]> Git — Sourcephile - haskell/symantic-parser.git/blob - parsers/Parsers/Brainfuck/inputs/compiler.bf
doc: update
[haskell/symantic-parser.git] / parsers / Parsers / Brainfuck / inputs / compiler.bf
1 Thanks to: https://github.com/matslina/awib
2 # This is the awib frontend
3 # Please refer to the documentation in the full source distribution
4 # of awib for details regarding this file
5 ## Phase 1
6 ## Target identification
7 ##
8 % *T (where T = index of target platform)
9 # read bytes until EOF or bf instruction or '@' is reached
10 >>>>+[>[-],+
11 % T 0 0 0 1 *inc(X) 0 0 0 (where X is byte read)
12 [->+>+<<]>>[-<<+>>]+<
13 % T 0 0 0 1 inc(X) *inc(X) 1 0
14 [-[>+++++[-<------->]+<-[-[-[-[--------------[--[-->>+<<[>>-<++
15 [-<--------->]+<[--[>+++++++++[-<++++++++++>]<[-]]]]]]]]]]]<->]
16 >[-<<<->>>]<<<]
17 % T 0 0 0 *0 X 0 0 d
18 % if( X=='@' ) d=1 else if(EOF) X=0 else X = a bf instruction
19 # if '@' was encountered then read a string at most 20 bytes long
20 # whitespace and EOF and bf all terminate the string when read
21 >>>>[->++++++++++++++++++++<<<<[-]>>>+[
22 % T 0 0 0 0 (target) 0 0 0 *1 C (where C = sub(20 strlen(target)))
23 -<,+[-<+<+>>]+<<->
24 % T 0 0 0 0 (target) X *X 1 0 C
25 [-[---------[-[---[>++++[-<---->]+<+[-----------[-[-[-[--------------
26 [--[>++[-<--------->]+<--[--[>+++++++++[-<++++++++++>]<[-]]]]]]]]]]]]]]]
27 +>[-<->]
28 % T 0 0 0 0 (target) X c *0 0 C (where c=(X EOF or bf or whitespace ? 0 : 1))
29 >>[->+<]
30 <<<[->>>+>->+<[>-]>[>]<[-<<->>]<<<<<]>>>
31 % T 0 0 0 0 (target) X 0 0 0 *c D
32 % where c=(string terminated ? 0 : 1) and D=(c==1 ? sub(C 1) : C)
33 ]
34 # if string was ended due to strlen exceeding limit then read one char extra
35 +>[<-]<[<]>[-<<<,>>>>]
36 % T 0 0 0 0 (target) X 0 0 0 *0 D
37 # now check if the read target string matches any known target string
38 # and overwrite the target index T accordingly
39 # we take care not to overwrite the last read X as it may be bf and should
40 # be passed on to the bytecode compiler below
41 <<<<+[->+<]>[-<<[<]<<<+>>>>[>]>]++++++++++++++++++++>>>>[-<<<<->>>>]<<<++++++++
42 <<<[<]<<<->>>>[>]>>
43 % T X 0 0 0 (target) 0 s *8 0 0 (where s = strlen(target))
44 [[->+>+<<]>[-<+>]+>-[-[-[-[-[-[-[-[<->[-]]
45 <[-
46 # build target string for backend index 8
47 % T X 0 0 0 (target) 0 s 8 *0 0
48 >+++++++++[->+>++++++++++++<<]>>[->+>+>+>+>+>+>+>+>+<<<<<<<<<]
49 >>----------->++>----->------------->-->----------->++++++++++>-----------
50 <<<<<<<<<<<<
51 % T X 0 0 0 (target) 0 s 8 *0 0 9 0 "lang_java" 0
52 ]>]
53 <[-
54 # build target string for backend index 7
55 % T X 0 0 0 (target) 0 s 7 *0 0
56 >+++++++++[->+>++++++++++++<<]>->[->+>+>+>+>+>+>+>+<<<<<<<<]>>----------->++
57 >----->------------->++++++++>---------
58 <<<<<<<<<<
59 % T X 0 0 0 (target) 0 s 7 *0 0 8 0 "lang_tcl" 0
60 ]>]
61 <[-
62 # build target string for backend index 6
63 % T X 0 0 0 (target) 0 s 6 *0 0
64 >+++++++++[->+>++++++++++++<<]>>[->+>+>+>+>+>+>+>+>+<<<<<<<<<]>>----------->++
65 >----->------------->++++++>+++++++++>---------->+++++++++++++
66 <<<<<<<<<<<<
67 % T X 0 0 0 (target) 0 s 6 *0 0 9 0 "lang_ruby" 0
68 ]>]
69 <[-
70 # build target string for backend index 5
71 % T X 0 0 0 (target) 0 s 5 *0 0
72 >+++++++++++[->+>++++++++++<<]>>[->+>+>+>+>+>+>+>+>+>+>+<<<<<<<<<<<]
73 >-->------------->>------->--------------->++>+++++++++++>++++++>------>+
74 <<<<<<<<<<<<<
75 % T X 0 0 0 (target) 0 s 5 *0 0 11 0 "lang_python" 0
76 ]>]
77 <[-
78 # build target string for backend index 4
79 % T X 0 0 0 (target) 0 s 4 *0 0
80 >>+++++++[->+++++++<]+++++++>
81 [->++>++>++>++>++>++>++<<<<<<<]>
82 ++++++++++>->++++++++++++>+++++>--->+++++>+++++++++++++
83 <<<<<<<<<<
84 % T X 0 0 0 (target) 0 s 4 *0 0 7 0 "lang_go" 0
85 ]>]
86 <[-
87 # build target string for backend index 3
88 % T X 0 0 0 (target) 0 s 3 *0 0
89 >>+++++++[->+++++++<]++++++++++>
90 [->++>++>++>++>++>++>++>++>++>++<<<<<<<<<<]>
91 ++++++++++>->++++++++++++>+++++>--->++>+++++++++++++++++++>+++++++++++>
92 +++++++++++>+++++++++++++++++++++++<<<<<<<<<<<<<
93 % T X 0 0 0 (target) 0 s 3 *0 0 10 0 "lang_dummy" 0
94 ]>]
95 <[-
96 # build target string for backend index 2
97 % T X 0 0 0 (target) 0 s 2 *0 0
98 >>+++++++[->+++++++<]++++++>[->++>++>++>++>++>++<<<<<<]
99 >++++++++++>->++++++++++++>+++++>--->+<<<<<<<<<
100 % T X 0 0 0 (target) 0 s 2 *0 0 6 0 "lang_c" 0
101 ]>]
102 <[-
103 # build target string for backend index 1
104 % T X 0 0 0 (target) 0 s 1 *0 0
105 >>+++++++[->+++++++<]+++++++++>[->+>+>+>++>++>++>++>++>++<<<<<<<<<]
106 >++>+++++++>+++++>--->++++++++++>+++++++>++++++++++++>+++
107 ++++++++++++++++>++++++++++++++++++++++<<<<<<<<<<<<
108 % T X 0 0 0 (target) 0 s 1 *0 0 9 0 "386_linux" 0
109 ]
110 % T X 0 0 0 (target) 0 s i *0 0 S 0 (string) 0
111 % where S = strlen(string) and i is the backend index of the target (string)
112 # if (target) equals (string) then set T=i and break else decrease s and retry
113 <<[->>+>>-<<<<]>>[-<<+>>]>+>[<++++[->++++<]>[-]]<
114 % T X 0 0 0 (target) 0 s i 0 *e 0 0 (string) 0 (where e=(S==s ? 1 : 0))
115 [-
116 <+<<<<[<]>
117 % T X 0 0 0 *(target) 0 s i 1 0 0 0 (string) 0
118 [
119 % T X 0 (target) 0 0 *(F target) 0 s i c 0 (1sled) 0 0 (G string) 0
120 % where c = (strings equal so far ? 1 : 0 ) and (1sled) is a (initially empty)
121 % sequence of cells holding 1 and F/G first cells of respective block
122 [-<+<+>>]<[>>[>]>>>>>[>]>+>[<-]<[<]>[-<<[<]<[-]<<<<[<]<[-]+>>[>]>>>>>[>]>>+<]>-<<<[<]<<<<<[<]<-]
123 % T X 0 (target F) *0 0 (target) 0 s i c 0 (1sled) 0 0 sub(G F) (string) 0
124 >>[>]>>>>>[>]>>[[-]<<<[<]<[-]>>[>]>>]<<+[<]<<<<<[<]>
125 % T X 0 (target F) 0 0 *(target) 0 s i c 0 (1sled) 1 0 0 (string)
126 ]
127 % T X 0 (target) 0 0 *0 s i c 0 (1sled) 0
128 <<<[[->>+<<]<]>>>[>]>>>>>[>]<[-<]<
129 % T X 0 0 0 (target) 0 s i *c 0
130 # if c==1 then we have a match and write T=i and set i=1
131 [-<<<<[<]<<<<[-]>>>>>[>]>>[-<<<[<]<<<<+>>>>>[>]>>]+>]>
132 % T X 0 0 0 (target) 0 s i 0 *0
133 ]
134 # remove (string) if string lengths didn't match and then sub 1 from i
135 >>>[>]<[[-]<]<<
136 <<-]
137 % T X 0 0 0 (target) 0 s *0 0 0
138 <[-]<<[[-]<]<<<+[->>>>+<<<<]>>>>->>>
139 % T 0 0 0 0 X 0 0 *0
140 ]
141 % T 0 0 0 0 X 0 0 *0
142 <<<+[->>>>>>>+<<<<<<<]>>>>>>>-
143 % T 11(0) *X 0 0
144 ## Phase 2
145 ## Bytecode compilation
146 ##
147 % T 11(0) *X (where X is user input)
148 # if read char X is not EOF then enter main loop
149 +[[-<+>]>+<]>[-<<->>]<<
150 [
151 % T 8(0) (code) 0 0 *X (cells left of code ignored for a while hereafter)
152 # check if X is brainfuck
153 [->+>+<<]>[-<+>]++++++[->-------<]+>-
154 [-[-[-[--------------[--[<+++[->-----
155 --<]+>-[--[<->>+++++++[-<++++++++++++
156 +>]<++[-]]]]]]]]]<<
157 % (code) 0 0 *X isbf(X) 0 0
158 # if bf then add to bytecode
159 >[-
160 ++++++[-<------->]+<
161 % (code) 0 0 *sub(X 42) 1 0 0
162 [-[-[-[-[--------------[--[-----------------------------[
163 # CLOSING BRACKET
164 # if this closes OPEN SUB(1) or OPEN ADD(1) then overwrite with SET(0)
165 # else append CLOSE
166 --<<
167 +<<<<-------[>>>>-]>>>>[>>>>]<<<<<<<<+++++++>>>>
168 % (code) P i Q j *c 0 0 1 0 (where c = (P(i) == OPEN(0)))
169 [<<---[>>-]>>[>>]<<[->>>>+<<<<]+
170 << ++[>>-]>>[>>]<<[->>>>+<<<<]<<+>>>>>>
171 % (code) OPEN 0 Q j 0 0 0 1 *d (where d = (Q == ADD or Q == SUB))
172 [-<<<<+<-[>-]>[>]<<+>
173 % (code) OPEN 0 Q j *e 0 0 1 0 (where e = (j == 1) == overwrite SET(0))
174 [->>>-<<<<-<[-]<<++>>]>>>>]<<<<]>
175 % (code) 0 *0 0 f 0 (where f = 1 if append CLOSE)
176 >>[-<<<++++++++>>>>>]<<
177 % (code) CLOSE()/SET(0) 0 *0 0 0
178 ]
179 # OPENING BRACKET
180 # if previous op was SET(0) or CLOSE or if this is the first op
181 # then ignore this loop
182 >[-
183 % (code) 0 0 0 *0 0 0
184 +++<<<<<
185 [>>>>>-<<<<<[->>>+<<<]]>>>
186 --------[++++++++[-<+>]<-------->>>-<<]<
187 -[+++++++++[-<<+>>]<<--------->>>>>-<<<]<<+++++++++>>
188 +<[>-]>[>]<[->>>[-<+>]<<<]>>>[-]<<<+++++++>>
189 % (code) OPEN *c 0 0 0 (where c = (should this loop be ignored ? 1 : 0))
190 [[-]+>>>>>+<<<<<[
191 % (code) OPEN *1 0 0 0 L l
192 >>+<,[>-]>[>]<[-<<->>]+<+[>-]>[>]<[-<<->>]<-
193 % (code) OPEN c *X 0 0 L l (where c = (EOF reached ? 0 : 1) and X = byte read)
194 >+++++++++[-<---------->]+<-[>-]>[>]<[->>
195 { 16b inc >>>++++++++[-<++++++++>]<[->++++<]<
196 [->+>-<<]>+[-<+>]+>-[<->[-]]<[-<[-]<+>>]<< }
197 <<]+<--[>-]>[>]<[->>
198 { 16b dec >>+<[>-<[->>+<<]]>>[-<<+>>]<<->[-<+
199 <->++++++++[->++++++++<]>[-<++++>]<->]<< }
200 <<]+++++++++[-<++++++++++>]<++++[-]
201 >>>
202 { 16b iszero >>+<[>-]>[>]<<<[[->>>+<<<]>>[-]<<]>>>[-<<<+>>>]<<< }
203 # if Ll=0 then delete OPEN and set c=0 to break
204 >>[-<<<<<<[-]<<------->>>>>>]<<<<<<
205 ]]
206 % (code) *0 0 0 0 L l (where Ll is nonzero iff EOF occurred prematurely)
207 >>>>[-]>[-]<<<
208 % (code) 0 0 *0 0
209 ]<]
210 # MOVE RIGHT
211 # if previous op is RIGHT(i) and i is not 255 then overwrite with RIGHT(inc(i))
212 # else append RIGHT(1)
213 >[
214 -<<<<<[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]
215 % (code) *0 P i 0 (where P(i) = previous op)
216 ++++++++++++++++[->>----------------<<]>>+
217 [<<++++++++++++++++[->>++++++++++++++++<<]+>>[-]]<------[<[-]>++++++[-]]
218 <[->>+<<]++++++>+>[-<-<------<+>]>>
219 ]<
220 % (code) RIGHT(?) 0 *0 0 0
221 ]
222 # MOVE LEFT
223 # if previous op is LEFT(i) and i is not 255 then overwrite with LEFT(inc(i))
224 # else append LEFT(1)
225 >[
226 -<<<<<[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]
227 % (code) *0 P i 0 (where P(i) = previous op)
228 ++++++++++++++++[->>----------------<<]>>+
229 [<<++++++++++++++++[->>++++++++++++++++<<]+>>[-]]<-----[<[-]>+++++[-]]
230 <[->>+<<]+++++>+>[-<-<-----<+>]>>
231 ]<
232 % (code) LEFT(?) 0 *0 0 0
233 ]
234 # OUTPUT
235 >[
236 <<<++++>>>->
237 ]<
238 % (code) OUTPUT 0 *0 0 0
239 ]
240 # SUB
241 #if previous op is SUB(i)
242 # if i is 255 then remove previous op
243 # else overwrite with SUB(inc(i))
244 #else append SUB(1)
245 >[
246 -<<<<<[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]
247 % (code) *0 P i 0 (where P(i) = previous op)
248 >---[<+++>+++[-]+>[-]>]>
249 [<++++++++++++++++[->----------------<]>+>+<
250 [<<<+>>++++++++++++++++[->++++++++++++++++<]>[-]>-<]
251 >[-<<<<[-]<--->>>]<]
252 ]<
253 % (code) SET/SUB(?) 0 *0 0 0
254 ]
255 # INPUT
256 >[
257 <<<++>>>->
258 ]<
259 % (code) INPUT 0 *0 0 0
260 ]
261 # ADD
262 #if previous op is ADD(i)
263 # if i is 255 then remove previous op
264 # else overwrite with ADD(inc(i))
265 #else append ADD(1)
266 >[
267 -<<<<<[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]
268 % (code) *0 P i 0 (where P(i) = previous op)
269 >-[<+>+[-]+>[-]>]>
270 [<++++++++++++++++[->----------------<]>+>+<
271 [<<<+>>++++++++++++++++[->++++++++++++++++<]>[-]>-<]
272 >[-<<<<[-]<->>>]<]
273 ]<
274 % (code) ADD(?) 0 *0 0 0
275 ]
276 # Cancellation
277 % (code P i Q j) 0 *0 (where P(i) and Q(j) are the two most recent ops)
278 # if P/Q in (LEFT/RIGHT RIGHT/LEFT ADD/SUB SUB/ADD) and j == 1
279 # remove Q(j) and decrement i
280 # if dec(i) == 0 then remove P(i)
281 >>+<<<+<-[>-]>[>]<<+>[
282 # j == 1
283 % P i Q 1 *1 0 0 1
284 <<<[>>-]>>[>>]<<[->-<]+>[-
285 # i != 0
286 <-<[->+<<<+>>]
287 % add(P Q) i *0 Q 0 0 0 1
288 +<<----[>>-]>>[>>]<<[->>>+<<<]+<<-------[>>-]>>[>>]<<[->>>+<<<]
289 >[-<+<<->>>]+<<<+++++++++++>>>>>
290 % P i Q 1 0 *c 0 1 (where c = add(P Q) in (add(LEFT RIGHT) add(ADD SUB)))
291 [->>-<<<<-<[-]+<-[>-]>[>]<[-<<[-]]>]<]]>>>
292 % (code) 0 0 0 *z (where z = 1 if we should attempt further optimizations)
293 #if P in (ADD SUB) and Q == SET then remove P
294 [>+<-<<<+<<---------[>>-]>>[>>]<<[
295 # Q == SET
296 >>>>-<<<<
297 -<<+<<-[>>-]>>[>>]<<[->>>+<<<]+<<--[>>-]>>[>>]<<[->>>+<<<]<<+++>>>>>
298 % P i 0 j 0 *c 0 0 0 (where c = P in (ADD SUB))
299 [-<<<<<[-]>[-]>>[-<<+>>]]<]<<+++++++++>>>>>]
300 % (code) 0 0 0 *0 z (where z = 1 if we should attempt further optimizations)
301 # if P == SET and Q(j) in (ADD(1) SUB(1)) then inc/dec i and remove Q(j)
302 +>[-
303 <<<<+<<<<---------[>>>>-]>>>>[>>>>]<<<<<<<<+++++++++>>>>[
304 # P == SET
305 % 9 i Q j *1 0 0 1 0
306 <-[>-]>[>]<<+>[
307 # j == 1
308 <<-[>>-]>>[>>]<<<<+>>[-
309 # Q == ADD
310 >>>-<<<<-<<<+++++++[->----------------<]>+[>-]>[>]+<[->-<]>
311 [-<++++++++++++++++[-<++++++++++++++++>]>]
312 <<<+++++++++>>]
313 +<<---[>>-]>>[>>]<<<<+++>>[-
314 # Q == SUB
315 >>>-<<<<-<--
316 <[>-]>[>]<[+++++++++++++++[-<++++++++++++++++>]]<->
317 ]]]>>>>]<
318 % (code) 0 0 0 *z 0 (where z = 1 if we should attempt further optimizations)
319 # if P == CLOSE then try the copy loop optimization
320 [
321 -<<<+<<--------[>>-]>>[>>]<<<<++++++++>>[# P == CLOSE
322 ->>>>>>>++++++++<<++++++++[-<++++++++++++++++>]<-[-<+<+>>]
323 <<<<<+<-------
324 % (code) Q j *1 1 0 0 128 128 *0 0 0 P
325 <<[>>-]>>[>>]<<[->-<]>[-<+>]<
326 [ # determine if loop can be optimized
327 % (code) *k 0 0 0 l r a 0 0 (code)
328 % where k = 1 iff next op should be inspected
329 % l = sub(127 num_left)
330 % r = sub(127 num_right)
331 % a = 1 iff SUB(1) on cell 0 processed
332 <<-[>>-]>>[>>]<<[# P == ADD
333 >>>>[->->>+<<<]+>[<-]<[<]>[ # l == r: kill l ->>>[-<<+>>]<<<]
334 >>>[-<<+<+>>>]<<<<<<+<-]+
335 <<--[>>-]>>[>>]<<[# P == SUB
336 >>>>[->->>+<<<]+>[<-]<[<]>[ # l == r
337 >>[<<-]<<[<<]>+>[-<<<<<-[>-]>[>]<<+>[->>>->>>+<<<<<<]+>>>>]
338 <[->>>>[-<<+>>]<<<<]>]
339 >>>[-<<+<+>>>]<<<<<<+<-]+
340 <<--[>>-]>>[>>]<<[# P == LEFT
341 -<[->+>>>+>-[<-]<[<]>[-<<<<[->+<]>>>>]<<<<]>[-<+>]>+<]+
342 <<-[>>-]>>[>>]<<[ # P == RIGHT
343 -<[->+>>>+>>-[<<-]<<[<<]>>[-<<<<[->+<]>>>>]<<<<]>[-<+>]>+<]
344 % (code) sub(P 6) i *0 q 0 0 l r a 0 0 (code) 0
345 % where q = P in (ADD SUB LEFT RIGHT)
346 # keep going if q==1 && l!=0 && r!=0 && next op exists
347 <[->>>>>>>>>+<<<<<<<<<]<++++++[->>>>>>>>>+<<<<<<<<<]
348 +<<[>>->>>+<<<]>>[>>]<<[-]>>>>>>
349 [[-<<+>>]>[[-<<+>>]<<<<+>>>>]<]>[-<<+>>]>[-<<+>>]<<<<<
350 ---[<<<->>>+++[-]]<<<+
351 % (code) *k 0 0 0 l r a 0 0 P i (code)
352 ]
353 >>>>>>>>+>-------[<-]<[<]>>+++++++
354 <<<[->>+<<]+<<[-<+>>-<]>[>-]>[>]<[->>+<<]>+>---[<-]<[<]>>+++[-]
355 <<<<<[->>+<<]>>[-]>+>
356 % (code) 0 0 0 0 0 0 1 *w 0 (loop)
357 % where w = 1 iff copy loop optimization can be applied
358 [<->->>[-]>[-]<<<<<<<<<+>+>+>+>+>>>>>>
359 [ # replace loop with LMUL/RMUL
360 % (code) 0 1 ::: 1 0 0 n d 0 *P i (loop)
361 % where d = offset to current cell
362 % n = 1 iff offset is negative
363 <+>-[--[--[-[++++++[-]<->]<[ # RIGHT(i)
364 ->>[<<+<[>-]>[>]<[-<<[-]>>]<+>>>-]<<
365 ]>]<[ # LEFT(i)
366 ->>[<<+<[>-]>[>]<[-<<[-]+>>]<->>>-]<<
367 ]>]<[ # SUB(i)
368 % (code) 0 1 ::: 1 0 0 n d *1 0 i (loop)
369 <[>-]>[>]+<[->-<]>[ # d != 0
370 +++++++++++++++[-<<<<++++++++++++++++>>>>]>[-<<<<<->>>>>]<]<
371 % (code) 0 1 ::: 1 0 sub(256 i) n d *0 0 0 (loop)
372 ]>]<[ # ADD(i)
373 % (code) 0 1 ::: 1 0 0 n d *1 0 i (loop)
374 <[>-]>[>]+<[->-<]>[ # d != 0
375 ->[-<<<<<+>>>>>]<]<
376 % (code) 0 1 ::: 1 0 i n d *0 0 0 (loop)
377 ]
378 % (code) 0 1 ::: 1 0 y n d *0 0 i (loop)
379 % where y!=0 iff MUL op should be appended to code
380 % and y is the second op argument
381 <<<[ # y!=0
382 <+>>[ # n=1 so d negative
383 <<-<[<]++++++++++>->++++++++++>->->[>]
384 >>>[+<<<<[<]<<<+>>>>[>]>>>>>-<<]>+<<-]
385 <<[ # n=0 so d positive
386 -<[<]++++++++++++>->++++++++++++>->->[>]
387 >>>[->>+<<<<<<[<]<<<+>>>>[>]>>>]
388 <<<]
389 >[-<<[<]<+>>[>]>]
390 % (code) LMUL/RMUL y 0 1 ::: 1 0 *0 0 0 n d 0? (loop)
391 ]
392 % (code) 0 1 ::: 1 0 *0 n d 0 0 i (loop)
393 >[>[+>>-<<]>+<<-]>[->>+<<]
394 <<+<+>>>>>>>
395 % (code) 0 1 ::: 1 0 0 n d 0 *(loop)
396 ]
397 % (code) 0 1 ::: 1 0 0 n 0 0 *0
398 <<<[-]<<<[-<]+++++++++>>>>>>>>>
399 % (code) SET(0) 0 0 0 0 0 0 0 *0
400 ]
401 % (code) 0 0 0 0 0 0 v *0 0 (loop)
402 % where v = 1 iff copy loop optimization was not applied
403 <[->>>[[-<<<<<<<<<+>>>>>>>>>]>[-<<<<<<<<<+>>>>>>>>>]>]
404 <<<]<<<<<<
405 ]>>>
406 % (code) 0 0 0 *0 0
407 ]
408 ]
409 % 8(0) (code) 0 0 X *0 (where X may be the last byte read)
410 # read next byte and and break if EOF
411 <[-]>
412 ,+[[-<+>]>+<]>[-<<->>]<<
413 ]
414 <<<<[<<]
415 % 6(0) *0 0 (code)
416 ## Phase 3
417 ## Code verification
418 ##
419 # move code leftwards and ensure that all OPEN/CLOSE are balanced
420 # in the process we calculate the maximum loop (ie OPEN/CLOSE) depth
421 % 6(0) *0 0 (code)
422 <+<<+>>>>>[
423 % 0 0 (code) M m D d 0 0 *P p (code) 0 c
424 % where Pp is first op of right code block
425 % Dd holds current loop depth (starting at 1)
426 % Mm holds the max loop depth yet encountered
427 % c = (unbalanced code ? 1 : 0)
428 <<<[->>+<<]<[->>+<<]<[->>+<<]<[->>+<<]>>>>>>>[-<<<<<<+>>>>>>]<
429 [->+<<<<<<<+>>>>>>]+>
430 % 0 0 (code) P p M m D d 1 *P (code) 0 c
431 -------[-[<->++++++++[-]]
432 <[-<<
433 # P is CLOSE; decrease Dd and leave Mm as it was
434 { 16b dec >>+<[>-<[->>+<<]]>>[-<<+>>]<<->[-<+<->++++++
435 ++[->++++++++<]>[-<++++>]<->]<< }
436 >>]>]
437 <[
438 # P is OPEN; if Mm==Dd then Mm=Dd=inc(Dd) else Dd=inc(Dd)
439 % (code) P p M m D d *1 0 (code) 0 c (note: p=0 since P=OPEN)
440 <<[-<<->>>>>+<<<]<<[[->>+<<]>>>>-<<<<]
441 % (code) P p *0 m sub(M D) d e D (code) 0 c (where e=(M==D ? 1 : 0))
442 >>>[-<<-<+>>>]<<[[->>+<<]>>>[-]<<<]
443 % (code) P p d *0 sub(M D) sub(m d) e D (code) 0 c (where e=(Mm==Dd ? 1 : 0))
444 >>[-<<+>>]<<<[->+>>+<<<]>>[-<<+>>]>>>[-<<<+<<+>>>>>]<[-<<<<<+>>>>>]<<
445 % (code) P e M m *D d 0 0 (code) 0 c (where e = (Mm==Dd ? 1 : 0))
446 { 16b inc >>>++++++++[-<++++++++>]<[->++++<]<[->+>-<<]
447 >+[-<+>]+>-[<->[-]]<[-<[-]<+>>]<< }
448 <<<[->[-]>[-]>[-<+<+>>]<[->+<]>>[->+<<<+>>]>[-<+>]<<<<<]>>>>>
449 ]
450 % 0 0 (code P p) M m D d *0 0 (code) 0 c (where Dd is properly updated)
451 << { 16b iszero [[->>+<<]>>>+<<<]>>[-<<+>>]<[[->+<]>>+<<]>[-<+>]+>[<->[-]]<<< }
452 >>[-<+>>>[>>]>[-]+<<<[<<]]>>
453 % 0 0 (code P p) M m D d 0 0 *(code) 0 c (where c is properly updated)
454 ]
455 % 0 0 (code) M m D d 0 0 *0 c
456 <<<<
457 { 16b dec >>+<[>-<[->>+<<]]>>[-<<+>>]<<->[-<+<->++++++
458 ++[->++++++++<]>[-<++++>]<->]<< }
459 { 16b isnonzero >[>>+<]>[<]<<[[->>+<<]>>>+<<<]>>[-<<+>>]>[[-]<+>]<<< }
460 >>[->>>[-]+<<<]<[-]<[-]<[->+<]<[->+<]>>>>>>>[-<<<<+>>>>]<<<<
461 <<<<<[<<]>+>[>>]>>>
462 % 0 1 (code) 0 M m *c 0 0 0
463 # if c==1 output string "Error: unbalanced brackets!\n"
464 [-<[-]<[-]<<<[<<]>->[>>]
465 +++++++++++[->++++++>++++++++++>+++<<<]>
466 % (code) 0 *66 110 33
467 +++.>++++..---.+++.<-----------.>>-.<+++.-------.
468 ------------.-.+++++++++++.-----------.+++++++++++++.
469 -----------.++.-.>.<--.++++++++++++++++.-----------------.
470 ++.++++++++.------.+++++++++++++++.-.>+.---[--->+<]>.[-]<<[-]<[-]>>>]
471 <<<<<[<<]
472 % T *0 b (code) 0 M m
473 % where b = (bytecode OK ? 1 : 0) and Mm = maximum loop depth
474
475 # This is the Java language backend for awib
476 # Please refer to the documentation in the full source code distribution
477 # of awib for additional details
478 % 23(0) *8 (code) 0 M m
479 # print Java header
480 ++[-<++++++++<++++++++<++++++++++<++++++++++<+++<++++++++++<++++++++++<+
481 +++++++++<+++<++++++<++<+++++++++++>>>>>>>>>>>>]<<<+++++.++++.+++.-.+++.
482 ++.<<++.>++++++.<<---.>>>++.<<<.>++++++++++++++.>-.++++++.<.>>>-------.<
483 <-.++.>-.-.>>+++.<<.--.<<<<+.>.>>---.<<<<<<-.<----------.<-----.++++.+++
484 .-.+++.++.>>>++.>>+++++.>.>>>++++.<<<.>.<<-.>>>++.<.>>>>----.<<-.-.<+.>+
485 .-.>>++++.<<.--.<<<<<+.>>.>>---.<<<<<<.<.>>>>.>>>.>--.-.+++.++.<<<<<<.>>
486 +.>.>>>++.<<<.>.<<-.>>>++.<.>>>.>----.<----.<++.<<<++.++.>>+.++++.<<<.++
487 ++++.-.<<<.<..<----.+++++.>>>>---.>--.---.<+.<.>.>+++.<--.>>>>-..<<<<<.<
488 +++++++.>>>>+.<<<.>>>>>>+++.<<<<<<<<.>>....>+.>>>>>--.<+.<<-.<<-------.+
489 +.<.>>+.<<<-------.<.>>....>>----.+++++.>>>.<<<<<.>>++.<<<.<.>>....>>>>>
490 >>++++.<<<<<--.++.>>>+.-.>>>++++.<<<.--.<<.----.<---.<<.>>----.<<<.<.>>.
491 ...>>>>>>>>----.<<----.-.<--.>+.-.>>++++.<<.--.<<<++++.----.>>---.<<<<<.
492 >>>>>++.<<<<<<.<..>>....>>>>>+.>+++.<<<+.<+++.---.>+.<<<.<+++++++.>>>---
493 .>>------.>>>.<<--.++.>.-.>>.<<.--.<<<++.----.>>---.<<<<<.>>+++.>>++++.<
494 <<<.>>>>>>>>----.<<+++.-.----.+++++.-.>>++++.<<.--.<<<++++.----.>>.<<<<<
495 .>>>>>++.<---.<<<<.<<<++++++.>.>>........>>++++.<<<-----.>>>+.>++++.>>>+
496 ++++.<<<<<<.>>>---.>>>++.-----.<<<+++.<<--.>>>+++++++.>>++++.<<+.-.+.-..
497 <<<++.<<--.<.>>........>>++.<<<++.>>>>>+.+.+++++.++++.<<<<<<.>>........>
498 >++++.>+++.+.<-.>>-------------.<.<<<<.>>>>.<<<<--.<.>>........>>+.>-.+.
499 <-.>>.>.<<<<<<++.>>>>>>.<<<<<<--.<.>>....<<<++.>..>>....>>---.+++++.<+++
500 ++.>>+++.---.<<+.<.>>+.>>>.<<.<<+.<.>>----.+++.>>>-.<<<<<.++++++++.+.---
501 ------.<<<--.>.>>........>>-.>-.+.<-.>>.<<<-----.>>>++.--------.+.<<<<<.
502 <.>>....<<<++.>..>>....>>---.+++++.<+++.>>+++.---.<<+.<.>>--.+.<--.>.>.<
503 <++.<.>>++.>>>+.<<.<<+.<.>>>>>--.<<<<---.>>.>>+.<-.>>>>.<<----.--.<<<.>>
504 .<<--.<<------.++.<.>++++.>>>>>.<<<.>>>+.<<+.<<<<.<<<--.>.>>........>>>>
505 >.<<--.<+.<<.<+++++++.>>>>+.>-.>>>>.<<++++++.------.+.<<<-.>>-.<++++++.>
506 ----.+++++.<--.>>>>.<<+++++.------.+.<<<.>>-.<++.>++.>+.-.<<-----.+++++.
507 >>--.+++.<-.<------.+.<<<<<-------.<.>>....<<<++.>..>>....>>>>>++.++.<<+
508 +++.<-.<.>--.>----.<<<.>>++.>>>---.------.<<-.<<<.>>----.>>-.+.<<<<.<<<-
509 -.>.>>........>>++.--.+++++++.<<.<<<.>.>>............>>>>>.<+++++.>>---.
510 <<<+.<<.>>-.>------.>++++.<++++.>>--.<<.+++++.--------.<<<<<.<.>>.......
511 .<<<++.>>>.>++.--.>-----.>-.+++++.<<<.>>>>-.>>>.>----.<----.<++++++++.<<
512 <<<++.++.>----.++++.>+.>>++.-.<<<<<.>.>>>+.<<<<.<<<--.++.>.>>....<<<.>..
513 >>....>>----.++.>.>>>--.<<<<<----.>++.>----.<<<.>>++.>>>+.------.<<-.<<<
514 .>>+.>>-.+.<<<<.<<<--.>.>>........>>---.--.>>>>+++.<<<<<<.<<<.>.>>......
515 ......>>---.>>+++++.>>--.-----.<.>++.<<<+.>------.<<--.<------.>+++.<++.
516 >>>+.<<<<<.<.>>............>>-.>>+++++.<+.<---.>>>>+.--.<-.<------.+.<<<
517 <<.<.>>........<<<++.>>>.>>>---.--.>>>+.<<<++.>>.<<<<<.>>>>-.>>>++++.>.<
518 ----.<++++.<<<.++.<++++.++++.>>>+.++++++.-.<<<<<.>>>.>+.<<<<.<<<--.++.>.
519 >>....<<<.>..>>....>>----.++.>++++.>>>--.<<<<<++++.>++.>----.<<<.>>++.>>
520 >+.------.<<-.<<<.>--.>>>+++++++.--------.+.<<<<.<<<--.>.[<]>[[-]>]
521 % 23(0) *0 (code) 0 M m
522 ++++++++++++++++[-<++++++++++++++++>]<-[-<<<<<<<<<<<<<<<+<+>>>>>>>>>>>>>>>>]
523 <<<<<<<<<<<<<<<<<<+<+>>>>>>>>>>>>>>>>>>>>
524 % 4(0) 1 0 255 255 15(0) *0 (code) 0 M m
525 >[<+>
526 % ::: (stack) 0 1:::1 0 c d 15(0) 1 *P i (code) 0 M m
527 % (where c and d form a two cell counter
528 % P(i) is the next op code)
529 # the stack segment is a sequence of adjacent C and D; these values
530 # are previous values of the cd counter that have been pushed to stack
531 # on OPEN; they are in turn popped on CLOSE
532 -[-[-[-[-[-[-[-[-[-[-[-[[-]
533 <[
534 # RMUL2
535 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
536 +++++[->+++++++++++++++<]>+++.-[--<+>]<---.-[-->+++<]>--.------[-<++>]<-.-
537 -----------------.+[---->+++++<]>---.+++[-----<++++>]<+.-[-->+<]>----.[-]
538 <<<+<<+>>>>
539 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
540 ]>]
541 <[
542 # RMUL1
543 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
544 ++++++++.---[->++++++++++++++++++<]>+.------------------.+[----<+++++>]<---.
545 --[----->++<]>-.[-]<<<+>>
546 % ::: (stack) 0 1:::1 0 c d 11(0) 0 0 1 0 *0 0 i (code) 0 M m
547 ]>]
548 <[
549 # LMUL2
550 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
551 +++++[->+++++++++++++++<]>+++.-[--<+>]<---.-[-->+++<]>--.------[-<++>]<-.-
552 -----------------.+[---->+++++<]>---.+++[-----<++++>]<+.-[-->+<]>----.[-]
553 <<<+<<+>>>>
554 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
555 ]>]
556 <[
557 # LMUL1
558 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
559 ++++++++.---[->++++++++++++++++++<]>+.------------------.+[----<+++++>]<---.
560 --[----->++<]>+.[-]<
561 <<+>>
562 % ::: (stack) 0 1:::1 0 c d 11(0) 0 0 1 0 *0 0 i (code) 0 M m
563 ]>]
564 <[
565 # SET
566 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
567 ++++[->++++++<]>[-<++++<+++<+<++>>>>]<-----------.<+.>+++.<++.
568 <<+.>++++++++++.>+++++.>+++++++++.-----.<+++.<+.>>[[-]<]+>>+>>
569 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
570 ]>]
571 <[-
572 # CLOSE
573 % ::: (stack) 0 1:::1 0 c d 15(0) *0 0 0 (code) 0 M m
574 # output: ' }\n\n private void '
575 +++++++++++++++++++++++++[-<+<+++++<++++<++<+++>>>>>]<+++++++....<.
576 >>++++++++++..<....<-------------.++.<+++++.>++++.<--------.>--.<++++
577 .>>.<++.-------.<++++.-----.>>.>[[-]<]<<<<<<<<<<<<
578 % ::: (stack) 0 1:::1 *0 c d 15(0) 0 0 0 (code) 0 M m
579 # fetch xy from top of stack
580 <[<]<[->>[>]>>>>+<<<<<[<]<]<[->>>[>]>>>>>+<<<<<<[<]<<]>+>+[>]
581 % ::: (stack) 0 1:::1 *0 c d 0 y x 12(0) 0 0 0 (code) 0 M m
582 # output: '_x_y'
583 >>>>>[
584 >++++++++[->++++++++++++<]>-.[-]
585 # itoa
586 ++++++++++<<[->>->+<[>-]>[>]<[-<++++++++++<+>>]<<<]++++++++++>>[-<<->>]
587 >++++++++++<<[->>->+<[>-]>[>]<[-<++++++++++<+>>]<<<]++++++++++>>[-<<->>]
588 >++++++[-<++++++++>]<<[>[-<+<+>>]<.[-]<.[-]>]
589 <[>>[-<<+>>]<<.[-]]>>[-]<<++++++[-<++++++++>]<.[-]<
590 ]
591 % ::: (stack) 0 1:::1 0 c d *0 14(0) 0 0 0 (code) 0 M m
592 # output: '() {'
593 +++++++++++++++++++++++++++++++++++++++++[->+++>+>++<<<]
594 >>-.+.---------.<.<++++++++++.[[-]>]>>>>>>>>>>>
595 % ::: (stack) 0 1:::1 0 c d 15(0) *0 0 0 (code) 0 M m
596 ]>]
597 <[-
598 # OPEN
599 % ::: (stack) 0 1:::1 0 c d 15(0) *0 0 0 (code) 0 M m
600 # build ef = dec(cd)
601 <<<<<<<<<<<<<<<<[[->>+>>>>>>>>+<<<<<<<<<<]<]
602 >>>>>+<-[>-]>[>]<[+++++++++++++++[-<++++++++++++++++>]<-<->>]<
603 % ::: (stack) 0 1:::1 0 0 0 e *f 6(0) c d 5(0) *0 0 0 (code) 0 M m
604 # push a copy of ef to stack
605 <<<<<[<]>->->[>]>>>
606 [-<<<<[<]<<+>>>[>]>>>>>>>>>+<<<<<<]>
607 [-<<<<<[<]<+>>[>]>>>>>>>>>>+<<<<<<]>>>>>>>>
608 % ::: (stack ef) 0 1:::1 9(0) e f c *d 5(0) 0 0 0 (code) 0 M m
609 # construct decimal representations of e f c and d
610 [
611 % 0 (counters) *n 5(0) 0 0 0
612 % (where n is the rightmost counter)
613 # itoa
614 % (counters) *n 5(0) 0 0 0
615 >>++++++++++<<[->>->+<[>-]>[>]<[-<++++++++++<+>>]<<<]++++++++++>>[-<<->>]
616 >++++++++++<<[->>->+<[>-]>[>]<[-<++++++++++<+>>]<<<]++++++++++>>[-<<->>]
617 >++++++[-<++++++++>]<<[>[-<+<+>>]<:[->>>>+<<<<]<:[->>>>>>+<<<<<<]>]
618 <[>>[-<<+>>]<<[->>>>>>+<<<<<<]]>>[-]<<++++++[-<++++++++>]<[->>>>>>>>+<<<<<<<<]
619 % (counters) *0 5(0) n2 n1 n0
620 % (where n2n1n0 is n in base 10
621 % ni is 0 if not significant)
622 # move down remaining counters to make room for next base 10 rep
623 <[<]>[[-<<+>>]>]<<<
624 ]
625 % ::: (stack) 0 1:::1 *0 8(0) e2 e1 e0 f2 f1 f0 c2 c1 c0 *d2 d1 d0 (code) 0 M m
626 # output: ' while(m{p}!=0){_'
627 # but with brackets instead of braces
628 ++++++++++++++++++++++++++++++[->++>+>++++>+++<<<<]>>++........>-.
629 ---------------.+.+++.-------.<++++++++.>++++++++.>+.<+++.>++.
630 <<-------.<+.-------------.-------.>>+++++++++++.>++.>
631 % 0 41 33 123 95 *0 0 0 0 e2 e1 e0 f2 f1 f0 c2 c1 c0 d2 d1 d0
632 # output: '_c_d();}'
633 # replace c and d with the corresponding decimal representation
634 >>>>>>>>>
635 >[.[-<<<<<<<<<+>>>>>>>>>]]>[.[-<<<<<<<<<+>>>>>>>>>]]>[.[-<<<<<<<<<+>>>>>>>>>]]
636 <<<<<<<<<<<<<.>>>>>>>>>>>>>
637 >[.[-<<<+>>>]]>[.[-<<<+>>>]]>[.[-<<<+>>>]]
638 <<<<<<<<<<<<<<<<<<<-.+.++++++++++++++++++.------------------>>++.
639 <<<++++++++++.>->-
640 % 10 40 *32 125 95 0 c2 c1 c0 e2 e1 e0 f2 f1 f0 d2 d1 d0 0 0 0
641 # output: ' _e_f();\n }\n\n private void _c_d'
642 # again with e f c and d replaced by their base 10 reps
643 ........>>.>>>>
644 >[.[->>>>>>>>>+<<<<<<<<<]]
645 >[.[->>>>>>>>>+<<<<<<<<<]]
646 >[.[->>>>>>>>>+<<<<<<<<<]]
647 <<<<<<<.>>>>>>>
648 >[.[-<<<+>>>]]
649 >[.[-<<<+>>>]]
650 >[.[-<<<+>>>]]
651 % 10 40 32 125 95 0 c2 c1 c0 f2 f1 f0 0 0 *0 d2 d1 d0 e2 e1 e0
652 <<<<<<<<<
653 <<<<.+.++++++++++++++++++.<.>>....>.<<<..>>....>-------------.++.---------.
654 +++++++++++++.>++.<--.>++++.<<.>++.-------.>++++.-----.<<.>>-----.<<<<
655 % *10 59 32 111 95 0 c2 c1 c0 f2 f1 f0 0 0 0 d2 d1 d0 e2 e1 e0
656 >>>>>
657 >[.[-]]>[.[-]]>[.[-]]
658 <<<<.>>>>>>>>>>
659 >[.[-]]>[.[-]]>[.[-]]
660 % 10 59 32 111 95 0 0 0 0 f2 f1 f0 0 0 0 0 0 *0 e2 e1 e0
661 # restore ef
662 >[[-<+>]++++++[-<-------->]]
663 >[[-<+>]++++++[-<-------->]]
664 >[[-<+>]++++++[-<-------->]]
665 <<[->++++++++++<]
666 <[->++++++++++[->++++++++++<]<]
667 <<<<<
668 <[[->+<]++++++[->--------<]]
669 <[[->+<]++++++[->--------<]]
670 <[[->+<]++++++[->--------<]]
671 >>[->++++++++++<]<[->++++++++++[->++++++++++<]<]
672 % 10 59 32 111 95 0 0 0 0 0 *0 0 f 0 0 0 0 0 0 e 0
673 # output: '() {'
674 # and move ef into position
675 <<<<<<<<++++++++.+.---------.>++++++++++++.<<<.
676 [[-]>]
677 >>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]
678 >>>>>>>[-<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>]
679 % 0 e f 15(0) 0 *0 0
680 # leave behind gh = dec(dec(cd)) = dec(ef)
681 <<<<<<<<<<<<<<<<+<-[>-]>[>]<[+++++++++++++++[-<++++++++++++++++>]<-<->>]
682 >>>>>>>>>>>>>>>
683 % ::: (stack) 0 1:::1 0 g h 15(0) *0 0 0 (code) 0 M m
684 ]>]
685 <[
686 # RIGHT
687 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
688 ++++++++.---[->+++++++++++++++++++<]>--.--[-----<++>]<-.-[-->+++<]>--.[-]<
689 <<+<<+>>>>
690 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
691 ]>]
692 <[
693 # LEFT
694 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
695 ++++++++.---[->+++++++++++++++++++<]>--.--[-----<++>]<+.[--->++++<]>+.[-]<
696 <<+<<+>>>>
697 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
698 ]>]
699 <[
700 # OUTPUT
701 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
702 ++++++++.---[->++++++++++++++++++++<]>-.+[---<+>]<.+.[-]
703 <<<<+>>>>
704 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 0 0 *0 0 i (code) 0 M m
705 ]>]
706 <[
707 # SUB
708 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
709 ++++++++.---[->++++++++++++++++++<]>+.------------------.+[----<+++++>]<---.
710 +++[----->++++<]>+.-[--<+>]<-.[--->++++<]>+.[-]<
711 <<+<<+>>>>
712 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
713 ]>]
714 <[
715 # INPUT
716 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
717 ++++++++.---[->+++++++++++++++++++<]>.[---<+>]<++.+.[-]
718 <<<<+>>>>
719 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 0 0 *0 0 i (code) 0 M m
720 ]>]
721 <[
722 # ADD
723 % ::: (stack) 0 1:::1 0 c d 15(0) *1 0 i (code) 0 M m
724 ++++++++.---[->++++++++++++++++++<]>+.------------------.+[----<+++++>]<---.
725 +++[----->++++<]>+.-[--<+>]<---.-[-->+++<]>--.[-]<
726 <<+<<+>>>>
727 % ::: (stack) 0 1:::1 0 c d 11(0) 1 0 1 0 *0 0 i (code) 0 M m
728 ]
729 # optionally append ; and/or itoa(i)
730 % ::: (stack) 0 1:::1 0 c d 11(0) b 0 a 0 *0 0 i (code) 0 M m
731 % (where a==1 iff i should be output
732 % b==1 iff ';\n' should be output)
733 <<[->>
734 % ::: b 0 0 0 *0 0 i (code) 0 M m
735 # itoa
736 ++++++++++>>[-<<-<+>[<-]<[<]>[->++++++++++>+<<]>>>]++++++++++<<[->>-<<]
737 <++++++++++>>[-<<-<+>[<-]<[<]>[->++++++++++>+<<]>>>]++++++++++<<[->>-<<]
738 <++++++[->++++++++<]>>[<[->+>+<<]>.[-]>.[-]<]
739 >[<<[->>+<<]>>.[-]]<<[-]>>++++++[->++++++++<]>.[-]
740 <<<<]
741 <<[+++++[->++++++++++<]>-.[-]++++++++++.[-]<]>>>>>>[-]
742 % ::: (stack) 0 1:::1 0 c d 15(0) 0 0 *0 (code) 0 M m
743 # copy up cd; extend the 1 sled; process next operation
744 <<<<<<<<<<<<<<<<<<[->>+<<]<[->>+<<]+<+>>>>>>>>>>>>>>>>>>>>
745 >]
746 % ::: 0 0 0 *0 M m
747 # footer
748 >[-]>[-]++++[->++++++++<]>....[->++++<]>---.>++++++++++.<.[-]>.[-]
749 % ::: 0 0 *0 0 0