Lines added in edit (added_lines) | [
0 => '{{infobox proglang',
1 => '|name=AlphaStack',
2 => '|paradigms=imperative',
3 => '|author=[[User:Glax]]',
4 => '|year=[[:Category:2026|2026]]',
5 => '|memsys=[[:Category:Stack-based|Stack-based]]',
6 => '|dimensions=one-dimensional',
7 => '|class=[[:Category:Turing complete|Turing complete]]',
8 => '|refimpl=[https://gitlab.com/mattia.basaglia/dragon.best/-/blob/master/media/scripts/alphastack/alphastack.py alphastack.py]',
9 => '}}',
10 => '',
11 => '[[Category:Languages]]',
12 => '[[Category:2026]]',
13 => '[[Category:Stack-based]]',
14 => '[[Category:Turing complete]]',
15 => '[[Category:Deterministic]]',
16 => '[[Category:Implemented]]',
17 => '',
18 => '<h2>Introduction</h2>',
19 => '',
20 => '<p><em>AlphaStack</em> is an stack-based language that uses only letters of the alphabet as values and instructions.</p>',
21 => '',
22 => '<p>Being stack based, the instructions typically pop their arguments from the stacks and push their results onto the stack.</p>',
23 => '',
24 => '<p>You can try this language at its official [https://dragon.best/alphastack/#playground web playground].</p>',
25 => '',
26 => '<h3>Examples</h3>',
27 => '',
28 => '<h4>Hello World</h4>',
29 => '',
30 => '<pre>a pd djro pa w pb w pc ojje xjbk pa h pb l sps ao pppp spsps pppp sp</pre>',
31 => '',
32 => '<h4>99 Bottles of beer</h4>',
33 => '',
34 => '<pre>vdyppsjepkkjesjeejesjdejidsjfexexjacjdjcsjfadaajasjbaabjpsppppppspsppspsppppspsp',
35 => 'pppspspppspsppppspsjepkaptakecpwaponecpwapdowncpwappasscpwapitcpwaparoundepkjesj',
36 => 'dejesjeejesjdejyyhesppppspsppspspppppppspsppppspsppsesjceapnocpwapmorecpwapbottx',
37 => 'escpwapofcpwapbeerzeejyypsppppspspppspsppspsesjcecpwaponcpwapthecpwapwaxxepkzjyy',
38 => 'ppppspsppspspppppppspsesjcecpwapbottxescpwapofcpwapbeerzjesjbejyysoassjanaakbxzb',
39 => 'njyyppsjcpjppeesjaejsjzpjcjbjcjbjyyasjdaakjwjbdjpsjzpjasjeaakjcjbjcjbjynbqjkblao',
40 => 'sdddddddlalr</pre>',
41 => '',
42 => '<h3 id="stack">Stacks and Procedures</h3>',
43 => '',
44 => '<p><em>AlphaStack</em> has two stacks:</p>',
45 => '',
46 => '<p>The value stack is where most operations happens, with individual letters being pushed and popped into it.</p>',
47 => '',
48 => '<p>The procedure stack contains procedures, the only instruction that can add to this stack is [[#d_-_Define|d]] and some other instructions can access the data stored there.</p>',
49 => '',
50 => '<p>A procedure is a sequence of letters that can be executed at a later time.',
51 => 'Procedures only ever exist on the procedure stack.</p>',
52 => '',
53 => '<p>This manual will often show a summary of an operation as follows:</p>',
54 => '',
55 => '<table class="wikitable">',
56 => ' <tr><td><span class="operand">op1</span><span class="operand">op2</span></td>',
57 => ' <td><code class="instruction">a</code></td>',
58 => ' <td><span class="operand">result</span></td></tr>',
59 => '</table>',
60 => '<p>This shows the instruction <code class="instruction">a</code> and its effect on the stack.',
61 => 'Values before it in the summary represent the top of the stack before the execution of that instruction.',
62 => 'Values after it represent what the head of the stack has been replaced with.',
63 => 'In this example, <code class="operand">op1</code> and <code class="operand">op2</code> will be popped off the stack',
64 => 'and <code class="operand">result</code> will be popped onto the stack.',
65 => '</p>',
66 => '',
67 => '<h3 id="literal-mode">Literal Mode</h3>',
68 => '',
69 => '<p><em>AlphaStack</em> has two modes: literal mode and instruction mode.</p>',
70 => '',
71 => '<p>In literal mode all valid characters are pushed directly onto the stack until the mode is switched.</p>',
72 => '',
73 => '<p>In instruction mode, all charcters are interpreted as instructions and executed immediately.</p>',
74 => '',
75 => '<p>The instruction [[#l_-_Literal|l]] is used to switch between these two modes, and it's the only',
76 => 'instruction to have an effect in literal mode.</p>',
77 => '',
78 => '<p>Program execution always starts in literal mode so you can add data before adding code.</p>',
79 => '',
80 => '<h3>Comments</h3>',
81 => '',
82 => '<p><em>AlphaStack</em> doesn't directly support comments but there are a few techniques to simulate them.</p>',
83 => '',
84 => '<p>All examples in this section are a print the characters <code>a</code> and <code>b</code> using',
85 => '<code>alp</code> and <code>lblp</code> respectively.',
86 => '',
87 => '<p>First of all, all characters that are not lower case ASCII characters are ignored, so you can always add',
88 => 'spaces, upper case letter, and special character.</p>',
89 => '',
90 => '<pre>alp SPACES AND UPPER CASE LETTERS ARE IGNORED! lblp</pre>',
91 => '',
92 => '<p>Since yelling in every comment is considered ruse there's an alternative:',
93 => 'using the [[#l_-_Literal|l]] instruction you can start pushing values onto the stack, then',
94 => 'clear it with [[#u_-_Undo|u]]. Note that [[#u_-_Undo|u]] needs a marker (which can be any letter)',
95 => 'to stop clearing the stack so you can't use that character in the comment.</p>',
96 => '',
97 => '<pre>alp lx this is pushed then popped from the stack, so it has no effect on the program xlu lblp</pre>',
98 => '<p>One side effect of this is that you can't use the marker letter (<code>x</code> in this example) nor single <code>l</code>s',
99 => 'in this style of comment as those they will switch back to instruction mode.',
100 => 'Pairs of <code>l</code>s will work as switching modes twice has no effect.</p>',
101 => '<pre>alp lx Hello comment! xlu lblp</pre>',
102 => '',
103 => '<h3>Numbers</h3>',
104 => '',
105 => '<p>In <em>AlphaStack</em> there are only letters, no numbers.',
106 => 'However can consider interpret the letters as numbers based on their position in the alphabet.',
107 => 'With this in mind, <code>a</code> can be thought as 0, <code>b</code> as 1 and so on.</p>',
108 => '<p>Similarly, the value <code>a</code> is considered false, while all other values are considered true.</p>',
109 => '',
110 => '<h3>Registers</h3>',
111 => '',
112 => '<p>Each letter has a register associated with it. These registered can be freely',
113 => 'written to or read from (using [[#s_-_Set|s]] and [[#g_-_Get|g]]).',
114 => 'Some instructions modify their behaviour based on the value of the corresponding register.</p>',
115 => '',
116 => '<p>At the start of a program all registers have a value of <code>a</code> (0).</p>',
117 => '',
118 => '',
119 => '<h2>Tutorial</h2>',
120 => '',
121 => '<p>This section will walk through the basics of <em>AlphaStack</em> with some practical examples.',
122 => 'The tutorials assume you've been through the [[#Introduction|introduction]] fist.</p>',
123 => '',
124 => '<h3>Hello World</h3>',
125 => '',
126 => '<p>This tutorial shows the basics of printing text to standard output</p>',
127 => '',
128 => '<pre>abcd</pre>',
129 => '',
130 => '<p>Since a program starts in [[#Literal_Mode|literal mode]],',
131 => 'this code pushes <code>abcd</code> onto the [[#Stacks_and_Procedures|value stack]].',
132 => '<code>d</code> being at the top of the stack and <code>a</code> at the bottom.</p>',
133 => '',
134 => '<pre>abcd l</pre>',
135 => '',
136 => '<p>Any characters that are not letters are ignored, so the space does nothing.',
137 => '[[#l_-_Literal|l]] exits literal mode and enters instruction mode.',
138 => 'This means after it letters will be executed as instructions rather than pushed onto the stack.</p>',
139 => '',
140 => '<pre>abcd l pppp</pre>',
141 => '',
142 => '<p>Here [[#p_-_Print|p]] is executed 4 times, printing 4 letters off the top of the stack.',
143 => 'This clears the stack as each letter is popped before printing and outputs <code>dbca</code>. <br/>',
144 => 'The order of the letters is reversed because they are printed from the top of the stack.</p>',
145 => '',
146 => '<p>Now, if we want to print <code>abcd</code> as numbers instead, we need to set the [[#p_-_Print_Mode_Register|p register]] to <code>c</code> first, this is done with the [[#s_-_Set|s]] command which pops a',
147 => 'reister and its value off the stack:</p>',
148 => '',
149 => '<pre>abcd pc l s pppp</pre>',
150 => '',
151 => '<p>Here <code>pc</code> on the stack is consumed by [[#s_-_Set|s]] to do just that',
152 => 'and the code outputs <code>3210</code>.</p>',
153 => '',
154 => '<p>Again, spaces are not meaningful in <em>AlphaStack</em> in the example they are used to',
155 => 'highlight which literals are used by which instuction.</p>',
156 => '',
157 => '<p>If you want to enter values in literal mode and then print them in the same order as',
158 => 'they were pushed onto the stack, you need to flip them around first:</p>',
159 => '',
160 => '<pre>abcd e l f pppp</pre>',
161 => '',
162 => '<p>Now [[#f_-_Flip|f]] pops <code>e</code> off the stack, this corresponds',
163 => 'with the number 4, and flips that many items on the stack. In this case the stack',
164 => 'ends up as <code>dbca</code>, printing <code>abcd</code>.</p>',
165 => '',
166 => '<p>Let's say we want to print the word "hello". There's an issue here,',
167 => '[[#l_-_Literal|l]] switches between literal mode and instruction mode',
168 => 'so it can't be directly entered as a literal.',
169 => 'To work around this we can push a value <code>l</code> onto the stack by',
170 => 'performing a simple mathematical operation:',
171 => '</p>',
172 => '',
173 => '<pre>kb l a p</pre>',
174 => '',
175 => '<p>[[#a_-_Arithmetic_Operation|a]] pops two values off the stack and adds them together,',
176 => 'in this case adds <code>b</code> (1) to <code>k</code>, obtaining <code>l</code>.',
177 => 'Then [[#p_-_Print|p]] prints it.</p>',
178 => '',
179 => '<p>Now we can print hello like so:</p>',
180 => '',
181 => '<pre>o kb kb e h l p p ap ap p</pre>',
182 => '',
183 => '<p>The first two [[#p_-_Print|p]] print <code>h</code> and <code>e</code>',
184 => 'respectively. Then [[#a_-_Arithmetic_Operation|a]] followed by [[#p_-_Print|p]] print an <code>l</code>, this is done twice. The final [[#p_-_Print|p]] prints',
185 => 'the <code>o</code>.</p>',
186 => '',
187 => '<p>Replacing each <code>l</code> individually can become tedious so we can push a single',
188 => 'one onto the stack and then replace a different character with it.</p>',
189 => '',
190 => '<code>oxxeh yxkb l a o ppppp</code>',
191 => '',
192 => '<p>Here [[#a_-_Arithmetic_Operation|a]] turns <code>kb</code> into <code>l</code> like before.',
193 => '[[#o_-_Overwrite|o]] then pops the 3 topmost items on the stack: <code>yxl</code>.',
194 => 'It then performs a replacement of the values on the stack with as follows:',
195 => 'all occurrences of <code>x</code> are replaced by <code>l</code> until the next',
196 => '<code>y</code> is reached. In this case there are no <code>y</code> values on the stack',
197 => 'after the initial one so the entire stack is processed.',
198 => 'Finally the five [[#p_-_Print|p]] print <code>hello</code>.</p>',
199 => '',
200 => '<p>We can combine all of this with different print modes to print <code>Hello World!</code>:</p>',
201 => '',
202 => '<pre>a pd djro pa w pb w pc ojje xjbk pa h pb l sps ao pppp spsps pppp sp</pre>',
203 => '',
204 => '<h3>Procedures and Loops</h3>',
205 => '',
206 => '<p>Let's say you don't want to type a [[#p_-_Print|p]] for every single letters you',
207 => 'want to output. We can create a procedure that prints the stack until a condition is met.</p>',
208 => '',
209 => '<p>First we need to get a condition that checks the top of the stack for a given value and',
210 => 'halts execution when found.',
211 => 'Conditionals are handled by [[#i_-_If|i]], which needs a procedure to run when the condition is met.',
212 => 'We start by defining the halting procedure:/p>',
213 => '',
214 => '<pre>xhx l d</pre>',
215 => '',
216 => '<p>[[#d_-_Define|d]] here uses <code>x</code> as a delimiter',
217 => 'and pushes a procedure containing <code>h</code> on top of the procedure stack.</p>',
218 => '',
219 => '<p>Now we are ready to define the main procedure.',
220 => 'Since we need literals in the main procedure we need to perform the usual trick to replace',
221 => '<code>j</code> with <code>l</code>:</p>',
222 => '',
223 => '<pre>xpikacjbzjx jbk ob xhx l d sao d</pre>',
224 => '',
225 => '<p>This code starts as before with [[#d_-_Define|d]] popping <code>xhx</code> from the value',
226 => 'stack and pushing <code>h</code> onto the procedure stack.',
227 => 'Then <code>sao</code> performs the <code>j</code> to <code>l</code> replacement:',
228 => '[[#s_-_Set|s]] pops <code>ob</code> to set the [[#o_-_Keep_Mark_Register|o register]] to keep the delimiter.',
229 => '[[#a_-_Arithmetic_Operation|a]] the pops <code>bk</code> to push a <code>l</code>.',
230 => '[[#o_-_Overwrite|o]] pops <code>jl</code> to replace all occurrences of <code>j</code> with <code>l</code>',
231 => 'using <code>x</code> as a delimiter. Since we set the [[#o_-_Keep_Mark_Register|o register]] register to the value',
232 => '<code>b</code> using [[#s_-_Set|s]], the <code>x</code> delimiters are not removed from the stack.',
233 => 'This allows [[#d_-_Define|d]] to use the same deimiter.</p>',
234 => '',
235 => '<p>Finally, [[#d_-_Define|d]] pops <code>xpikaclbzlx</code> from the value stack and pushes',
236 => '<code>lzblcakip</code> onto the procedure stack.',
237 => 'Note that [[#d_-_Define|d]] removes the delimiters from the procedure and reverses the order of its letters',
238 => 'so when you define procedures in literal mode, you need to flip them around.</p>',
239 => '',
240 => '<p>Now let's see that the code in the procedure does:</p>',
241 => '<pre>lzbl ca kip</pre>',
242 => '',
243 => '<p>[[#l_-_Literal|l]] toggles between modes so <code>lzbl</code> results in a literal',
244 => 'pushing <code>z</code> and <code>b</code> onto the stack.',
245 => '[[#c_-_Copy|c]] then pops <code>b</code> from the stack, this is a value of 1',
246 => 'which means [[#c_-_Copy|c]] copies the next item on the stack, skipping the <code>z</code>.',
247 => 'After [[#c_-_Copy|c]] the stack top of the contains a copy of the initial top of the stack followed by <code>z</code>.',
248 => '</p>',
249 => '',
250 => '<p>[[#a_-_Arithmetic_Operation|a]] then performs an operation on these two.',
251 => 'The operation performed by [[#a_-_Arithmetic_Operation|a]] is determined by the value of the [[#a_-_Operation_Register|a register]].',
252 => 'The default operation is addition but it will need to be set to equality comparison before the procedure is executed.',
253 => 'If the [[#a_-_Operation_Register|a register]] is set to comparison, [[#a_-_Arithmetic_Operation|a]] will pop the two letters off the top',
254 => 'of the stack and push true (<code>b</code>) or false (<code>a</code>) depending whether they are the same.</p>',
255 => '',
256 => '<p>Follows [[#k_-_Keep|k]] which copies the top procedure from the procedure stack, this is requires to prevent',
257 => '[[#i_-_If|i]] from consuming it since we are looping.',
258 => '[[#i_-_If|i]] consumes the copied procedure and the result of the comparison, executing the procedure if the',
259 => 'result is true (<code>b</code>). When the procedure is executed, the program halts (this procedure is <code>h</code>, which was defined',
260 => 'at the start.',
261 => 'Finally [[#p_-_Print|p]] pops and prints the top of the stack. This only happens if the condition was false as it means the program',
262 => 'was not halted.',
263 => '</p>',
264 => '',
265 => '<p>Final bit of setup:</p>',
266 => '<pre>a af xpikacjbzjx jbk ob xhx l d sao d s r</pre>',
267 => '',
268 => '<p>Here is the same but there is more data onto the stack and two more instructions.',
269 => 'The second [[#s_-_Set|s]] pops <code>af</code> to set the [[#a_-_Arithmetic_Operation|a]] to equality',
270 => 'comparison mode. Then [[#r_-_Repeat|r]] will pop the remaining <code>a</code> which means it will loop',
271 => 'forever (or in this case until halted.</p>',
272 => '',
273 => '<p>Now all that's needed is some data on the stack to be printed, using <code>z</code> as a delimiter',
274 => '(since it's the value we're comparing against on the procedure).</p>',
275 => '',
276 => '<pre>z kcatsehtgnitnirp a af xpikacjbzjx jbk ob xhx l d sao d s r</pre>',
277 => '',
278 => 'Output:',
279 => '<pre>printingthestack</pre>',
280 => '',
281 => '<h2>Alphabet</h2>',
282 => '',
283 => '<p><em>AlphaStack</em> uses the 26 (lower case) letters of the Latin alphabet.',
284 => 'All other characters are ignores, including upper case letters.</p>',
285 => '',
286 => '<table class="wikitable">',
287 => ' <tr><th>Letter</th><th>Numerical</th><th>Instruction</th><th>Register</th><th colspan='3'>Summary</th></tr>',
288 => ' <tr><th>a</th><td class='letterval'>0</td>',
289 => ' <td>[[#a_-_Arithmetic_Operation|Arithmetic Operation]]</td>',
290 => ' <td>[[#a_-_Operation_Register|Operation]]</td>',
291 => ' <td class='summary-col'><span class='operand'>num1</span><span class='operand'>num2</span></td>',
292 => ' <td class='summary-col'><code class='instruction'>a</code></td>',
293 => ' <td class='summary-col'><span class='operand'>num3</span></td></tr>',
294 => ' <tr><th>b</th><td class='letterval'>1</td>',
295 => ' <td>[[#b_-_Break|Break]]</td>',
296 => ' <td></td>',
297 => ' <td class='summary-col'></td>',
298 => ' <td class='summary-col'><code class='instruction'>b</code></td>',
299 => ' <td class='summary-col'></td></tr>',
300 => ' <tr><th>c</th><td class='letterval'>2</td>',
301 => ' <td>[[#c_-_Copy|Copy]]</td>',
302 => ' <td></td>',
303 => ' <td class='summary-col'><span class='operand'>val</span><span class='operand'>...</span><span class='operand'>index</span></td>',
304 => ' <td class='summary-col'><code class='instruction'>c</code></td>',
305 => ' <td class='summary-col'><span class='operand'>val</span><span class='operand'>...</span><span class='operand'>val</span></td></tr>',
306 => ' <tr><th>d</th><td class='letterval'>3</td>',
307 => ' <td>[[#d_-_Define|Define]]</td>',
308 => ' <td></td>',
309 => ' <td class='summary-col'><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span></td>',
310 => ' <td class='summary-col'><code class='instruction'>d</code></td>',
311 => ' <td class='summary-col'></td></tr>',
312 => ' <tr><th>e</th><td class='letterval'>4</td>',
313 => ' <td>[[#e_-_Execute_Specific|Execute Specific]]</td>',
314 => ' <td>[[#e_-_Execute_Index_Register|Execute Index]]</td>',
315 => ' <td class='summary-col'></td>',
316 => ' <td class='summary-col'><code class='instruction'>e</code></td>',
317 => ' <td class='summary-col'></td></tr>',
318 => ' <tr><th>f</th><td class='letterval'>5</td>',
319 => ' <td>[[#f_-_Flip|Flip]]</td>',
320 => ' <td></td>',
321 => ' <td class='summary-col'><span class='operand'>...</span><span class='operand'>count</span></td>',
322 => ' <td class='summary-col'><code class='instruction'>f</code></td>',
323 => ' <td class='summary-col'><span class='operand'>...</span></td></tr>',
324 => ' <tr><th>g</th><td class='letterval'>6</td>',
325 => ' <td>[[#g_-_Get|Get]]</td>',
326 => ' <td></td>',
327 => ' <td class='summary-col'><span class='operand'>reg</span></td>',
328 => ' <td class='summary-col'><code class='instruction'>g</code></td>',
329 => ' <td class='summary-col'><span class='operand'>val</span></td></tr>',
330 => ' <tr><th>h</th><td class='letterval'>7</td>',
331 => ' <td>[[#h_-_Halt|Halt]]</td>',
332 => ' <td></td>',
333 => ' <td class='summary-col'></td>',
334 => ' <td class='summary-col'><code class='instruction'>h</code></td>',
335 => ' <td class='summary-col'></td></tr>',
336 => ' <tr><th>i</th><td class='letterval'>8</td>',
337 => ' <td>[[#i_-_If|If]]</td>',
338 => ' <td>[[#i_-_If_Else_Count_Register|If Else Count]]</td>',
339 => ' <td class='summary-col'><span class='operand'>valn</span><span class='operand'>...</span><span class='operand'>val0</span></td>',
340 => ' <td class='summary-col'><code class='instruction'>i</code></td>',
341 => ' <td class='summary-col'></td></tr>',
342 => ' <tr><th>j</th><td class='letterval'>9</td>',
343 => ' <td></td>',
344 => ' <td></td>',
345 => ' <td class='summary-col'></td>',
346 => ' <td class='summary-col'></td>',
347 => ' <td class='summary-col'></td></tr>',
348 => ' <tr><th>k</th><td class='letterval'>10</td>',
349 => ' <td>[[#k_-_Keep|Keep]]</td>',
350 => ' <td>[[#k_-_Keep_Count_Register|Keep Count]]</td>',
351 => ' <td class='summary-col'></td>',
352 => ' <td class='summary-col'><code class='instruction'>k</code></td>',
353 => ' <td class='summary-col'></td></tr>',
354 => ' <tr><th>l</th><td class='letterval'>11</td>',
355 => ' <td>[[#l_-_Literal|Literal]]</td>',
356 => ' <td>[[#l_-_Mode_Register|Mode]]</td>',
357 => ' <td class='summary-col'></td>',
358 => ' <td class='summary-col'><code class='instruction'>l</code></td>',
359 => ' <td class='summary-col'></td></tr>',
360 => ' <tr><th>m</th><td class='letterval'>12</td>',
361 => ' <td>[[#m_-_Memory|Memory]]</td>',
362 => ' <td>[[#m_-_Memory_Cell_Register|Memory Cell]]</td>',
363 => ' <td class='summary-col'></td>',
364 => ' <td class='summary-col'><code class='instruction'>m</code></td>',
365 => ' <td class='summary-col'><span class='operand'>val</span></td></tr>',
366 => ' <tr><th>n</th><td class='letterval'>13</td>',
367 => ' <td>[[#n_-_Number_of_Items|Number of Items]]</td>',
368 => ' <td>[[#n_-_Number_Size_Register|Number Size]]</td>',
369 => ' <td class='summary-col'></td>',
370 => ' <td class='summary-col'><code class='instruction'>n</code></td>',
371 => ' <td class='summary-col'><span class='operand'>count</span></td></tr>',
372 => ' <tr><th>o</th><td class='letterval'>14</td>',
373 => ' <td>[[#o_-_Overwrite|Overwrite]]</td>',
374 => ' <td>[[#o_-_Keep_Mark_Register|Keep Mark]]</td>',
375 => ' <td class='summary-col'><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span><span class='operand'>search</span><span class='operand'>replace</span></td>',
376 => ' <td class='summary-col'><code class='instruction'>o</code></td>',
377 => ' <td class='summary-col'><span class='operand'>...</span></td></tr>',
378 => ' <tr><th>p</th><td class='letterval'>15</td>',
379 => ' <td>[[#p_-_Print|Print]]</td>',
380 => ' <td>[[#p_-_Print_Mode_Register|Print Mode]]</td>',
381 => ' <td class='summary-col'><span class='operand'>val</span></td>',
382 => ' <td class='summary-col'><code class='instruction'>p</code></td>',
383 => ' <td class='summary-col'></td></tr>',
384 => ' <tr><th>q</th><td class='letterval'>16</td>',
385 => ' <td></td>',
386 => ' <td></td>',
387 => ' <td class='summary-col'></td>',
388 => ' <td class='summary-col'></td>',
389 => ' <td class='summary-col'></td></tr>',
390 => ' <tr><th>r</th><td class='letterval'>17</td>',
391 => ' <td>[[#r_-_Repeat|Repeat]]</td>',
392 => ' <td></td>',
393 => ' <td class='summary-col'><span class='operand'>count</span></td>',
394 => ' <td class='summary-col'><code class='instruction'>r</code></td>',
395 => ' <td class='summary-col'></td></tr>',
396 => ' <tr><th>s</th><td class='letterval'>18</td>',
397 => ' <td>[[#s_-_Set|Set]]</td>',
398 => ' <td></td>',
399 => ' <td class='summary-col'><span class='operand'>reg</span><span class='operand'>val</span></td>',
400 => ' <td class='summary-col'><code class='instruction'>s</code></td>',
401 => ' <td class='summary-col'></td></tr>',
402 => ' <tr><th>t</th><td class='letterval'>19</td>',
403 => ' <td>[[#t_-_Text_Input|Text Input]]</td>',
404 => ' <td>[[#t_-_Read_Result_Register|Read Result]]</td>',
405 => ' <td class='summary-col'></td>',
406 => ' <td class='summary-col'><code class='instruction'>t</code></td>',
407 => ' <td class='summary-col'><span class='operand'>val?</span></td></tr>',
408 => ' <tr><th>u</th><td class='letterval'>20</td>',
409 => ' <td>[[#u_-_Undo|Undo]]</td>',
410 => ' <td></td>',
411 => ' <td class='summary-col'><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span></td>',
412 => ' <td class='summary-col'><code class='instruction'>u</code></td>',
413 => ' <td class='summary-col'></td></tr>',
414 => ' <tr><th>v</th><td class='letterval'>21</td>',
415 => ' <td></td>',
416 => ' <td></td>',
417 => ' <td class='summary-col'></td>',
418 => ' <td class='summary-col'></td>',
419 => ' <td class='summary-col'></td></tr>',
420 => ' <tr><th>w</th><td class='letterval'>22</td>',
421 => ' <td>[[#w_-_Wrap|Wrap]]</td>',
422 => ' <td></td>',
423 => ' <td class='summary-col'><span class='operand'>...</span><span class='operand'>count</span><span class='operand'>steps</span></td>',
424 => ' <td class='summary-col'><code class='instruction'>w</code></td>',
425 => ' <td class='summary-col'><span class='operand'>...</span></td></tr>',
426 => ' <tr><th>x</th><td class='letterval'>23</td>',
427 => ' <td>[[#x_-_Execute|Execute]]</td>',
428 => ' <td></td>',
429 => ' <td class='summary-col'></td>',
430 => ' <td class='summary-col'><code class='instruction'>x</code></td>',
431 => ' <td class='summary-col'></td></tr>',
432 => ' <tr><th>y</th><td class='letterval'>24</td>',
433 => ' <td>[[#y_-_Yield|Yield]]</td>',
434 => ' <td></td>',
435 => ' <td class='summary-col'></td>',
436 => ' <td class='summary-col'><code class='instruction'>y</code></td>',
437 => ' <td class='summary-col'></td></tr>',
438 => ' <tr><th>z</th><td class='letterval'>25</td>',
439 => ' <td></td>',
440 => ' <td></td>',
441 => ' <td class='summary-col'></td>',
442 => ' <td class='summary-col'></td>',
443 => ' <td class='summary-col'></td></tr>',
444 => '</table>',
445 => '',
446 => '<h2>Letter Details</h2>',
447 => '',
448 => '<h3 id='a-instruction'><span class='instruction'>a</span> - Arithmetic Operation</h3>',
449 => '',
450 => ''''Synopsis'''',
451 => '',
452 => '<table class="wikitable synopsis"><tr><td><span class='operand'>num1</span><span class='operand'>num2</span></td><td><code>a</code></td><td><span class='operand'>num3</span></td></tr></table>',
453 => '<p>The <span class="instruction">a</span> pops two values from the stack,',
454 => 'performs a mathematical operation on them and pushes the result back onto the stack.',
455 => 'In all cases <code class="operand">num1</code> is the left hand side operand and',
456 => '<code class="operand">num2</code> is the right hand side operand.</p>',
457 => '',
458 => '<p>The specific operation to be performed on the two operands depends on the value of the <span class="instruction">a</span> register.</p>',
459 => '<h3 id='a-register'><span class='instruction'>a</span> - Operation Register</h3>',
460 => '<table class="wikitable">',
461 => ' <tr>',
462 => ' <th>Value</th>',
463 => ' <th>Name</th>',
464 => ' <th>Operation</th>',
465 => ' </tr>',
466 => ' <tr><th class='operand'>a</th><td>Addition</td><td class='operand'>val3 = val1 + val2</td></tr>',
467 => ' <tr><th class='operand'>b</th><td>Subtraction</td><td class='operand'>val3 = val1 - val2</td></tr>',
468 => ' <tr><th class='operand'>c</th><td>Multiplication</td><td class='operand'>val3 = val1 * val2</td></tr>',
469 => ' <tr><th class='operand'>d</th><td>Integer division</td><td class='operand'>val3 = val1 / val2</td></tr>',
470 => ' <tr><th class='operand'>e</th><td>Modulo</td><td class='operand'>val3 = val1 % val2</td></tr>',
471 => ' <tr><th class='operand'>f</th><td>Equality comparison</td><td class='operand'>val3 = val1 == val2</td></tr>',
472 => ' <tr><th class='operand'>g</th><td>Greater than</td><td class='operand'>val3 = val1 > val2</td></tr>',
473 => ' <tr><th class='operand'>h</th><td>Greater or equal</td><td class='operand'>val3 = val1 >= val2</td></tr>',
474 => ' <tr><th class='operand'>i</th><td>Less or equal</td><td class='operand'>val3 = val1 <= val2</td></tr>',
475 => ' <tr><th class='operand'>j</th><td>Less than</td><td class='operand'>val3 = val1 < val2</td></tr>',
476 => ' <tr><th class='operand'>k</th><td>Not equal</td><td class='operand'>val3 = val1 != val2</td></tr>',
477 => '</table>',
478 => '',
479 => ''''Examples'''',
480 => '',
481 => 'Code:',
482 => '<pre>cdlap</pre>',
483 => '',
484 => 'Output:',
485 => '<pre>f</pre>',
486 => '',
487 => '<p>The program starts in literal mode, so <code class="operand">c</code> and <code class="operand">d</code>',
488 => 'are pushed onto the stack as data.<br/>',
489 => '[[#l_-_Literal|l]] disables literal mode, so [[#a_-_Arithmetic_Operation|a]] is executed as an instruction. It pops <code class="operand">c</code> (2) and <code class="operand">d</code> (3)',
490 => 'from the stack calculates their sum, <code class="operand">f</code> (5), then pushes it onto the stack.<br/>',
491 => 'Finally, [[#p_-_Print|p]] prints the top of the stack to standard output.</p>',
492 => '',
493 => 'Code:',
494 => '<pre>czlap</pre>',
495 => '',
496 => 'Output:',
497 => '<pre>b</pre>',
498 => '',
499 => '<p>This example adds <code class="operand">c</code> (2) and <code class="operand">z</code> (25). Ther output is',
500 => '<code class="operand">b</code> (1) because math operations are modulo 26.</p>',
501 => '',
502 => '',
503 => 'Code:',
504 => '<pre>cdaclsap</pre>',
505 => '',
506 => 'Output:',
507 => '<pre>g</pre>',
508 => '',
509 => '<p>This example multiplies <code class="operand">c</code> (2) and <code class="operand">d</code> (3).',
510 => 'This is achieved by setting the [[#a_-_Operation_Register|a register]] to <code class="operand">c</code> using [[#s_-_Set|s]].',
511 => '</p>',
512 => '',
513 => '<h3 id='b-instruction'><span class='instruction'>b</span> - Break</h3>',
514 => '',
515 => ''''Synopsis'''',
516 => '',
517 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>b</code></td><td></td></tr></table>',
518 => '<p>Breaks out of the current loop. Does not affect the stack.</p>',
519 => '',
520 => ''''Example'''',
521 => '',
522 => '<p>If we take this starting example:</p>',
523 => '',
524 => '<pre>xpkbl a labl c lxl d lal r</pre>',
525 => '',
526 => '<p>it will endlessly print <code>a</code>.</p>',
527 => '',
528 => '<p>The explanation chunk by chunk:</p>',
529 => '',
530 => '<pre>xpkbl a</pre>',
531 => '',
532 => '<p>Pushes <code>xpkb</code> onto the stack, then calls [[#a_-_Arithmetic_Operation|a]] to add <code>b</code> and <code>k</code> to obtain <code>l</code> since <code>l</code>',
533 => 'can't be pushed onto the stack directly, obtaining <code>xpl</code>.</p>',
534 => '',
535 => '<pre>labl c</pre>',
536 => '<p>Pushes <code>a</code> and copies the <code>l</code> with [[#c_-_Copy|c]] resulting with the stack <code>xplal</code>.</p>',
537 => '',
538 => '<pre>lxl d</pre>',
539 => '<p>Pushes <code>x</code> as a marker, then [[#d_-_Define|d]] rolls the stack betwen the two',
540 => '<code>x</code> markers into a procedure. Note that the procedure will be reversed compared to the other of the stack.',
541 => 'The procedure will be pushed into the procedure stack as <code>lalp</code>.</p>',
542 => '',
543 => '<pre>lal r</pre>',
544 => '<p>Pushes <code>a</code> onto the stack to create an infinite loop with [[#r_-_Repeat|r]], which',
545 => 'will pop the created procedure and loop it indefinitely. The procedure just prints <code>a</code> every time.',
546 => '</p>',
547 => '',
548 => 'If we add a break to the procedure the loop will stop after the first iteration:',
549 => '',
550 => '<pre>xbpkbl a labl c lxl d lal r</pre>',
551 => '',
552 => 'Output:',
553 => '<pre>a</pre>',
554 => '',
555 => '<h3 id='c-instruction'><span class='instruction'>c</span> - Copy</h3>',
556 => '',
557 => ''''Synopsis'''',
558 => '',
559 => '<table class="wikitable synopsis"><tr><td><span class='operand'>val</span><span class='operand'>...</span><span class='operand'>index</span></td><td><code class='instruction'>c</code></td><td><span class='operand'>val</span><span class='operand'>...</span><span class='operand'>val</span></td></tr></table>',
560 => '<p>Copies a value <code class="operand">index</code> positions into the stack.</p>',
561 => '',
562 => '<p>It pops <code class="operand">index</code>, looks into the stack from the top',
563 => 'that many spaces, and pushes a copy of the corresponding value on top of the stack.</p>',
564 => '',
565 => ''''Example'''',
566 => '',
567 => '<pre>somedatafl c</pre>',
568 => '',
569 => '<p>This pushes <code>somedataf</code> onto the stack then executes [[#c_-_Copy|c]].',
570 => 'It will pop <code>f</code> (5), then look that many spaces down the remaining stack, find',
571 => '<code>m</code> and copy it on top of the stack. This results in a stack of <code>somedatam</code>.',
572 => '</p>',
573 => '',
574 => '<h3 id='d-instruction'><span class='instruction'>d</span> - Define</h3>',
575 => '',
576 => ''''Synopsis'''',
577 => '',
578 => '<table class="wikitable synopsis"><tr><td><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span></td><td><code class='instruction'>d</code></td><td></td></tr></table>',
579 => '<p>Defines a procedure delimited by <code class="operand">mark</code> and pushes it on the procedure stack.</p>',
580 => '',
581 => '<p>It pops the first stack value, <code class="operand">mark</code> which can be anything, then keeps popping',
582 => 'until another value equal to <code class="operand">mark</code> is found (or the stack is empty).</p>',
583 => '',
584 => '<p>The result is then pushed onto the procedure stack, with the values flipped compared to how they were in the initial stack.',
585 => 'The flip happens because values are pushed onto the procedure as they are popped from the stack.</p>',
586 => '',
587 => '',
588 => ''''Example'''',
589 => '',
590 => 'This example uses a procedure and a loop to print the contents of the stack until a delimiter (<code>z</code>) is reached.',
591 => '',
592 => 'Code:',
593 => '<pre>zerudecorp a af xpikacjbzjx jbk xhx ob l sdaodsr</pre>',
594 => '',
595 => 'Output:',
596 => '<pre>procedure</pre>',
597 => '',
598 => '<p>Before the [[#l_-_Literal|l]] all the letter are pushed onto the stack. then the following operations are performed:</p>',
599 => '',
600 => '<p>[[#s_-_Set|s]] pops <code>ob</code> and sets the [[#o_-_Keep_Mark_Register|o register]] is set to keep the delimiter.</p>',
601 => '<p>[[#d_-_Define|d]] pops <code>xhx</code> and pushes <code>h</code> as a procedure.',
602 => 'Here we are using <code>x</code> as a delimiter but any letter works as delimiter, just ensure it isn't used with the procedure itself.',
603 => '</p>',
604 => '<p>[[#a_-_Arithmetic_Operation|a]] pops <code>bk</code>, adds them, and pushes <code>l</code> (this is because <code>l</code> cannot be used as a literal).</p>',
605 => '<p>[[#o_-_Overwrite|o]] pops <code>jl</code> and preforms a replacement from <code>j</code> to <code>l</code>.',
606 => 'using <code>x</code> as delimiter. Results in changing the top of the stack from',
607 => '<code>xpikacjbzjx</code> to <code>xpikaclbzlx</code>. The <code>x</code> delimiters are preserved due to the value of',
608 => '[[#o_-_Keep_Mark_Register|o register]] that was set previously.',
609 => '</p>',
610 => '<p>[[#d_-_Define|d]] pops <code>xpikaclbzlx</code> and pushes <code>lzblcakip</code> as a procedure.</p>',
611 => '<p>[[#s_-_Set|s]] pops <code>af</code> and sets the [[#a_-_Operation_Register|a register]] to perform equality comparison.</p>',
612 => '<p>[[#r_-_Repeat|r]] pops <code>a</code> and performs the last procedure indefinitely.</p>',
613 => '',
614 => 'The code in the procedure does the following:',
615 => '<pre>lzbl c akip</pre>',
616 => '',
617 => '<p><code>lzbl</code> pushes <code>zb</code> onto the stack.</p>',
618 => '<p>[[#c_-_Copy|c]] pops <code>b</code> and copies the item below the head of the stack back on top.',
619 => 'This copies the value set at the start of the main code',
620 => '</p>',
621 => '<p>[[#a_-_Arithmetic_Operation|a]] pops the copied value and <code>b</code> from the stack pushing <code>b</code> (true)',
622 => 'or <code>a</code> (false) based on their comparison (because [[#a_-_Operation_Register|a register]] is set to comparison.</p>',
623 => '<p>[[#k_-_Keep|k]] duplicates the top procedure.',
624 => 'Note that [[#r_-_Repeat|r]] pops the procedure before looping so the top procedure is now <code>h</code>.</p>',
625 => '<p>[[#i_-_If|i]] pops the value left by [[#a_-_Arithmetic_Operation|a]] and the procedure duplicated by [[#k_-_Keep|k]].',
626 => 'If the result of the comparison is true, (the letter copied by [[#c_-_Copy|c]] is <code>z</code>), it will call the procedure',
627 => 'which in turns halts the program using [[#h_-_Halt|h]].',
628 => 'If the condition is not true nothing else happens.</p>',
629 => '<p>[[#p_-_Print|p]] pops the top of the stack and prints it. This causes the stack size to decrease by one.</p>',
630 => '<p>After this [[#r_-_Repeat|r]] keeps repeating the procedure, which has the effect of printing the stack',
631 => 'until the character <code>z</code> is reached.</p>',
632 => '',
633 => '<h3 id='e-instruction'><span class='instruction'>e</span> - Execute Specific</h3>',
634 => '',
635 => ''''Synopsis'''',
636 => '',
637 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>e</code></td><td></td></tr></table>',
638 => '<p>Executes a specific procedure based on [[#e_-_Execute_Index_Register|e register]], not affecting any of the stacks.</p>',
639 => '',
640 => '<p>This is handy to repeatedly calling a procedure without having to modify stack values.</p>',
641 => '',
642 => '<h3 id='e-register'><span class='instruction'>e</span> - Execute Index Register</h3> <p>Procedure index for [[#e_-_Execute_Specific|e]]. A value of <code>a</code> (0), which is the default',
643 => 'means the first procedure.<p>',
644 => '',
645 => '<p>This index is counted from the bottom of the procedure stack.</p>',
646 => '',
647 => ''''Example'''',
648 => '',
649 => 'Code:',
650 => '<pre>tset xqx xax xpx xhx eb l s dddd eeee</pre>',
651 => '',
652 => 'Output:',
653 => '<pre>test</pre>',
654 => '',
655 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]].</p>',
656 => '<p>[[#s_-_Set|s]] pops <code>eb</code> and sets the [[#e_-_Execute_Index_Register|e register]] is set to <code>b</code> (1).</p>',
657 => '<p>[[#d_-_Define|d]] is called 4 times and it defines procedures based on the <code>x</code> delimiter.',
658 => 'After this the procedure stack has these procedures: <code>h</code>, <code>p</code>, <code>a</code>, <code>q</code>.',
659 => '</p>',
660 => '<p>[[#e_-_Execute_Specific|e]] is called 4 times as well, each time executing the procedure at index 1, which just prints the top of the stack.',
661 => 'Note that any procedure defined after the one with the given index doesn't matter as [[#e_-_Execute_Index_Register|e register]] refers to indices',
662 => 'starting from the bottom of the procedure stack.</p>',
663 => '',
664 => '',
665 => '<h3 id='f-instruction'><span class='instruction'>f</span> - Flip</h3>',
666 => '',
667 => ''''Synopsis'''',
668 => '',
669 => '<table class="wikitable synopsis"><tr><td><span class='operand'>...</span><span class='operand'>count</span></td><td><code class='instruction'>f</code></td><td><span class='operand'>...</span></td></tr></table>',
670 => '<p>Reverses the order of <code class="operand">count</code> items on the top of the stack.</p>',
671 => '',
672 => '<p>Pops <code class="operand">count</code>, then pops that many other items off the top of the stack',
673 => 'and pushes them back onto the stack but in reverse order.</p>',
674 => '',
675 => ''''Example'''',
676 => '',
677 => 'Code:',
678 => '<pre>foobar d l f</pre>',
679 => '',
680 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>foobard</code>.</p>',
681 => '<p>[[#f_-_Flip|f]] pops <code>d</code> (3), then flips the next 3 items on the stack, resulting with a stack of <code>foorab</code>.</p>',
682 => '',
683 => '',
684 => '<h3 id='g-instruction'><span class='instruction'>g</span> - Get</h3>',
685 => '',
686 => ''''Synopsis'''',
687 => '',
688 => '<table class="wikitable synopsis"><tr><td><span class='operand'>reg</span></td><td><code class='instruction'>g</code></td><td><span class='operand'>val</span></td></tr></table>',
689 => '<p>Pops <code class="operand">reg</code> from the stack, then pushes the value of the corresponding register onto the stack.</p>',
690 => '',
691 => ''''Example'''',
692 => '',
693 => 'Code:',
694 => '<pre>m mf l s g</pre>',
695 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>mmf</code>.</p>',
696 => '<p>[[#s_-_Set|s]] pops <code>mf</code> and sets the [[#m_-_Memory_Cell_Register|m register]] to <code>f</code>.</p>',
697 => '<p>[[#g_-_Get|g]] pops <code>m</code> and pushes its value (<code>f</code>) onto the stack, resulting in a stack with <code>f</code>.</p>',
698 => '',
699 => '<h3 id='h-instruction'><span class='instruction'>h</span> - Halt</h3>',
700 => '',
701 => ''''Synopsis'''',
702 => '',
703 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>h</code></td><td></td></tr></table>',
704 => '<p>Halts execution, without affecting the stack.</p>',
705 => '',
706 => ''''Example'''',
707 => '',
708 => 'Code:',
709 => '<pre>abcd l p p h p p</pre>',
710 => '',
711 => 'Output:',
712 => '<pre>dc</pre>',
713 => '',
714 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>abcd</code>.</p>',
715 => '<p>[[#p_-_Print|p]] is called twice popping <code>d</code> and <code>c</code> off the stack and printing them.</p>',
716 => '<p>[[#h_-_Halt|h]] halts execution so the remaining [[#p_-_Print|p]] calls are not executed.</p>',
717 => '',
718 => '<h3 id='i-instruction'><span class='instruction'>i</span> - If</h3>',
719 => '',
720 => ''''Synopsis'''',
721 => '',
722 => '<table class="wikitable synopsis"><tr><td><span class='operand'>valn</span><span class='operand'>...</span><span class='operand'>val0</span></td><td><code class='instruction'>i</code></td><td></td></tr></table>',
723 => '<p>Pops the top value from the stack and the top procedure off the top of the procedure stack.',
724 => 'If the value is true (anything but <code>a</code>), the procedure is then executed.</p>',
725 => '',
726 => '<p>The value of the [[#i_-_If_Else_Count_Register|i register]] defines if-else chain, [[#i_-_If|i]] will pop enough values and procedure to satisfy that many conditions.</p>',
727 => '',
728 => '',
729 => '<h3 id='i-register'><span class='instruction'>i</span> - If Else Count Register</h3> <p>Determines how many if-else chains are present (if any).</p>',
730 => '<p>The default value of <code>a</code> (0), indicates there is no else to execute.',
731 => '[[#i_-_If|i]] will pop a single value and procedure.</p>',
732 => '<p>A value of <code>b</code>, indicates an else procedure.',
733 => '[[#i_-_If|i]] will pop one value and two procedures, the second procedure',
734 => 'being executed if the condition is not true.</p>',
735 => '<p>For higher values of the [[#i_-_If_Else_Count_Register|i register]], [[#i_-_If|i]] will',
736 => 'pop additional values off the stack and procedures, executing the procedure of the first',
737 => 'matching condition (or the last procedure if no conditions match).</p>',
738 => '',
739 => ''''Examples'''',
740 => '',
741 => 'Code:',
742 => '<pre>z xjajx yjkb l ao d t i p</pre>',
743 => '',
744 => '<p>Output: <code>a</code> or <code>z</code> based on user input.</p>',
745 => '',
746 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>zxjajxyjkb</code>.</p>',
747 => '<p>[[#a_-_Arithmetic_Operation|a]] pops <code>bk</code>, adds them, and pushes <code>l</code> (this is because <code>l</code> cannot be used as a literal).</p>',
748 => '<p>[[#o_-_Overwrite|o]] pops <code>yjl</code> and preforms a replacement from <code>j</code> to <code>l</code>',
749 => 'until the end of the stack since there are no other <code>y</code> values on the stack.',
750 => 'All this results with a stack of <code>zxlalx</code>.</p>',
751 => '<p>[[#d_-_Define|d]] pops <code>xlalx</code> and pushes <code>lal</code> as a procedure. This procedure just pushes <code>a</code> onto the stack.</p>',
752 => '<p>[[#t_-_Text_Input|t]] reads a character from the user, converts it into a letter, and pushes it onto the stack.</p>',
753 => '<p>[[#i_-_If|i]] pops this user-generated value, the procedure, and if the value is true, the procedure is executed.',
754 => 'Now the stack is either <code>z</code> or <code>za</code>.</p>',
755 => '<p>[[#p_-_Print|p]] pops the top of the stack and prints it, printing <code>a</code> if',
756 => 'the user input evaluated as true, and <code>z</code> otherwise.</p>',
757 => '',
758 => 'Code:',
759 => '<pre>xjajx xjzjx yjkb ib l s ao dd t i p</pre>',
760 => '',
761 => '<p>This example has the same output as the previous one but it works slightly differently.</p>',
762 => '<p>The first operation after exiting literal mode is [[#s_-_Set|s]] to set [[#i_-_If_Else_Count_Register|i register]] to <code>b</code> (1).',
763 => 'This indicates that [[#i_-_If_Else_Count_Register|i register]] should use an else procedure.</p>',
764 => '<p>Now the next difference is that there are two procedures in the procedure stack: <code>lzl</code> and <code>lal</code>,',
765 => 'wich just push <code>z</code> or <code>a</code> onto the value stack.',
766 => 'Note that <code>lal</code> is the procedure on top of the stack because it has been pushed last.</p>',
767 => '<p>[[#i_-_If|i]] now pops both procedures off the procedure stack, executing the first on true and the second on false.</p>',
768 => '',
769 => 'Code:',
770 => '<pre>xjajx xjbjx xjcjx yjkb ic l s ao ddd tt lclf i p</pre>',
771 => '',
772 => '<p>This example takes 2 inputs from the user and selects one of 3 procedures to execute.</p>',
773 => '<p><code>tt</code> will read 2 inputs from the user and push them onto the stack.',
774 => 'since this will cause the inputs to be in reverse order (the last input is on top of the stack)',
775 => '<code>lclf</code> uses [[#f_-_Flip|f]] to flip them back around. Now the first',
776 => 'input is on top of the stack and the second input below it.</p>',
777 => '<p>The [[#i_-_If_Else_Count_Register|i register]] is set to <code>c</code> (2), indicating an else-if chain.</p>',
778 => '<p>[[#i_-_If|i]] now pops 2 values off the value stack and 3 procedures.',
779 => 'It uses the first value from the stack as the first condition, if that is true the first procedure is executed.',
780 => 'Otherwise, if the next value is true, the second procedure is executed.',
781 => 'Finally, if both values are false, the third procedure is executed.',
782 => '</p>',
783 => '',
784 => '<h3 id='k-instruction'><span class='instruction'>k</span> - Keep</h3>',
785 => '',
786 => ''''Synopsis'''',
787 => '',
788 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>k</code></td><td></td></tr></table>',
789 => '<p>Duplicates the procedure on top of the procedure stack.</p>',
790 => '',
791 => '<p>This is useful if you want to run [[#i_-_If|i]] or [[#x_-_Execute|x]] while keeping the procedure on the stack for later use.</p>',
792 => '',
793 => '<h3 id='k-register'><span class='instruction'>k</span> - Keep Count Register</h3> <p>Determines the number of procedures [[#k_-_Keep|k]] will copy.',
794 => 'The number is the value of this register plus one.</p>',
795 => '',
796 => ''''Example'''',
797 => '',
798 => 'Code:',
799 => '<pre>xpppjfoojx yjkb l ao d kxx</pre>',
800 => '',
801 => 'Output:',
802 => '<pre>foofoo</pre>',
803 => '',
804 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>xpppjfoojxyjkb</code>.</p>',
805 => '<p>[[#a_-_Arithmetic_Operation|a]] and [[#o_-_Overwrite|o]] ensure <code>j</code> values on the stack are replaced by <code>l</code> as',
806 => '<code>l</code> cannot be used as a literal. The stack after them is <code>xppplfoolx</code></p>',
807 => '<p>[[#d_-_Define|d]] defines the procedure <code>looflppp</code>, which prints the string "foo" to output.</p>',
808 => '',
809 => '<p>Finally [[#k_-_Keep|k]] duplicates this procedure, and [[#x_-_Execute|x]] is called twice, popping and',
810 => 'executing the two copies of the procedure.</p>',
811 => '',
812 => '<h3 id='l-instruction'><span class='instruction'>l</span> - Literal</h3>',
813 => '',
814 => ''''Synopsis'''',
815 => '',
816 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>l</code></td><td></td></tr></table>',
817 => '<p>Switches between literal and instruction modes.</p>',
818 => '<p>Specifically it toggles the [[#l_-_Literal|l]] register between',
819 => '<code>a</code> (0), which indicated literal mode, and <code>b</code> (1), instruction mode.</p>',
820 => '',
821 => '<p>While in instruction mode all letters are executed as an instruction.</p>',
822 => '<p>In literal mode (which is the mode at the start of execution) letters are',
823 => 'pushed onto the value stack.</p>',
824 => '',
825 => '<p>[[#l_-_Literal|l]] will keep its behaviour in both modes so the letter <code>l</code>',
826 => 'cannot appear directly as a literal.</p>',
827 => '',
828 => '<h3 id='l-register'><span class='instruction'>l</span> - Mode Register</h3> <p>Determines whether the program is in literal mode or instruction mode.</p>',
829 => '',
830 => '<p>A value of <code>a</code> indicates literal mode, any other value is instruction mode.</p>',
831 => '',
832 => '<p>Generally it's toggled with [[#l_-_Literal|l]] but setting a value explicitly',
833 => 'using [[#s_-_Set|s]] will also switch between modes.</p>',
834 => '',
835 => ''''Example'''',
836 => '',
837 => 'Code:',
838 => '<pre>oof l ppp lrabl ppp</pre>',
839 => '',
840 => 'Output:',
841 => '<pre>foobar</pre>',
842 => '',
843 => '<p><code>oof</code> are pushed onto the stack because the program starts in literal mode.</p>',
844 => '<p>[[#l_-_Literal|l]] enables instruction mode and [[#p_-_Print|p]] is called 3 times',
845 => 'to print <code>foo</code> from the stack to the output.</p>',
846 => '<p>In <code>lrabl</code> literal mode is entered again to push <code>rab</code>',
847 => 'onto the stack, the last [[#l_-_Literal|l]] goes back into instruction mode.</p>',
848 => '<p>Finally [[#p_-_Print|p]] is called again to print <code>bar</code>.</p>',
849 => '',
850 => ''''Adding <code class="instruction">l</code> onto the stack'''',
851 => '',
852 => '<p>Since [[#l_-_Literal|l]] ends literal mode, values of <code>l</code>',
853 => 'cannot be directly added onto the stack, but some easy work-arounds are available.</p>',
854 => '',
855 => '<p>The most basic is to use addition to get an <code>l</code> from other values:</p>',
856 => '',
857 => '<pre>kb l a</pre>',
858 => '<p>Here [[#a_-_Arithmetic_Operation|a]] pops <code>k</code> and <code>b</code> from the stack,',
859 => 'adds them together, and pushes <code>l</code> (the result of this addition) back onto the stack.</p>',
860 => '',
861 => '<p>Sometimes you might want multiple <code>l</code> on the stack, this is especially useful when',
862 => 'defining procedures that need to output literal values on the stack.',
863 => 'You can achieve this by combining the previous approach with the overwrite instruction ([[#l_-_Literal|l]]):</p>',
864 => '',
865 => '<pre>jjj x jjj x j bk l ao</pre>',
866 => '<p>Here [[#a_-_Arithmetic_Operation|a]] does the same as it did before, replacing <code>bk</code> with <code>l</code>.</p>',
867 => '<p>[[#o_-_Overwrite|o]] pops <code>xjl</code>. It preforms a replacement from <code>j</code> to <code>l</code>',
868 => 'using <code>x</code> as delimiter. Both instances of the delimiter are removed from the stack.</p>',
869 => '<p>At the end the stack will be <code>jjjlll</code>, the first the <code>j</code> not being replaced because found',
870 => 'after the delimiter when searching from the top of the stack.</p>',
871 => '',
872 => '<h3 id='m-instruction'><span class='instruction'>m</span> - Memory</h3>',
873 => '',
874 => ''''Synopsis'''',
875 => '',
876 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>m</code></td><td><span class='operand'>val</span></td></tr></table>',
877 => '<p>Pushes the value of the [[#m_-_Memory_Cell_Register|m register]] onto the stack.</p>',
878 => '<p>This can be useful if there is a value that needs to be pushed onto the stack multiple time.</p>',
879 => '',
880 => '<h3 id='m-register'><span class='instruction'>m</span> - Memory Cell Register</h3> <p>Doesn't have any special meaning, pushed onto the stack by [[#m_-_Memory|m]].</p>',
881 => '',
882 => ''''Examples'''',
883 => '',
884 => 'Code:',
885 => '<pre>lmmmppp</pre>',
886 => '',
887 => 'Output:',
888 => '<pre>aaa</pre>',
889 => '',
890 => '<p>[[#l_-_Literal|l]] enables instruction mode.</p>',
891 => '<p>[[#m_-_Memory|m]] is called 3 times and pushes the default value (<code>a</code>) onto the stack each time.</p>',
892 => '<p>[[#p_-_Print|p]] is called 3 times, popping the 3 values and printing them.</p>',
893 => '',
894 => 'Code:',
895 => '<pre>mz l s mmmppp</pre>',
896 => '',
897 => 'Output:',
898 => '<pre>zzz</pre>',
899 => '',
900 => '<p>Same as before but [[#s_-_Set|s]] uses the <code>z</code> and <code>m</code> values',
901 => 'from the stack to set the [[#m_-_Memory_Cell_Register|m register]] to <code>z</code>.</p>',
902 => '',
903 => '<h3 id='n-instruction'><span class='instruction'>n</span> - Number of Items</h3>',
904 => '',
905 => ''''Synopsis'''',
906 => '',
907 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>n</code></td><td><span class='operand'>count</span></td></tr></table>',
908 => '<p>Pushed onto the stack the number of items currently on the stack</p>',
909 => '',
910 => '<h3 id='n-register'><span class='instruction'>n</span> - Number Size Register</h3>',
911 => '',
912 => '<p>Number of letters per number, see [[Multi-Letter_Numbers|multi-letter numbers]] in advanced concepts.</p>',
913 => '',
914 => ''''Examples'''',
915 => '',
916 => 'Code:',
917 => '<pre>foobar l nf</pre>',
918 => '',
919 => '<p><code>foobar</code> is pushed onto the stack, then [[#n_-_Number_of_Items|n]] pushes',
920 => 'the stack count <code>g</code> (6) onto the stack.',
921 => 'Finally [[#f_-_Flip|f]] pops that value and flips the whole stack.</p>',
922 => '',
923 => 'Code:',
924 => '<pre>foobar xpx l d n f n r</pre>',
925 => '',
926 => 'Output:',
927 => '<pre>foobar</pre>',
928 => '',
929 => '<p><code>foobarxpx</code> is pushed onto the value stack, then [[#d_-_Define|d]] pops <code>xpx</code> to push <code>p</code> on the procedure stack.</p>',
930 => '<p>As before [[#n_-_Number_of_Items|n]] followed by [[#f_-_Flip|f]] flips the entire stack.',
931 => 'Finally [[#n_-_Number_of_Items|n]] followed by [[#r_-_Repeat|r]] repeats the print',
932 => 'procedure for each item on the stack.</p>',
933 => '',
934 => '<p>Note that this works up to a value of <code>z</code> (25).</p>',
935 => '',
936 => '<h3 id='o-instruction'><span class='instruction'>o</span> - Overwrite</h3>',
937 => '',
938 => ''''Synopsis'''',
939 => '',
940 => '<table class="wikitable synopsis"><tr><td><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span><span class='operand'>search</span><span class='operand'>replace</span></td><td><code class='instruction'>o</code></td><td><span class='operand'>...</span></td></tr></table>',
941 => '<p>Replaces values on the stack until a delimiter is reached.</p>',
942 => '',
943 => '<p>Pops <code>replace</code> and <code>search</code> from the stack.',
944 => 'Then replaces all instanced of <code>search</code> between the two <code>mark</code>',
945 => 'with <code>replace</code>.</p>',
946 => '',
947 => '<p>If the second <code>mark</code> is not found, all occurrences of <code>search</code> will be replaced.</p>',
948 => '',
949 => '<p>The two <code>mark</code> are removed from the stack by default but they can be preserved',
950 => 'depending on the value of the [[#o_-_Keep_Mark_Register|o register]].</p>',
951 => '',
952 => '<h3 id='o-register'><span class='instruction'>o</span> - Keep Mark Register</h3> <p>By default [[#o_-_Overwrite|o]] deleted the markers from the stack, if this',
953 => 'register has a value other than <code>a</code>, they are kept.</p>',
954 => '',
955 => ''''Example'''',
956 => '',
957 => 'Code:',
958 => '<pre>test x test x t b l o</pre>',
959 => '',
960 => '<p>All the values until [[#l_-_Literal|l]] are pushed onto the stack.</p>',
961 => '<p>[[#o_-_Overwrite|o]] pops <code>xtb</code> from the stack, and replaces',
962 => 'all <code>t</code> into <code>b</code> until the next <code>x</code> is found.</p>',
963 => '<p>This results in the stack ending with <code>testbesb</code>.</p>',
964 => '<p>Note that the value <code>x</code> is arbitrary, any letter can work as a marker.</p>',
965 => '',
966 => '',
967 => 'Code:',
968 => '<pre>test x test x t b ob l s o</pre>',
969 => '',
970 => '<p>Similar as before, now [[#s_-_Set|s]] pops <code>ob</code>',
971 => 'and sets the [[#o_-_Keep_Mark_Register|o register]] to <code>b</code>.</p>',
972 => '',
973 => '<p>The rest works the same except the markers are kept, resulting in <code>testxbesbx</code>.</p>',
974 => '',
975 => '<h3 id='p-instruction'><span class='instruction'>p</span> - Print</h3>',
976 => '',
977 => ''''Synopsis'''',
978 => '',
979 => '<table class="wikitable synopsis"><tr><td><span class='operand'>val</span></td><td><code class='instruction'>p</code></td><td></td></tr></table>',
980 => '<p>Pops a letter from the stack and prints it to output.</p>',
981 => '',
982 => '<p>By default prints them as lower case letters but this can changed based on the value of the [[#p_-_Print_Mode_Register|p register]].</p>',
983 => '',
984 => '<h3 id='p-register'><span class='instruction'>p</span> - Print Mode Register</h3> <p>Specifies the print mode, depending on the mode letters are printed differently.</p>',
985 => '<p>Using the right combination of printed letter and mode, any ASCII character can be printed.</p>',
986 => '',
987 => '<table class="wikitable print-mode mono">',
988 => ' <caption>Print Modes</caption>',
989 => ' <tr><th rowspan="2">Letter</th><th colspan="5">Mode</th></tr>',
990 => ' <tr><th>a</th> <th>b</th> <th>c</th> <th>d</th> <th>e</th></tr>',
991 => ' <tr><th>a</th><td class='print-mode'>a</td><td class='print-mode'>A</td><td class='print-mode'>0</td><td class='print-mode'>!</td><td class='print-mode'>NUL</td></tr>',
992 => ' <tr><th>b</th><td class='print-mode'>b</td><td class='print-mode'>B</td><td class='print-mode'>1</td><td class='print-mode'>"</td><td class='print-mode'>x01</td></tr>',
993 => ' <tr><th>c</th><td class='print-mode'>c</td><td class='print-mode'>C</td><td class='print-mode'>2</td><td class='print-mode'>#</td><td class='print-mode'>x02</td></tr>',
994 => ' <tr><th>d</th><td class='print-mode'>d</td><td class='print-mode'>D</td><td class='print-mode'>3</td><td class='print-mode'>$</td><td class='print-mode'>x03</td></tr>',
995 => ' <tr><th>e</th><td class='print-mode'>e</td><td class='print-mode'>E</td><td class='print-mode'>4</td><td class='print-mode'>%</td><td class='print-mode'>x04</td></tr>',
996 => ' <tr><th>f</th><td class='print-mode'>f</td><td class='print-mode'>F</td><td class='print-mode'>5</td><td class='print-mode'>&</td><td class='print-mode'>x05</td></tr>',
997 => ' <tr><th>g</th><td class='print-mode'>g</td><td class='print-mode'>G</td><td class='print-mode'>6</td><td class='print-mode'>'</td><td class='print-mode'>x06</td></tr>',
998 => ' <tr><th>h</th><td class='print-mode'>h</td><td class='print-mode'>H</td><td class='print-mode'>7</td><td class='print-mode'>(</td><td class='print-mode'>x07</td></tr>',
999 => ' <tr><th>i</th><td class='print-mode'>i</td><td class='print-mode'>I</td><td class='print-mode'>8</td><td class='print-mode'>)</td><td class='print-mode'>x08</td></tr>',
1000 => ' <tr><th>j</th><td class='print-mode'>j</td><td class='print-mode'>J</td><td class='print-mode'>9</td><td class='print-mode'>*</td><td class='print-mode'>HT</td></tr>',
1001 => ' <tr><th>k</th><td class='print-mode'>k</td><td class='print-mode'>K</td><td class='print-mode'>:</td><td class='print-mode'>+</td><td class='print-mode'>LF</td></tr>',
1002 => ' <tr><th>l</th><td class='print-mode'>l</td><td class='print-mode'>L</td><td class='print-mode'>;</td><td class='print-mode'>,</td><td class='print-mode'>x0b</td></tr>',
1003 => ' <tr><th>m</th><td class='print-mode'>m</td><td class='print-mode'>M</td><td class='print-mode'><</td><td class='print-mode'>-</td><td class='print-mode'>x0c</td></tr>',
1004 => ' <tr><th>n</th><td class='print-mode'>n</td><td class='print-mode'>N</td><td class='print-mode'>=</td><td class='print-mode'>.</td><td class='print-mode'>CR</td></tr>',
1005 => ' <tr><th>o</th><td class='print-mode'>o</td><td class='print-mode'>O</td><td class='print-mode'>></td><td class='print-mode'>/</td><td class='print-mode'>x0e</td></tr>',
1006 => ' <tr><th>p</th><td class='print-mode'>p</td><td class='print-mode'>P</td><td class='print-mode'>?</td><td class='print-mode'>@</td><td class='print-mode'>x0f</td></tr>',
1007 => ' <tr><th>q</th><td class='print-mode'>q</td><td class='print-mode'>Q</td><td class='print-mode'>x1a</td><td class='print-mode'>[</td><td class='print-mode'>x10</td></tr>',
1008 => ' <tr><th>r</th><td class='print-mode'>r</td><td class='print-mode'>R</td><td class='print-mode'>ESC</td><td class='print-mode'>\</td><td class='print-mode'>x11</td></tr>',
1009 => ' <tr><th>s</th><td class='print-mode'>s</td><td class='print-mode'>S</td><td class='print-mode'>x1c</td><td class='print-mode'>]</td><td class='print-mode'>x12</td></tr>',
1010 => ' <tr><th>t</th><td class='print-mode'>t</td><td class='print-mode'>T</td><td class='print-mode'>x1d</td><td class='print-mode'>^</td><td class='print-mode'>x13</td></tr>',
1011 => ' <tr><th>u</th><td class='print-mode'>u</td><td class='print-mode'>U</td><td class='print-mode'>x1e</td><td class='print-mode'>_</td><td class='print-mode'>x14</td></tr>',
1012 => ' <tr><th>v</th><td class='print-mode'>v</td><td class='print-mode'>V</td><td class='print-mode'>x1f</td><td class='print-mode'>`</td><td class='print-mode'>x15</td></tr>',
1013 => ' <tr><th>w</th><td class='print-mode'>w</td><td class='print-mode'>W</td><td class='print-mode'>SP</td><td class='print-mode'>{</td><td class='print-mode'>x16</td></tr>',
1014 => ' <tr><th>x</th><td class='print-mode'>x</td><td class='print-mode'>X</td><td class='print-mode'>x7f</td><td class='print-mode'>|</td><td class='print-mode'>x17</td></tr>',
1015 => ' <tr><th>y</th><td class='print-mode'>y</td><td class='print-mode'>Y</td><td class='print-mode'></td><td class='print-mode'>}</td><td class='print-mode'>x18</td></tr>',
1016 => ' <tr><th>z</th><td class='print-mode'>z</td><td class='print-mode'>Z</td><td class='print-mode'></td><td class='print-mode'>~</td><td class='print-mode'>x19</td></tr> </table>',
1017 => '',
1018 => '<p>The special mode <code>z</code> will cause [[#p_-_Print_Mode_Register|p register]] to not',
1019 => 'print anything turning it into a pop operation.</p>',
1020 => '',
1021 => ''''Examples'''',
1022 => '',
1023 => 'Code:',
1024 => '<pre>tnirp l ppppp</pre>',
1025 => '',
1026 => 'Output:',
1027 => '<pre>print</pre>',
1028 => '',
1029 => '<p>All the values until [[#l_-_Literal|l]] are pushed onto the stack',
1030 => 'then [[#p_-_Print_Mode_Register|p register]] is called multiple times, each time',
1031 => 'it pops a value off the stack and prints it.</p>',
1032 => '<p>Note that since [[#p_-_Print_Mode_Register|p register]] prints off the top of the stack,',
1033 => 'the stack values need to be in reverse order to be printed.</p>',
1034 => '',
1035 => 'Code:',
1036 => '<pre>tnirp pb l s ppppp</pre>',
1037 => '',
1038 => 'Output:',
1039 => '<pre>PRINT</pre>',
1040 => '',
1041 => '<p>Similar as before, now [[#s_-_Set|s]] pops <code>pb</code>',
1042 => 'and sets the [[#p_-_Print_Mode_Register|p register]] to <code>b</code>, switching to uppercase print mode.</p>',
1043 => '',
1044 => 'Code:',
1045 => '<pre>hddb pc l s pppp</pre>',
1046 => '',
1047 => 'Output:',
1048 => '<pre>1337</pre>',
1049 => '',
1050 => '<p>Print mode <code>c</code> can be used to print numbers.</p>',
1051 => '',
1052 => 'Code:',
1053 => '<pre>tnirp pz l s ppppp</pre>',
1054 => '',
1055 => '(No Output)',
1056 => '',
1057 => '<p>Print mode <code>z</code> can be used to pop values off the stack without printing them.</p>',
1058 => '',
1059 => 'Code:',
1060 => '<pre>a pd djro pa w pb w pc ojje xjbk pa h pb l sps ao pppp spsps pppp sp</pre>',
1061 => '',
1062 => 'Output:',
1063 => '<pre>Hello World!</pre>',
1064 => '',
1065 => '<p>Does the usual trick to replace <code>l</code> (see [[#l_-_Literal|l]] examples).',
1066 => 'Then keeps switching print modes and printing values from the stack.</p>',
1067 => '',
1068 => '<h3 id='r-instruction'><span class='instruction'>r</span> - Repeat</h3>',
1069 => '',
1070 => ''''Synopsis'''',
1071 => '',
1072 => '<table class="wikitable synopsis"><tr><td><span class='operand'>count</span></td><td><code class='instruction'>r</code></td><td></td></tr></table>',
1073 => '<p>Pops <code>count</code> and the top procedure from the procedure stack and executes',
1074 => 'said procedure <code>count</code> times. A count of <code>a</code> (0) means infinite loop.</p>',
1075 => '',
1076 => ''''Example'''',
1077 => '',
1078 => 'Code:',
1079 => '<pre>tset e xpx l dr</pre>',
1080 => '',
1081 => 'Output:',
1082 => '<pre>test</pre>',
1083 => '',
1084 => '<p>After [[#l_-_Literal|l]] the stack contains <code>tsetexpx</code>.</p>',
1085 => '<p>[[#d_-_Define|d]] pops <code>xpx</code> from the value stack and pushes <code>p</code> on the procedure stack.</code>',
1086 => '<p>[[#r_-_Repeat|r]] pops <code>e</code> (4) from the value stack,',
1087 => 'the procedure from the procedure stack and repeats it 4 times, printing the 4 remaining letters on the stack.</p>',
1088 => '',
1089 => '<h3 id='s-instruction'><span class='instruction'>s</span> - Set</h3>',
1090 => '',
1091 => ''''Synopsis'''',
1092 => '',
1093 => '<table class="wikitable synopsis"><tr><td><span class='operand'>reg</span><span class='operand'>val</span></td><td><code class='instruction'>s</code></td><td></td></tr></table>',
1094 => '<p>Pops <code class="operand">reg</code> and <code class="operand">val</code> from the stack,',
1095 => 'then sets the corresponding register to <code class="operand">val</code>.</p>',
1096 => '',
1097 => ''''Example'''',
1098 => '',
1099 => 'Code:',
1100 => '<pre>m mf l s g</pre>',
1101 => '<p>Values are pushed onto the stack until [[#l_-_Literal|l]], resulting in the stack containing <code>mmf</code>.</p>',
1102 => '<p>[[#s_-_Set|s]] pops <code>mf</code> and sets the [[#m_-_Memory_Cell_Register|m register]] to <code>f</code>.</p>',
1103 => '<p>[[#g_-_Get|g]] pops <code>m</code> and pushes its value (<code>f</code>) onto the stack, resulting in a stack with <code>f</code>.</p>',
1104 => '',
1105 => '',
1106 => '<h3 id='t-instruction'><span class='instruction'>t</span> - Text Input</h3>',
1107 => '',
1108 => ''''Synopsis'''',
1109 => '',
1110 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>t</code></td><td><span class='operand'>val?</span></td></tr></table>',
1111 => '<p>Pushes a letter onto the stack based on user input.</p>',
1112 => '',
1113 => '<p>Reads one character from the input stream, converts into a',
1114 => 'letter using the reverse operation of [[#p_-_Print|p]] and sets the [[#t_-_Read_Result_Register|t register]] to the print mode that would',
1115 => 'yield that character.</p>',
1116 => '',
1117 => '<p>On failure (end of file or invalid character) it sets the',
1118 => '[[#t_-_Read_Result_Register|t register]] to <code>z</code> and doesn't push anything',
1119 => 'onto the stack.</p>',
1120 => '',
1121 => '<h3 id='t-register'><span class='instruction'>t</span> - Read Result Register</h3> <p>Holds the status of the last [[#t_-_Text_Input|t]] operation.',
1122 => 'Basically if you want to print back the same character you need to set',
1123 => 'the [[#p_-_Print_Mode_Register|p register]] to the value of the [[#t_-_Read_Result_Register|t register]].',
1124 => 'The special value of <code>z</code> indicates an error.',
1125 => 'Refer to the documentation of the [[#p_-_Print_Mode_Register|p register]] for a description of values.</p>',
1126 => '',
1127 => ''''Example'''',
1128 => '',
1129 => 'Code:',
1130 => '<pre>lt</pre>',
1131 => '',
1132 => '<p>[[#l_-_Literal|l]] exits literal mode, then [[#t_-_Text_Input|t]] reads one character',
1133 => 'from input. Follow a few examples of the end state based on the input.</p>',
1134 => '',
1135 => '<p>If the user typed <code>h</code>, the [[#t_-_Read_Result_Register|t register]] holds the value <code>a</code> and',
1136 => 'the stack the value <code>h</code>.</p>',
1137 => '',
1138 => '<p>If the user typed <code>H</code>, the stack still holds the value <code>h</code>',
1139 => 'but now the [[#t_-_Read_Result_Register|t register]] has the value <code>b</code> which corresponds to the',
1140 => 'upper case print mode.</p>',
1141 => '',
1142 => '<p>If the user typed <code>3</code>, the stack still holds the value <code>d</code>',
1143 => 'but now the [[#t_-_Read_Result_Register|t register]] has the value <code>c</code> which corresponds to the',
1144 => 'number print mode.</p>',
1145 => '',
1146 => '<p>If the input reached end of file, the [[#t_-_Read_Result_Register|t register]] will have the value <code>z</code>',
1147 => 'and the stack will be empty.</p>',
1148 => '',
1149 => '<h3 id='u-instruction'><span class='instruction'>u</span> - Undo</h3>',
1150 => '',
1151 => ''''Synopsis'''',
1152 => '',
1153 => '<table class="wikitable synopsis"><tr><td><span class='operand'>mark</span><span class='operand'>...</span><span class='operand'>mark</span></td><td><code class='instruction'>u</code></td><td></td></tr></table>',
1154 => '<p>Pops everything on the stack until <code>mark</code> is found.</p>',
1155 => '',
1156 => '<p>Starts by popping <code>mark</code>, that can be any letter.',
1157 => 'Then it keeps popping until it finds another value of <code>mark</code>',
1158 => 'or the stack is empty.</p>',
1159 => '',
1160 => ''''Example'''',
1161 => '',
1162 => 'Code:',
1163 => '<pre>foobartest l u</pre>',
1164 => '',
1165 => '<p>Before [[#u_-_Undo|u]] is executed, the stack contains <code>foobartest</code>.</p>',
1166 => '<p>[[#u_-_Undo|u]] pops a <code>t</code> then keeps popping until the following',
1167 => '<code>t</code> is popped, then stops. At the end the stack holds <code>foobar</code></p>',
1168 => '',
1169 => '<h3 id='w-instruction'><span class='instruction'>w</span> - Wrap</h3>',
1170 => '',
1171 => ''''Synopsis'''',
1172 => '',
1173 => '<table class="wikitable synopsis"><tr><td><span class='operand'>...</span><span class='operand'>count</span><span class='operand'>steps</span></td><td><code class='instruction'>w</code></td><td><span class='operand'>...</span></td></tr></table>',
1174 => '<p>Wraps the top <code>count</code> items of the stack by <code>steps</code> steps.</p>',
1175 => '',
1176 => '<p>Starts by popping <code>count</code> and <code>steps</code> from the value stack.',
1177 => 'Then it pops <code>count</code> more items, which will be the operands of the wrap operation.</p>',
1178 => '',
1179 => '<p>A wrap step consists on moving the first operand to the back of the list of operands.',
1180 => 'This is applied <code>steps</code> times.</p>',
1181 => '',
1182 => '<p>After all the steps, the operands are pushed back onto the stack in their new order.</p>',
1183 => '',
1184 => ''''Examples'''',
1185 => '',
1186 => 'Code:',
1187 => '<pre>foobar db l w</pre>',
1188 => '',
1189 => '<p>Here [[#w_-_Wrap|w]] performs <code>b</code> (1) step on',
1190 => 'the top <code>d</code> items, which are <code>bar</code>.',
1191 => 'This turns <code>bar</code> into <code>rba</code> as the <code>r</code>',
1192 => 'is moved to the back.</p>',
1193 => '',
1194 => '<p>At the end the stack contains <code>foorba</code>.</p>',
1195 => '',
1196 => 'Code:',
1197 => '<pre>foobar dc l w</pre>',
1198 => '',
1199 => '<p>The only change is the number of steps, resulting in a stack with <code>fooarb</code>.</p>',
1200 => '',
1201 => '<h3 id='x-instruction'><span class='instruction'>x</span> - Execute</h3>',
1202 => '',
1203 => ''''Synopsis'''',
1204 => '',
1205 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>x</code></td><td></td></tr></table>',
1206 => '<p>Pops and executes the top procedure.</p>',
1207 => '',
1208 => ''''Example'''',
1209 => '',
1210 => 'Code:',
1211 => '<pre>abc qppq l d x p</pre>',
1212 => '',
1213 => 'Output:',
1214 => '<pre>cba</pre>',
1215 => '',
1216 => '<p>After [[#l_-_Literal|l]] the stack contains <code>abcqppq</code>.</p>',
1217 => '<p>[[#d_-_Define|d]] pops <code>qppq</code> and pushes <code>pp</code>',
1218 => 'onto the procedure stack.</p>',
1219 => '<p>[[#x_-_Execute|x]] pops this procedure and executes it.',
1220 => 'the procedure calls [[#p_-_Print|p]] twice printing <code>cb</code>.</p>',
1221 => '<p>Finally execution continues after [[#x_-_Execute|x]], where an additional',
1222 => 'call to [[#p_-_Print|p]] prints <code>a</code>.</p>',
1223 => '',
1224 => '',
1225 => '<h3 id='y-instruction'><span class='instruction'>y</span> - Yield</h3>',
1226 => '',
1227 => ''''Synopsis'''',
1228 => '',
1229 => '<table class="wikitable synopsis"><tr><td></td><td><code class='instruction'>y</code></td><td></td></tr></table>',
1230 => '<p>Stops execution of the current procedure, leaving the stack unchanged</p>',
1231 => '',
1232 => ''''Example'''',
1233 => '',
1234 => 'Code:',
1235 => '<pre>abc qpypq l d x p</pre>',
1236 => '',
1237 => 'Output:',
1238 => '<pre>cb</pre>',
1239 => '',
1240 => '<p>This is the same as the example for [[#x_-_Execute|x]] with the exception of the presence of [[#y_-_Yield|y]] in the middle of the procedure, which causes the second [[#p_-_Print|p]] to not be executed.</p>',
1241 => '',
1242 => '<h2>Advanced Concept</h2>',
1243 => '',
1244 => '<h3 id="multi-letter-numbers">Multi-Letter Numbers</h3>',
1245 => '',
1246 => '<p>By default each letter represents a number in base 26.',
1247 => 'Sometimes values between 0 and 25 are not enough.',
1248 => 'You can enable a mode that uses multiple letters per number by setting the [[#n_-_Number_Size_Register|n register]] to',
1249 => 'a higher value, the number of letters per numer is [[#n_-_Number_of_Items|n]] + 1.</p>',
1250 => '',
1251 => '<p>This affects the condition inputs for [[#i_-_If|i]], the output of [[#n_-_Number_of_Items|n]], and',
1252 => 'both inputs and outputs of [[#a_-_Arithmetic_Operation|a]].</p>',
1253 => '',
1254 => '<p>When multi-number letters are used, the most significant letter is on the stack.',
1255 => 'For example if the stack contains <code>te</code> (<code>e</code> being at the top of the stack)',
1256 => 'and there are 2 letters per number ([[#n_-_Number_Size_Register|n register]] set to <code>b</code>),',
1257 => 'The numerical value is calculated as <code>26 * e + t</code>, with all numbers <code>26 * 4 + 19</code>, which is 123.</p>',
1258 => '',
1259 => '<h2>External Links</h2>',
1260 => '',
1261 => '* [https://dragon.best/alphastack/#playground web-based playground]',
1262 => '* [https://gitlab.com/mattia.basaglia/dragon.best/-/blob/master/media/scripts/alphastack/alphastack.py Python implementation]'
] |