• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Révision148 (tree)
l'heure2018-09-23 13:33:36
Auteurjakobthomsen

Message de Log

compile-time stack-offsets

Change Summary

Modification

--- trunk/experimental/compiler.compiled.c (revision 147)
+++ trunk/experimental/compiler.compiled.c (revision 148)
@@ -26,11 +26,22 @@
2626 #define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, "returned to 0x%0llXLLU\n", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; }
2727 #define ADDR stack$$$[ADDR_IDX]
2828
29+uint64_t SP = 0;
30+void SP_TRACK() { fprintf(stdout, "// SP %llu\n", (long long unsigned int)SP); }
31+void SP_VERIFY() { fprintf(stdout, "// VERIFY SP\nif(sp$$$ != %lluLLU) { fprintf(stderr, \"verify failed, sp %cllu != %llu SP in line %cd\\n\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\n", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); }
32+uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; }
33+uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; }
34+uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; }
35+uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; }
36+
2937 int32_t main()
3038 {
3139 uint64_t *stack$$$ = malloc(8 * 1048576LLU);
3240 register uint64_t sb$$$ = 17; // skip space reserved for globals
3341 register uint64_t sp$$$ = 0;
42+// SP 0
43+// VERIFY SP
44+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3445 register uint64_t sz$$$ = 0;
3546 register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol
3647 register uint64_t c$$$;
@@ -41,146 +52,232 @@
4152 {
4253 // reserve space for globals
4354
44-case /*false_____*/0x85C9EE8000000000LLU:
55+case /*false_____*/0x85C9EE8000000000LLU:// SP 0
56+// VERIFY SP
57+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4558
59+
4660 PUSH(0LLU);
61+// SP 1
62+// VERIFY SP
63+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4764 ACCESS_RETURN = POP;
65+// SP 0
66+// VERIFY SP
67+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4868
4969 RET;
5070
5171
52-case /*true______*/0xBEDC200000000000LLU:
72+case /*true______*/0xBEDC200000000000LLU:// SP 0
73+// VERIFY SP
74+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5375
76+
5477 PUSH(1LLU);
78+// SP 1
79+// VERIFY SP
80+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5581 ACCESS_RETURN = POP;
82+// SP 0
83+// VERIFY SP
84+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5685
5786 RET;
5887
5988
60-case /*exit______*/0x83392F0000000000LLU:
89+case /*exit______*/0x83392F0000000000LLU:// SP 0
90+// VERIFY SP
91+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6192
93+
6294 exit(ACCESS_ARG(0));
6395 RET;
6496
6597
66-case /*equ_______*/0x82CC000000000000LLU:
98+case /*equ_______*/0x82CC000000000000LLU:// SP 0
99+// VERIFY SP
100+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
67101
102+
68103 ACCESS_RETURN = ACCESS_ARG(0) == ACCESS_ARG(1);
69104 RET;
70105
71106
72-case /*geq_______*/0x8A0B000000000000LLU:
107+case /*geq_______*/0x8A0B000000000000LLU:// SP 0
108+// VERIFY SP
109+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
73110
111+
74112 ACCESS_RETURN = ACCESS_ARG(0) >= ACCESS_ARG(1);
75113 RET;
76114
77115
78-case /*gtr_______*/0x8AFB400000000000LLU:
116+case /*gtr_______*/0x8AFB400000000000LLU:// SP 0
117+// VERIFY SP
118+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
79119
120+
80121 ACCESS_RETURN = ACCESS_ARG(0) > ACCESS_ARG(1);
81122 RET;
82123
83124
84-case /*leq_______*/0x9E0B000000000000LLU:
125+case /*leq_______*/0x9E0B000000000000LLU:// SP 0
126+// VERIFY SP
127+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
85128
129+
86130 ACCESS_RETURN = ACCESS_ARG(0) <= ACCESS_ARG(1);
87131 RET;
88132
89133
90-case /*lss_______*/0x9EEB800000000000LLU:
134+case /*lss_______*/0x9EEB800000000000LLU:// SP 0
135+// VERIFY SP
136+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
91137
138+
92139 ACCESS_RETURN = ACCESS_ARG(0) < ACCESS_ARG(1);
93140 RET;
94141
95142
96-case /*neq_______*/0xA60B000000000000LLU:
143+case /*neq_______*/0xA60B000000000000LLU:// SP 0
144+// VERIFY SP
145+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
97146
147+
98148 ACCESS_RETURN = (ACCESS_ARG(0) != ACCESS_ARG(1));
99149 RET;
100150
101151
102-case /*and_______*/0x7297C00000000000LLU:
152+case /*and_______*/0x7297C00000000000LLU:// SP 0
153+// VERIFY SP
154+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
103155
156+
104157 ACCESS_RETURN = (ACCESS_ARG(0) && ACCESS_ARG(1));
105158 RET;
106159
107160
108-case /*or________*/0xAAD0000000000000LLU:
161+case /*or________*/0xAAD0000000000000LLU:// SP 0
162+// VERIFY SP
163+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
109164
165+
110166 ACCESS_RETURN = (ACCESS_ARG(0) || ACCESS_ARG(1));
111167 RET;
112168
113169
114-case /*not_______*/0xA6ABC00000000000LLU:
170+case /*not_______*/0xA6ABC00000000000LLU:// SP 0
171+// VERIFY SP
172+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
115173
174+
116175 ACCESS_RETURN = !ACCESS_ARG(0);
117176 RET;
118177
119178
120-case /*id________*/0x91F0000000000000LLU:
179+case /*id________*/0x91F0000000000000LLU:// SP 0
180+// VERIFY SP
181+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
121182
183+
122184 ACCESS_RETURN = ACCESS_ARG(0);
123185 RET;
124186
125187
126-case /*inc_______*/0x9297800000000000LLU:
188+case /*inc_______*/0x9297800000000000LLU:// SP 0
189+// VERIFY SP
190+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
127191
192+
128193 ACCESS_RETURN = ACCESS_ARG(0) + 1;
129194 RET;
130195
131196
132-case /*dec_______*/0x7E07800000000000LLU:
197+case /*dec_______*/0x7E07800000000000LLU:// SP 0
198+// VERIFY SP
199+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
133200
201+
134202 ACCESS_RETURN = ACCESS_ARG(0) - 1;
135203 RET;
136204
137205
138-case /*add_______*/0x71F7C00000000000LLU:
206+case /*add_______*/0x71F7C00000000000LLU:// SP 0
207+// VERIFY SP
208+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
139209
210+
140211 ACCESS_RETURN = ACCESS_ARG(0) + ACCESS_ARG(1);
141212 RET;
142213
143214
144-case /*sub_______*/0xBB07400000000000LLU:
215+case /*sub_______*/0xBB07400000000000LLU:// SP 0
216+// VERIFY SP
217+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
145218
219+
146220 ACCESS_RETURN = ACCESS_ARG(0) - ACCESS_ARG(1);
147221 RET;
148222
149223
150-case /*mul_______*/0xA309C00000000000LLU:
224+case /*mul_______*/0xA309C00000000000LLU:// SP 0
225+// VERIFY SP
226+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
151227
228+
152229 ACCESS_RETURN = ACCESS_ARG(0) * ACCESS_ARG(1);
153230 RET;
154231
155232
156-case /*div_______*/0x7E4C400000000000LLU:
233+case /*div_______*/0x7E4C400000000000LLU:// SP 0
234+// VERIFY SP
235+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
157236
237+
158238 ACCESS_RETURN = ACCESS_ARG(0) / ACCESS_ARG(1);
159239 RET;
160240
161241
162-case /*noop______*/0xA6AAAB0000000000LLU:
242+case /*noop______*/0xA6AAAB0000000000LLU:// SP 0
243+// VERIFY SP
244+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
163245
246+
164247 fprintf(stderr,"d");
165248 RET;
166249
167250
168-case /*skip______*/0xBA692B0000000000LLU:
251+case /*skip______*/0xBA692B0000000000LLU:// SP 0
252+// VERIFY SP
253+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
169254
170- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFFELLU, 0x8A0BC00000000000LLU);
255+
256+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
257+// SP 5
258+// VERIFY SP
259+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
260+CALLEND(0LLU, 0xFFFFFFFFFFFFFFFELLU, 0x8A0BC00000000000LLU);
171261 case 0xFFFFFFFFFFFFFFFELLU:
262+// SP 1
172263
173264 RET;
174265
175266
176-case /*put_______*/0xAF0BC00000000000LLU:
267+case /*put_______*/0xAF0BC00000000000LLU:// SP 0
268+// VERIFY SP
269+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
177270
271+
178272 ACCESS_RETURN = fputc(ACCESS_ARG(0), stdout);
179273 RET;
180274
181275
182-case /*get_______*/0x8A0BC00000000000LLU:
276+case /*get_______*/0x8A0BC00000000000LLU:// SP 0
277+// VERIFY SP
278+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
183279
280+
184281 if('\n' == ungetc(fgetc(stdin), stdin))
185282 {
186283 stack$$$[LINENR_IDX]++;
@@ -189,44 +286,89 @@
189286 RET;
190287
191288
192-case /*peek______*/0xAE08260000000000LLU:
289+case /*peek______*/0xAE08260000000000LLU:// SP 0
290+// VERIFY SP
291+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
193292
293+
194294 ACCESS_RETURN = ungetc(fgetc(stdin), stdin);
195295 RET;
196296
197297
198-case /*echo______*/0x81E8EA0000000000LLU:
298+case /*echo______*/0x81E8EA0000000000LLU:// SP 0
299+// VERIFY SP
300+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
199301
200- CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFFDLLU, 0x8A0BC00000000000LLU);
302+
303+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
304+// SP 5
305+// VERIFY SP
306+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
307+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
308+// SP 10
309+// VERIFY SP
310+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
311+CALLEND(0LLU, 0xFFFFFFFFFFFFFFFDLLU, 0x8A0BC00000000000LLU);
201312 case 0xFFFFFFFFFFFFFFFDLLU:
313+// SP 6
202314 CALLEND(1LLU, 0xFFFFFFFFFFFFFFFCLLU, 0xAF0BC00000000000LLU);
203315 case 0xFFFFFFFFFFFFFFFCLLU:
316+// SP 1
204317 ACCESS_RETURN = POP;
318+// SP 0
319+// VERIFY SP
320+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
205321
206322 RET;
207323
208324
209-case /*echonr____*/0x81E8EAA6D0000000LLU:
325+case /*echonr____*/0x81E8EAA6D0000000LLU:// SP 0
326+// VERIFY SP
327+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
210328
329+
211330 case 0xFFFFFFFFFFFFFFFBLLU: // loop to here
212331 // predicate
213-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF9LLU, 0xAE08260000000000LLU);
332+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
333+// SP 5
334+// VERIFY SP
335+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
336+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
337+// SP 10
338+// VERIFY SP
339+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
340+CALLEND(0LLU, 0xFFFFFFFFFFFFFFF9LLU, 0xAE08260000000000LLU);
214341 case 0xFFFFFFFFFFFFFFF9LLU:
342+// SP 6
215343 CALLEND(1LLU, 0xFFFFFFFFFFFFFFF8LLU, 0x92E7E48A4BC00000LLU);
216344 case 0xFFFFFFFFFFFFFFF8LLU:
217-if(!ACCESS_CURRENT)
345+// SP 1
346+if(!POP)
347+// SP 0
218348 JUMP(0xFFFFFFFFFFFFFFFALLU); // skip loop
219349 // loop
220350
221- PUSH(0); // place-holder for result of block
222-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
351+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
352+// SP 1
353+// VERIFY SP
354+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
223355 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
224356
225- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF7LLU, 0x81E8EA0000000000LLU);
357+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
358+// SP 6
359+// VERIFY SP
360+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
361+CALLEND(0LLU, 0xFFFFFFFFFFFFFFF7LLU, 0x81E8EA0000000000LLU);
226362 case 0xFFFFFFFFFFFFFFF7LLU:
363+// SP 2
227364
228- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
365+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
366+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
367+// SP 1
229368 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
369+// SP 0
370+// VERIFY SP
371+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
230372 JUMP(0xFFFFFFFFFFFFFFFBLLU); // loop
231373 case 0xFFFFFFFFFFFFFFFALLU: // skip to here
232374
@@ -233,296 +375,662 @@
233375 RET;
234376
235377
236-case /*match_____*/0xA1CBDE8C00000000LLU:
378+case /*match_____*/0xA1CBDE8C00000000LLU:// SP 0
379+// VERIFY SP
380+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
237381
382+
238383 // predicate
239-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF4LLU, 0x8A0BC00000000000LLU);
384+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
385+// SP 5
386+// VERIFY SP
387+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
388+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
389+// SP 10
390+// VERIFY SP
391+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
392+CALLEND(0LLU, 0xFFFFFFFFFFFFFFF4LLU, 0x8A0BC00000000000LLU);
240393 case 0xFFFFFFFFFFFFFFF4LLU:
394+// SP 6
241395 PUSH(ACCESS_ARG(0));
396+// SP 7
397+// VERIFY SP
398+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
242399 CALLEND(2LLU, 0xFFFFFFFFFFFFFFF3LLU, 0xA60B000000000000LLU);
243400 case 0xFFFFFFFFFFFFFFF3LLU:
244-if(!ACCESS_CURRENT)
401+// SP 1
402+if(!POP)
403+// SP 0
245404 JUMP(0xFFFFFFFFFFFFFFF6LLU); // skip consequent
246405 // consequent
247406
248- PUSH(0); // place-holder for result of block
249-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
407+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
408+// SP 1
409+// VERIFY SP
410+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
250411 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
251412
252413 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
253414 fprintf(stderr, "expected '%c' but found '%c'\n", (char)ACCESS_ARG(0), (char)c$$$);
254415 exit(-1);
255- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
416+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
417+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
418+// SP 1
256419 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
420+// SP 0
421+// VERIFY SP
422+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
257423 JUMP(0xFFFFFFFFFFFFFFF5LLU); // skip alternative
258424 case 0xFFFFFFFFFFFFFFF6LLU: // alternative
259425
260426
261- PUSH(0); // place-holder for result of block
262-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
427+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
428+// SP 1
429+// VERIFY SP
430+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
263431 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
264432
265- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
433+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
434+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
435+// SP 1
266436 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
437+// SP 0
438+// VERIFY SP
439+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
267440 case 0xFFFFFFFFFFFFFFF5LLU: // skip to here
268441
269442 RET;
270443
271444
272-case /*matchopt__*/0xA1CBDE8EAAEF0000LLU:
445+case /*matchopt__*/0xA1CBDE8EAAEF0000LLU:// SP 0
446+// VERIFY SP
447+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
273448
449+
274450 // predicate
275-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF0LLU, 0xAE08260000000000LLU);
451+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
452+// SP 5
453+// VERIFY SP
454+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
455+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
456+// SP 10
457+// VERIFY SP
458+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
459+CALLEND(0LLU, 0xFFFFFFFFFFFFFFF0LLU, 0xAE08260000000000LLU);
276460 case 0xFFFFFFFFFFFFFFF0LLU:
461+// SP 6
277462 PUSH(ACCESS_ARG(0));
463+// SP 7
464+// VERIFY SP
465+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
278466 CALLEND(2LLU, 0xFFFFFFFFFFFFFFEFLLU, 0x82CC000000000000LLU);
279467 case 0xFFFFFFFFFFFFFFEFLLU:
280-if(!ACCESS_CURRENT)
468+// SP 1
469+if(!POP)
470+// SP 0
281471 JUMP(0xFFFFFFFFFFFFFFF2LLU); // skip consequent
282472 // consequent
283473
284- PUSH(0); // place-holder for result of block
285-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
474+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
475+// SP 1
476+// VERIFY SP
477+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
286478 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
287479
288- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEELLU, 0xBA692B0000000000LLU);
480+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
481+// SP 6
482+// VERIFY SP
483+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
484+CALLEND(0LLU, 0xFFFFFFFFFFFFFFEELLU, 0xBA692B0000000000LLU);
289485 case 0xFFFFFFFFFFFFFFEELLU:
486+// SP 2
290487
291488 PUSH(1LLU);
489+// SP 3
490+// VERIFY SP
491+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
292492 ACCESS_RETURN = POP;
493+// SP 2
494+// VERIFY SP
495+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
293496
294- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
497+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
498+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
499+// SP 1
295500 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
501+// SP 0
502+// VERIFY SP
503+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
296504 JUMP(0xFFFFFFFFFFFFFFF1LLU); // skip alternative
297505 case 0xFFFFFFFFFFFFFFF2LLU: // alternative
298506
299507
300- PUSH(0); // place-holder for result of block
301-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
508+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
509+// SP 1
510+// VERIFY SP
511+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
302512 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
303513
304514 PUSH(0LLU);
515+// SP 2
516+// VERIFY SP
517+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
305518 ACCESS_RETURN = POP;
519+// SP 1
520+// VERIFY SP
521+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
306522
307- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
523+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
524+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
525+// SP 1
308526 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
527+// SP 0
528+// VERIFY SP
529+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
309530 case 0xFFFFFFFFFFFFFFF1LLU: // skip to here
310531
311532 RET;
312533
313534
314-case /*isalpha___*/0x92E727AE37000000LLU:
535+case /*isalpha___*/0x92E727AE37000000LLU:// SP 0
536+// VERIFY SP
537+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
315538
539+
316540 ACCESS_RETURN = isalpha((char)ACCESS_ARG(0));
317541 RET;
318542
319543
320-case /*isdigit___*/0x92E7E48A4BC00000LLU:
544+case /*isdigit___*/0x92E7E48A4BC00000LLU:// SP 0
545+// VERIFY SP
546+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
321547
548+
322549 ACCESS_RETURN = isdigit((char)ACCESS_ARG(0));
323550 RET;
324551
325552
326-case /*isspace___*/0x92EBAB71E8000000LLU:
553+case /*isspace___*/0x92EBAB71E8000000LLU:// SP 0
554+// VERIFY SP
555+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
327556
557+
328558 ACCESS_RETURN = isspace((char)ACCESS_ARG(0));
329559 RET;
330560
331561
332-case /*parseexpr_*/0xADCB6E820CEBB400LLU:
562+case /*parseexpr_*/0xADCB6E820CEBB400LLU:// SP 0
563+// VERIFY SP
564+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
333565
334- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEDLLU, 0xBA692B7A8A6FB800LLU);
566+
567+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
568+// SP 5
569+// VERIFY SP
570+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
571+CALLEND(0LLU, 0xFFFFFFFFFFFFFFEDLLU, 0xBA692B7A8A6FB800LLU);
335572 case 0xFFFFFFFFFFFFFFEDLLU:
573+// SP 1
336574
337575 // predicate
338-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEALLU, 0xAE08260000000000LLU);
576+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
577+// SP 6
578+// VERIFY SP
579+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
580+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
581+// SP 11
582+// VERIFY SP
583+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
584+CALLEND(0LLU, 0xFFFFFFFFFFFFFFEALLU, 0xAE08260000000000LLU);
339585 case 0xFFFFFFFFFFFFFFEALLU:
586+// SP 7
340587 CALLEND(1LLU, 0xFFFFFFFFFFFFFFE9LLU, 0x92E727AE37000000LLU);
341588 case 0xFFFFFFFFFFFFFFE9LLU:
342-if(!ACCESS_CURRENT)
589+// SP 2
590+if(!POP)
591+// SP 1
343592 JUMP(0xFFFFFFFFFFFFFFECLLU); // skip consequent
344593 // consequent
345594
346- PUSH(0); // place-holder for result of block
347-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
595+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
596+// SP 2
597+// VERIFY SP
598+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
348599 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
349600
350- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE8LLU, 0xADCB6E81E7279C00LLU);
601+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
602+// SP 7
603+// VERIFY SP
604+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
605+CALLEND(0LLU, 0xFFFFFFFFFFFFFFE8LLU, 0xADCB6E81E7279C00LLU);
351606 case 0xFFFFFFFFFFFFFFE8LLU:
607+// SP 3
352608
353- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
609+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
610+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
611+// SP 2
354612 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
613+// SP 1
614+// VERIFY SP
615+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
355616 JUMP(0xFFFFFFFFFFFFFFEBLLU); // skip alternative
356617 case 0xFFFFFFFFFFFFFFECLLU: // alternative
357618
358619
359- PUSH(0); // place-holder for result of block
360-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
620+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
621+// SP 2
622+// VERIFY SP
623+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
361624 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
362625
363626 // predicate
364-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE5LLU, 0xAE08260000000000LLU);
627+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
628+// SP 7
629+// VERIFY SP
630+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
631+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
632+// SP 12
633+// VERIFY SP
634+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
635+CALLEND(0LLU, 0xFFFFFFFFFFFFFFE5LLU, 0xAE08260000000000LLU);
365636 case 0xFFFFFFFFFFFFFFE5LLU:
637+// SP 8
366638 CALLEND(1LLU, 0xFFFFFFFFFFFFFFE4LLU, 0x92E7E48A4BC00000LLU);
367639 case 0xFFFFFFFFFFFFFFE4LLU:
368-if(!ACCESS_CURRENT)
640+// SP 3
641+if(!POP)
642+// SP 2
369643 JUMP(0xFFFFFFFFFFFFFFE7LLU); // skip consequent
370644 // consequent
371645
372- PUSH(0); // place-holder for result of block
373-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
646+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
647+// SP 3
648+// VERIFY SP
649+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
374650 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
375651
376652 fprintf(stdout, "PUSH(");
377- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE3LLU, 0x81E8EAA6D0000000LLU);
653+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
654+// SP 8
655+// VERIFY SP
656+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
657+CALLEND(0LLU, 0xFFFFFFFFFFFFFFE3LLU, 0x81E8EAA6D0000000LLU);
378658 case 0xFFFFFFFFFFFFFFE3LLU:
659+// SP 4
379660
380661 fprintf(stdout, "LLU);\n");
381- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
662+ SP_ADD_VERIFY(1);
663+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
664+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
665+// SP 3
382666 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
667+// SP 2
668+// VERIFY SP
669+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
383670 JUMP(0xFFFFFFFFFFFFFFE6LLU); // skip alternative
384671 case 0xFFFFFFFFFFFFFFE7LLU: // alternative
385672
386673
387- PUSH(0); // place-holder for result of block
388-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
674+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
675+// SP 3
676+// VERIFY SP
677+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
389678 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
390679
391680 // predicate
392-CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFE0LLU, 0xA1CBDE8EAAEF0000LLU);
681+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
682+// SP 8
683+// VERIFY SP
684+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
685+PUSH(35LLU);// SP 9
686+// VERIFY SP
687+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
688+CALLEND(1LLU, 0xFFFFFFFFFFFFFFE0LLU, 0xA1CBDE8EAAEF0000LLU);
393689 case 0xFFFFFFFFFFFFFFE0LLU:
394-if(!ACCESS_CURRENT)
690+// SP 4
691+if(!POP)
692+// SP 3
395693 JUMP(0xFFFFFFFFFFFFFFE2LLU); // skip consequent
396694 // consequent
397695
398- PUSH(0); // place-holder for result of block
399-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
696+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
697+// SP 4
698+// VERIFY SP
699+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
400700 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
401701
402- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFDFLLU, 0xAF0BA372D8800000LLU);
702+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
703+// SP 9
704+// VERIFY SP
705+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
706+CALLEND(0LLU, 0xFFFFFFFFFFFFFFDFLLU, 0xAF0BA372D8800000LLU);
403707 case 0xFFFFFFFFFFFFFFDFLLU:
708+// SP 5
404709
405- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
710+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
711+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
712+// SP 4
406713 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
714+// SP 3
715+// VERIFY SP
716+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
407717 JUMP(0xFFFFFFFFFFFFFFE1LLU); // skip alternative
408718 case 0xFFFFFFFFFFFFFFE2LLU: // alternative
409719
410720
411- PUSH(0); // place-holder for result of block
412-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
721+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
722+// SP 4
723+// VERIFY SP
724+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
413725 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
414726
415727 // predicate
416-CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFDCLLU, 0xA1CBDE8EAAEF0000LLU);
728+CALLBEGIN(1/*nr of chunks returned*/); // SP 5
729+// SP 9
730+// VERIFY SP
731+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
732+PUSH(94LLU);// SP 10
733+// VERIFY SP
734+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
735+CALLEND(1LLU, 0xFFFFFFFFFFFFFFDCLLU, 0xA1CBDE8EAAEF0000LLU);
417736 case 0xFFFFFFFFFFFFFFDCLLU:
418-if(!ACCESS_CURRENT)
737+// SP 5
738+if(!POP)
739+// SP 4
419740 JUMP(0xFFFFFFFFFFFFFFDELLU); // skip consequent
420741 // consequent
421742
422- PUSH(0); // place-holder for result of block
423-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
743+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
744+// SP 5
745+// VERIFY SP
746+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
424747 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
425748
426- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFDBLLU, 0xAF0BA38A7A9D0000LLU);
749+ CALLBEGIN(1/*nr of chunks returned*/); // SP 6
750+// SP 10
751+// VERIFY SP
752+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
753+CALLEND(0LLU, 0xFFFFFFFFFFFFFFDBLLU, 0xAF0BA38A7A9D0000LLU);
427754 case 0xFFFFFFFFFFFFFFDBLLU:
755+// SP 6
428756
429- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
757+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
758+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
759+// SP 5
430760 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
761+// SP 4
762+// VERIFY SP
763+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
431764 JUMP(0xFFFFFFFFFFFFFFDDLLU); // skip alternative
432765 case 0xFFFFFFFFFFFFFFDELLU: // alternative
433766
434767
435- PUSH(0); // place-holder for result of block
436-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
768+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
769+// SP 5
770+// VERIFY SP
771+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
437772 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
438773
439774 // predicate
440-CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFD8LLU, 0xA1CBDE8EAAEF0000LLU);
775+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
776+// SP 10
777+// VERIFY SP
778+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
779+PUSH(96LLU);// SP 11
780+// VERIFY SP
781+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
782+CALLEND(1LLU, 0xFFFFFFFFFFFFFFD8LLU, 0xA1CBDE8EAAEF0000LLU);
441783 case 0xFFFFFFFFFFFFFFD8LLU:
442-if(!ACCESS_CURRENT)
784+// SP 6
785+if(!POP)
786+// SP 5
443787 JUMP(0xFFFFFFFFFFFFFFDALLU); // skip consequent
444788 // consequent
445789
446- PUSH(0); // place-holder for result of block
447-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
790+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
791+// SP 6
792+// VERIFY SP
793+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
448794 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
449795
450- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD7LLU, 0xAF0BA3C5CB400000LLU);
796+ CALLBEGIN(1/*nr of chunks returned*/); // SP 7
797+// SP 11
798+// VERIFY SP
799+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
800+CALLEND(0LLU, 0xFFFFFFFFFFFFFFD7LLU, 0xAF0BA3C5CB400000LLU);
451801 case 0xFFFFFFFFFFFFFFD7LLU:
802+// SP 7
452803
453- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
804+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
805+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
806+// SP 6
454807 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
808+// SP 5
809+// VERIFY SP
810+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
455811 JUMP(0xFFFFFFFFFFFFFFD9LLU); // skip alternative
456812 case 0xFFFFFFFFFFFFFFDALLU: // alternative
457813
458814
459- PUSH(0); // place-holder for result of block
460-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
815+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
816+// SP 6
817+// VERIFY SP
818+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
461819 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
462820
463- fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
464- fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));
465- exit(-1);
466- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
821+ // predicate
822+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
823+// SP 11
824+// VERIFY SP
825+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
826+PUSH(40LLU);// SP 12
827+// VERIFY SP
828+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
829+CALLEND(1LLU, 0xFFFFFFFFFFFFFFD4LLU, 0xA1CBDE8EAAEF0000LLU);
830+case 0xFFFFFFFFFFFFFFD4LLU:
831+// SP 7
832+if(!POP)
833+// SP 6
834+ JUMP(0xFFFFFFFFFFFFFFD6LLU); // skip consequent
835+// consequent
836+
837+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
838+// SP 7
839+// VERIFY SP
840+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
841+stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
842+
843+ CALLBEGIN(1/*nr of chunks returned*/); // SP 8
844+// SP 12
845+// VERIFY SP
846+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
847+PUSH(ACCESS_ARG(0));
848+// SP 13
849+// VERIFY SP
850+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
851+CALLEND(1LLU, 0xFFFFFFFFFFFFFFD3LLU, 0xADCB6E820CEBB400LLU);
852+case 0xFFFFFFFFFFFFFFD3LLU:
853+// SP 8
854+
855+ CALLBEGIN(1/*nr of chunks returned*/); // SP 9
856+// SP 13
857+// VERIFY SP
858+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
859+CALLEND(0LLU, 0xFFFFFFFFFFFFFFD2LLU, 0xBA692B7A8A6FB800LLU);
860+case 0xFFFFFFFFFFFFFFD2LLU:
861+// SP 9
862+
863+ CALLBEGIN(1/*nr of chunks returned*/); // SP 10
864+// SP 14
865+// VERIFY SP
866+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
867+PUSH(41LLU);// SP 15
868+// VERIFY SP
869+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
870+CALLEND(1LLU, 0xFFFFFFFFFFFFFFD1LLU, 0xA1CBDE8C00000000LLU);
871+case 0xFFFFFFFFFFFFFFD1LLU:
872+// SP 10
873+
874+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
875+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
876+// SP 7
467877 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
878+// SP 6
879+// VERIFY SP
880+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
881+ JUMP(0xFFFFFFFFFFFFFFD5LLU); // skip alternative
882+case 0xFFFFFFFFFFFFFFD6LLU: // alternative
883+
884+
885+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
886+// SP 7
887+// VERIFY SP
888+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
889+stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
890+
891+ fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
892+ fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));
893+ exit(-1);
894+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
895+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
896+// SP 7
897+stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
898+// SP 6
899+// VERIFY SP
900+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
901+case 0xFFFFFFFFFFFFFFD5LLU: // skip to here
902+
903+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
904+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
905+// SP 6
906+stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
907+// SP 5
908+// VERIFY SP
909+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
468910 case 0xFFFFFFFFFFFFFFD9LLU: // skip to here
469911
470- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
912+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
913+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
914+// SP 5
471915 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
916+// SP 4
917+// VERIFY SP
918+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
472919 case 0xFFFFFFFFFFFFFFDDLLU: // skip to here
473920
474- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
921+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
922+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
923+// SP 4
475924 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
925+// SP 3
926+// VERIFY SP
927+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
476928 case 0xFFFFFFFFFFFFFFE1LLU: // skip to here
477929
478- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
930+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
931+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
932+// SP 3
479933 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
934+// SP 2
935+// VERIFY SP
936+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
480937 case 0xFFFFFFFFFFFFFFE6LLU: // skip to here
481938
482- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
939+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
940+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
941+// SP 2
483942 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
943+// SP 1
944+// VERIFY SP
945+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
484946 case 0xFFFFFFFFFFFFFFEBLLU: // skip to here
485947
486948 RET;
487949
488950
489-case /*parseexpr_'*/0xADCB6E820CEBB401LLU:
951+case /*parseexpr_'*/0xADCB6E820CEBB401LLU:// SP 0
952+// VERIFY SP
953+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
490954
491- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD6LLU, 0xBA692B7A8A6FB800LLU);
492-case 0xFFFFFFFFFFFFFFD6LLU:
493955
494- CALLBEGIN(1/*nr of chunks returned*/); PUSH(61LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFD5LLU, 0xA1CBDE8C00000000LLU);
495-case 0xFFFFFFFFFFFFFFD5LLU:
956+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
957+// SP 5
958+// VERIFY SP
959+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
960+CALLEND(0LLU, 0xFFFFFFFFFFFFFFD0LLU, 0xBA692B7A8A6FB800LLU);
961+case 0xFFFFFFFFFFFFFFD0LLU:
962+// SP 1
496963
497- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD4LLU, 0xADCB6E820CEBB400LLU);
498-case 0xFFFFFFFFFFFFFFD4LLU:
964+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
965+// SP 6
966+// VERIFY SP
967+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
968+PUSH(61LLU);// SP 7
969+// VERIFY SP
970+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
971+CALLEND(1LLU, 0xFFFFFFFFFFFFFFCFLLU, 0xA1CBDE8C00000000LLU);
972+case 0xFFFFFFFFFFFFFFCFLLU:
973+// SP 2
499974
975+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
976+// SP 7
977+// VERIFY SP
978+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
979+PUSH(ACCESS_ARG(0));
980+// SP 8
981+// VERIFY SP
982+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
983+CALLEND(1LLU, 0xFFFFFFFFFFFFFFCELLU, 0xADCB6E820CEBB400LLU);
984+case 0xFFFFFFFFFFFFFFCELLU:
985+// SP 3
986+
500987 RET;
501988
502989
503-case /*assignglob*/0x72EBA48A98A7A9D0LLU:
990+case /*assignglob*/0x72EBA48A98A7A9D0LLU:// SP 0
991+// VERIFY SP
992+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
504993
994+
505995 ACCESS_RETURN = 0;
506- case 0xFFFFFFFFFFFFFFD3LLU: // loop to here
996+ case 0xFFFFFFFFFFFFFFCDLLU: // loop to here
507997 // predicate
508-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD1LLU, 0xAE08260000000000LLU);
509-case 0xFFFFFFFFFFFFFFD1LLU:
510-CALLEND(1LLU, 0xFFFFFFFFFFFFFFD0LLU, 0x92E7E48A4BC00000LLU);
511-case 0xFFFFFFFFFFFFFFD0LLU:
512-if(!ACCESS_CURRENT)
513- JUMP(0xFFFFFFFFFFFFFFD2LLU); // skip loop
998+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
999+// SP 5
1000+// VERIFY SP
1001+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1002+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
1003+// SP 10
1004+// VERIFY SP
1005+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1006+CALLEND(0LLU, 0xFFFFFFFFFFFFFFCBLLU, 0xAE08260000000000LLU);
1007+case 0xFFFFFFFFFFFFFFCBLLU:
1008+// SP 6
1009+CALLEND(1LLU, 0xFFFFFFFFFFFFFFCALLU, 0x92E7E48A4BC00000LLU);
1010+case 0xFFFFFFFFFFFFFFCALLU:
1011+// SP 1
1012+if(!POP)
1013+// SP 0
1014+ JUMP(0xFFFFFFFFFFFFFFCCLLU); // skip loop
5141015 // loop
5151016
516- PUSH(0); // place-holder for result of block
517-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1017+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1018+// SP 1
1019+// VERIFY SP
1020+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5181021 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
5191022
5201023 ACCESS_RETURN *= 10;
5211024 ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get
522- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1025+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1026+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1027+// SP 1
5231028 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
524- JUMP(0xFFFFFFFFFFFFFFD3LLU); // loop
525-case 0xFFFFFFFFFFFFFFD2LLU: // skip to here
1029+// SP 0
1030+// VERIFY SP
1031+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1032+ JUMP(0xFFFFFFFFFFFFFFCDLLU); // loop
1033+case 0xFFFFFFFFFFFFFFCCLLU: // skip to here
5261034
5271035 if((long long unsigned int)ACCESS_RETURN >= stack$$$[GLOBMAX_IDX])
5281036 {
@@ -531,288 +1039,581 @@
5311039 exit(-1);
5321040 }
5331041
534- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFCFLLU, 0xADCB6E820CEBB401LLU);
535-case 0xFFFFFFFFFFFFFFCFLLU:
1042+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1043+// SP 5
1044+// VERIFY SP
1045+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1046+PUSH(ACCESS_ARG(0));
1047+// SP 6
1048+// VERIFY SP
1049+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1050+CALLEND(1LLU, 0xFFFFFFFFFFFFFFC9LLU, 0xADCB6E820CEBB401LLU);
1051+case 0xFFFFFFFFFFFFFFC9LLU:
1052+// SP 1
5361053
5371054
5381055 fprintf(stdout, "stack$$$[%lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);
1056+ SP_ADD_VERIFY(-1);
5391057 RET;
5401058
5411059
542-case /*assignvar_*/0x72EBA48A9C5CB400LLU:
1060+case /*assignvar_*/0x72EBA48A9C5CB400LLU:// SP 0
1061+// VERIFY SP
1062+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5431063
1064+
5441065 ACCESS_RETURN = 0;
5451066 // predicate
546-CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFCCLLU, 0xA1CBDE8EAAEF0000LLU);
547-case 0xFFFFFFFFFFFFFFCCLLU:
548-if(!ACCESS_CURRENT)
549- JUMP(0xFFFFFFFFFFFFFFCELLU); // skip consequent
1067+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1068+// SP 5
1069+// VERIFY SP
1070+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1071+PUSH(96LLU);// SP 6
1072+// VERIFY SP
1073+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1074+CALLEND(1LLU, 0xFFFFFFFFFFFFFFC6LLU, 0xA1CBDE8EAAEF0000LLU);
1075+case 0xFFFFFFFFFFFFFFC6LLU:
1076+// SP 1
1077+if(!POP)
1078+// SP 0
1079+ JUMP(0xFFFFFFFFFFFFFFC8LLU); // skip consequent
5501080 // consequent
5511081
552- PUSH(0); // place-holder for result of block
553-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1082+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1083+// SP 1
1084+// VERIFY SP
1085+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5541086 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
5551087
556- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFCBLLU, 0xADCB6E820CEBB401LLU);
557-case 0xFFFFFFFFFFFFFFCBLLU:
1088+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1089+// SP 6
1090+// VERIFY SP
1091+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1092+PUSH(ACCESS_ARG(0));
1093+// SP 7
1094+// VERIFY SP
1095+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1096+CALLEND(1LLU, 0xFFFFFFFFFFFFFFC5LLU, 0xADCB6E820CEBB401LLU);
1097+case 0xFFFFFFFFFFFFFFC5LLU:
1098+// SP 2
5581099
5591100
5601101 fprintf(stdout, "ACCESS_RETURN = POP;\n");
561- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1102+ SP_ADD_VERIFY(-1);
1103+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1104+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1105+// SP 1
5621106 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
563- JUMP(0xFFFFFFFFFFFFFFCDLLU); // skip alternative
564-case 0xFFFFFFFFFFFFFFCELLU: // alternative
1107+// SP 0
1108+// VERIFY SP
1109+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1110+ JUMP(0xFFFFFFFFFFFFFFC7LLU); // skip alternative
1111+case 0xFFFFFFFFFFFFFFC8LLU: // alternative
5651112
5661113
567- PUSH(0); // place-holder for result of block
568-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1114+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1115+// SP 1
1116+// VERIFY SP
1117+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5691118 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
5701119
571- case 0xFFFFFFFFFFFFFFCALLU: // loop to here
1120+ case 0xFFFFFFFFFFFFFFC4LLU: // loop to here
5721121 // predicate
573-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC8LLU, 0xAE08260000000000LLU);
574-case 0xFFFFFFFFFFFFFFC8LLU:
575-CALLEND(1LLU, 0xFFFFFFFFFFFFFFC7LLU, 0x92E7E48A4BC00000LLU);
576-case 0xFFFFFFFFFFFFFFC7LLU:
577-if(!ACCESS_CURRENT)
578- JUMP(0xFFFFFFFFFFFFFFC9LLU); // skip loop
1122+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1123+// SP 6
1124+// VERIFY SP
1125+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1126+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
1127+// SP 11
1128+// VERIFY SP
1129+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1130+CALLEND(0LLU, 0xFFFFFFFFFFFFFFC2LLU, 0xAE08260000000000LLU);
1131+case 0xFFFFFFFFFFFFFFC2LLU:
1132+// SP 7
1133+CALLEND(1LLU, 0xFFFFFFFFFFFFFFC1LLU, 0x92E7E48A4BC00000LLU);
1134+case 0xFFFFFFFFFFFFFFC1LLU:
1135+// SP 2
1136+if(!POP)
1137+// SP 1
1138+ JUMP(0xFFFFFFFFFFFFFFC3LLU); // skip loop
5791139 // loop
5801140
581- PUSH(0); // place-holder for result of block
582-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1141+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1142+// SP 2
1143+// VERIFY SP
1144+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
5831145 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
5841146
5851147 ACCESS_RETURN *= 10;
5861148 ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get
587- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1149+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1150+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1151+// SP 2
5881152 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
589- JUMP(0xFFFFFFFFFFFFFFCALLU); // loop
590-case 0xFFFFFFFFFFFFFFC9LLU: // skip to here
1153+// SP 1
1154+// VERIFY SP
1155+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1156+ JUMP(0xFFFFFFFFFFFFFFC4LLU); // loop
1157+case 0xFFFFFFFFFFFFFFC3LLU: // skip to here
5911158
592- fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);
1159+ fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);
1160+ SP_ADD_VERIFY(1);
5931161
594- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC6LLU, 0xADCB6E820CEBB401LLU);
595-case 0xFFFFFFFFFFFFFFC6LLU:
1162+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1163+// SP 6
1164+// VERIFY SP
1165+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1166+PUSH(ACCESS_ARG(0));
1167+// SP 7
1168+// VERIFY SP
1169+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1170+CALLEND(1LLU, 0xFFFFFFFFFFFFFFC0LLU, 0xADCB6E820CEBB401LLU);
1171+case 0xFFFFFFFFFFFFFFC0LLU:
1172+// SP 2
5961173
5971174
5981175 fprintf(stdout, "stack$$$[sb$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);
599- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1176+ SP_ADD_VERIFY(-1);
1177+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1178+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1179+// SP 1
6001180 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
601-case 0xFFFFFFFFFFFFFFCDLLU: // skip to here
1181+// SP 0
1182+// VERIFY SP
1183+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1184+case 0xFFFFFFFFFFFFFFC7LLU: // skip to here
6021185
6031186 RET;
6041187
6051188
606-case /*assignarg_*/0x72EBA48A972D8800LLU:
1189+case /*assignarg_*/0x72EBA48A972D8800LLU:// SP 0
1190+// VERIFY SP
1191+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6071192
1193+
6081194 ACCESS_RETURN = 0;
6091195 // predicate
610-CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFC3LLU, 0xA1CBDE8EAAEF0000LLU);
611-case 0xFFFFFFFFFFFFFFC3LLU:
612-if(!ACCESS_CURRENT)
613- JUMP(0xFFFFFFFFFFFFFFC5LLU); // skip consequent
1196+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1197+// SP 5
1198+// VERIFY SP
1199+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1200+PUSH(35LLU);// SP 6
1201+// VERIFY SP
1202+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1203+CALLEND(1LLU, 0xFFFFFFFFFFFFFFBDLLU, 0xA1CBDE8EAAEF0000LLU);
1204+case 0xFFFFFFFFFFFFFFBDLLU:
1205+// SP 1
1206+if(!POP)
1207+// SP 0
1208+ JUMP(0xFFFFFFFFFFFFFFBFLLU); // skip consequent
6141209 // consequent
6151210
616- PUSH(0); // place-holder for result of block
617-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1211+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1212+// SP 1
1213+// VERIFY SP
1214+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6181215 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
6191216
620- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC2LLU, 0xBA692B0000000000LLU);
621-case 0xFFFFFFFFFFFFFFC2LLU:
1217+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1218+// SP 6
1219+// VERIFY SP
1220+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1221+CALLEND(0LLU, 0xFFFFFFFFFFFFFFBCLLU, 0xBA692B0000000000LLU);
1222+case 0xFFFFFFFFFFFFFFBCLLU:
1223+// SP 2
6221224
6231225
624- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC1LLU, 0xADCB6E820CEBB401LLU);
625-case 0xFFFFFFFFFFFFFFC1LLU:
1226+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
1227+// SP 7
1228+// VERIFY SP
1229+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1230+PUSH(ACCESS_ARG(0));
1231+// SP 8
1232+// VERIFY SP
1233+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1234+CALLEND(1LLU, 0xFFFFFFFFFFFFFFBBLLU, 0xADCB6E820CEBB401LLU);
1235+case 0xFFFFFFFFFFFFFFBBLLU:
1236+// SP 3
6261237
6271238
6281239 fprintf(stdout, "ACCESS_RETURN = POP;\n");
629- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1240+ SP_ADD_VERIFY(-1);
1241+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1242+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1243+// SP 1
6301244 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
631- JUMP(0xFFFFFFFFFFFFFFC4LLU); // skip alternative
632-case 0xFFFFFFFFFFFFFFC5LLU: // alternative
1245+// SP 0
1246+// VERIFY SP
1247+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1248+ JUMP(0xFFFFFFFFFFFFFFBELLU); // skip alternative
1249+case 0xFFFFFFFFFFFFFFBFLLU: // alternative
6331250
6341251
635- PUSH(0); // place-holder for result of block
636-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1252+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1253+// SP 1
1254+// VERIFY SP
1255+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6371256 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
6381257
639- case 0xFFFFFFFFFFFFFFC0LLU: // loop to here
1258+ case 0xFFFFFFFFFFFFFFBALLU: // loop to here
6401259 // predicate
641-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBELLU, 0xAE08260000000000LLU);
642-case 0xFFFFFFFFFFFFFFBELLU:
643-CALLEND(1LLU, 0xFFFFFFFFFFFFFFBDLLU, 0x92E7E48A4BC00000LLU);
644-case 0xFFFFFFFFFFFFFFBDLLU:
645-if(!ACCESS_CURRENT)
646- JUMP(0xFFFFFFFFFFFFFFBFLLU); // skip loop
1260+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1261+// SP 6
1262+// VERIFY SP
1263+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1264+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
1265+// SP 11
1266+// VERIFY SP
1267+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1268+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB8LLU, 0xAE08260000000000LLU);
1269+case 0xFFFFFFFFFFFFFFB8LLU:
1270+// SP 7
1271+CALLEND(1LLU, 0xFFFFFFFFFFFFFFB7LLU, 0x92E7E48A4BC00000LLU);
1272+case 0xFFFFFFFFFFFFFFB7LLU:
1273+// SP 2
1274+if(!POP)
1275+// SP 1
1276+ JUMP(0xFFFFFFFFFFFFFFB9LLU); // skip loop
6471277 // loop
6481278
649- PUSH(0); // place-holder for result of block
650-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1279+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1280+// SP 2
1281+// VERIFY SP
1282+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6511283 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
6521284
6531285 ACCESS_RETURN *= 10;
6541286 ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get
655- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1287+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1288+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1289+// SP 2
6561290 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
657- JUMP(0xFFFFFFFFFFFFFFC0LLU); // loop
658-case 0xFFFFFFFFFFFFFFBFLLU: // skip to here
1291+// SP 1
1292+// VERIFY SP
1293+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1294+ JUMP(0xFFFFFFFFFFFFFFBALLU); // loop
1295+case 0xFFFFFFFFFFFFFFB9LLU: // skip to here
6591296
660- fprintf(stdout, "if(sp$$$ != %lluLLU) { fprintf(stderr, \"ARG SP %cllu != %llu\\n\", (long long unsigned int)sp$$$); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);
6611297
662- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBCLLU, 0xADCB6E820CEBB401LLU);
663-case 0xFFFFFFFFFFFFFFBCLLU:
1298+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1299+// SP 6
1300+// VERIFY SP
1301+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1302+PUSH(ACCESS_ARG(0));
1303+// SP 7
1304+// VERIFY SP
1305+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1306+CALLEND(1LLU, 0xFFFFFFFFFFFFFFB6LLU, 0xADCB6E820CEBB401LLU);
1307+case 0xFFFFFFFFFFFFFFB6LLU:
1308+// SP 2
6641309
6651310
6661311 fprintf(stdout, "stack$$$[sb$$$ - sz$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);
667- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1312+ SP_ADD_VERIFY(-1);
1313+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1314+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1315+// SP 1
6681316 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
669-case 0xFFFFFFFFFFFFFFC4LLU: // skip to here
1317+// SP 0
1318+// VERIFY SP
1319+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1320+case 0xFFFFFFFFFFFFFFBELLU: // skip to here
6701321
6711322 RET;
6721323
6731324
674-case /*parseglob_*/0xADCB6E8229EA7400LLU:
1325+case /*parseglob_*/0xADCB6E8229EA7400LLU:// SP 0
1326+// VERIFY SP
1327+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6751328
1329+
6761330 PUSH(0LLU);
1331+// SP 1
1332+// VERIFY SP
1333+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6771334 ACCESS_RETURN = POP;
1335+// SP 0
1336+// VERIFY SP
1337+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6781338
6791339
6801340 fprintf(stdout, "stack$$$[");
681- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBBLLU, 0x81E8EAA6D0000000LLU);
682-case 0xFFFFFFFFFFFFFFBBLLU:
1341+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1342+// SP 5
1343+// VERIFY SP
1344+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1345+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB5LLU, 0x81E8EAA6D0000000LLU);
1346+case 0xFFFFFFFFFFFFFFB5LLU:
1347+// SP 1
6831348
6841349 fprintf(stdout, "]");
6851350 RET;
6861351
6871352
688-case /*parsevar__*/0xADCB6E83172D0000LLU:
1353+case /*parsevar__*/0xADCB6E83172D0000LLU:// SP 0
1354+// VERIFY SP
1355+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6891356
1357+
6901358 PUSH(0LLU);
1359+// SP 1
1360+// VERIFY SP
1361+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6911362 ACCESS_RETURN = POP;
1363+// SP 0
1364+// VERIFY SP
1365+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
6921366
6931367
6941368 fprintf(stdout, "stack$$$[sb$$$ + ");
695- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBALLU, 0x81E8EAA6D0000000LLU);
696-case 0xFFFFFFFFFFFFFFBALLU:
1369+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1370+// SP 5
1371+// VERIFY SP
1372+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1373+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB4LLU, 0x81E8EAA6D0000000LLU);
1374+case 0xFFFFFFFFFFFFFFB4LLU:
1375+// SP 1
6971376
6981377 fprintf(stdout, "]");
6991378 RET;
7001379
7011380
702-case /*parsearg__*/0xADCB6E81CB620000LLU:
1381+case /*parsearg__*/0xADCB6E81CB620000LLU:// SP 0
1382+// VERIFY SP
1383+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7031384
1385+
7041386 PUSH(0LLU);
1387+// SP 1
1388+// VERIFY SP
1389+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7051390 ACCESS_RETURN = POP;
1391+// SP 0
1392+// VERIFY SP
1393+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7061394
7071395
7081396 fprintf(stdout, "ACCESS_ARG(");
709- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB9LLU, 0x81E8EAA6D0000000LLU);
710-case 0xFFFFFFFFFFFFFFB9LLU:
1397+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1398+// SP 5
1399+// VERIFY SP
1400+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1401+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB3LLU, 0x81E8EAA6D0000000LLU);
1402+case 0xFFFFFFFFFFFFFFB3LLU:
1403+// SP 1
7111404
7121405 fprintf(stdout, ")");
7131406 RET;
7141407
7151408
716-case /*pushglob__*/0xAF0BA38A7A9D0000LLU:
1409+case /*pushglob__*/0xAF0BA38A7A9D0000LLU:// SP 0
1410+// VERIFY SP
1411+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7171412
1413+
7181414 PUSH(0LLU);
1415+// SP 1
1416+// VERIFY SP
1417+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7191418 ACCESS_RETURN = POP;
1419+// SP 0
1420+// VERIFY SP
1421+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7201422
7211423
7221424 fprintf(stdout, "PUSH(");
723- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB8LLU, 0xADCB6E8229EA7400LLU);
724-case 0xFFFFFFFFFFFFFFB8LLU:
1425+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1426+// SP 5
1427+// VERIFY SP
1428+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1429+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB2LLU, 0xADCB6E8229EA7400LLU);
1430+case 0xFFFFFFFFFFFFFFB2LLU:
1431+// SP 1
7251432
7261433 fprintf(stdout, ");\n");
1434+ SP_ADD_VERIFY(1);
7271435 RET;
7281436
7291437
730-case /*pushvar___*/0xAF0BA3C5CB400000LLU:
1438+case /*pushvar___*/0xAF0BA3C5CB400000LLU:// SP 0
1439+// VERIFY SP
1440+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7311441
1442+
7321443 PUSH(0LLU);
1444+// SP 1
1445+// VERIFY SP
1446+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7331447 ACCESS_RETURN = POP;
1448+// SP 0
1449+// VERIFY SP
1450+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7341451
7351452
7361453 fprintf(stdout, "PUSH(");
737- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB7LLU, 0xADCB6E83172D0000LLU);
738-case 0xFFFFFFFFFFFFFFB7LLU:
1454+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1455+// SP 5
1456+// VERIFY SP
1457+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1458+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB1LLU, 0xADCB6E83172D0000LLU);
1459+case 0xFFFFFFFFFFFFFFB1LLU:
1460+// SP 1
7391461
7401462 fprintf(stdout, ");\n");
1463+ SP_ADD_VERIFY(1);
7411464 RET;
7421465
7431466
744-case /*pusharg___*/0xAF0BA372D8800000LLU:
1467+case /*pusharg___*/0xAF0BA372D8800000LLU:// SP 0
1468+// VERIFY SP
1469+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7451470
1471+
7461472 PUSH(0LLU);
1473+// SP 1
1474+// VERIFY SP
1475+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7471476 ACCESS_RETURN = POP;
1477+// SP 0
1478+// VERIFY SP
1479+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7481480
7491481
7501482 fprintf(stdout, "PUSH(");
751- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB6LLU, 0xADCB6E81CB620000LLU);
752-case 0xFFFFFFFFFFFFFFB6LLU:
1483+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1484+// SP 5
1485+// VERIFY SP
1486+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1487+CALLEND(0LLU, 0xFFFFFFFFFFFFFFB0LLU, 0xADCB6E81CB620000LLU);
1488+case 0xFFFFFFFFFFFFFFB0LLU:
1489+// SP 1
7531490
7541491 fprintf(stdout, ");\n");
1492+ SP_ADD_VERIFY(1);
7551493 RET;
7561494
7571495
758-case /*pushconst_*/0xAF0BA37AAA6EBC00LLU:
1496+case /*pushconst_*/0xAF0BA37AAA6EBC00LLU:// SP 0
1497+// VERIFY SP
1498+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7591499
1500+
7601501 PUSH(0LLU);
1502+// SP 1
1503+// VERIFY SP
1504+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7611505 ACCESS_RETURN = POP;
1506+// SP 0
1507+// VERIFY SP
1508+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7621509
7631510
7641511 fprintf(stdout, "PUSH(");
765- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB5LLU, 0x81E8EAA6D0000000LLU);
766-case 0xFFFFFFFFFFFFFFB5LLU:
1512+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1513+// SP 5
1514+// VERIFY SP
1515+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1516+CALLEND(0LLU, 0xFFFFFFFFFFFFFFAFLLU, 0x81E8EAA6D0000000LLU);
1517+case 0xFFFFFFFFFFFFFFAFLLU:
1518+// SP 1
7671519
7681520 fputs("LLU);", stdout);
1521+ SP_ADD_VERIFY(1);/*SP_VERIFY();*/
7691522 RET;
7701523
7711524
772-case /*parsechar_*/0xADCB6E81E8DCB400LLU:
1525+case /*parsechar_*/0xADCB6E81E8DCB400LLU:// SP 0
1526+// VERIFY SP
1527+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7731528
774- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB4LLU, 0x8A0BC00000000000LLU);
775-case 0xFFFFFFFFFFFFFFB4LLU:
1529+
1530+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1531+// SP 5
1532+// VERIFY SP
1533+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1534+CALLEND(0LLU, 0xFFFFFFFFFFFFFFAELLU, 0x8A0BC00000000000LLU);
1535+case 0xFFFFFFFFFFFFFFAELLU:
1536+// SP 1
7761537 ACCESS_RETURN = POP;
1538+// SP 0
1539+// VERIFY SP
1540+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7771541
778- CALLBEGIN(1/*nr of chunks returned*/); PUSH(39LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFB3LLU, 0xA1CBDE8C00000000LLU);
779-case 0xFFFFFFFFFFFFFFB3LLU:
1542+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1543+// SP 5
1544+// VERIFY SP
1545+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1546+PUSH(39LLU);// SP 6
1547+// VERIFY SP
1548+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1549+CALLEND(1LLU, 0xFFFFFFFFFFFFFFADLLU, 0xA1CBDE8C00000000LLU);
1550+case 0xFFFFFFFFFFFFFFADLLU:
1551+// SP 1
7801552
7811553 RET;
7821554
7831555
784-case /*parsenr___*/0xADCB6E829B400000LLU:
1556+case /*parsenr___*/0xADCB6E829B400000LLU:// SP 0
1557+// VERIFY SP
1558+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
7851559
786- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB2LLU, 0xBA692B7A8A6FB800LLU);
787-case 0xFFFFFFFFFFFFFFB2LLU:
7881560
1561+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1562+// SP 5
1563+// VERIFY SP
1564+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1565+CALLEND(0LLU, 0xFFFFFFFFFFFFFFACLLU, 0xBA692B7A8A6FB800LLU);
1566+case 0xFFFFFFFFFFFFFFACLLU:
1567+// SP 1
1568+
7891569 ACCESS_RETURN = 0;
790- case 0xFFFFFFFFFFFFFFB1LLU: // loop to here
1570+ case 0xFFFFFFFFFFFFFFABLLU: // loop to here
7911571 // predicate
792-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFAFLLU, 0xAE08260000000000LLU);
793-case 0xFFFFFFFFFFFFFFAFLLU:
794-CALLEND(1LLU, 0xFFFFFFFFFFFFFFAELLU, 0x92E7E48A4BC00000LLU);
795-case 0xFFFFFFFFFFFFFFAELLU:
796-if(!ACCESS_CURRENT)
797- JUMP(0xFFFFFFFFFFFFFFB0LLU); // skip loop
1572+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1573+// SP 6
1574+// VERIFY SP
1575+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1576+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
1577+// SP 11
1578+// VERIFY SP
1579+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1580+CALLEND(0LLU, 0xFFFFFFFFFFFFFFA9LLU, 0xAE08260000000000LLU);
1581+case 0xFFFFFFFFFFFFFFA9LLU:
1582+// SP 7
1583+CALLEND(1LLU, 0xFFFFFFFFFFFFFFA8LLU, 0x92E7E48A4BC00000LLU);
1584+case 0xFFFFFFFFFFFFFFA8LLU:
1585+// SP 2
1586+if(!POP)
1587+// SP 1
1588+ JUMP(0xFFFFFFFFFFFFFFAALLU); // skip loop
7981589 // loop
7991590
800- PUSH(0); // place-holder for result of block
801-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1591+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1592+// SP 2
1593+// VERIFY SP
1594+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8021595 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
8031596
8041597 ACCESS_RETURN *= 10;
8051598 ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get
806- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1599+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1600+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1601+// SP 2
8071602 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
808- JUMP(0xFFFFFFFFFFFFFFB1LLU); // loop
809-case 0xFFFFFFFFFFFFFFB0LLU: // skip to here
1603+// SP 1
1604+// VERIFY SP
1605+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1606+ JUMP(0xFFFFFFFFFFFFFFABLLU); // loop
1607+case 0xFFFFFFFFFFFFFFAALLU: // skip to here
8101608
8111609 RET;
8121610
8131611
814-case /*debugnr___*/0x7E07708A9B400000LLU:
1612+case /*debugnr___*/0x7E07708A9B400000LLU:// SP 0
1613+// VERIFY SP
1614+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8151615
1616+
8161617 ACCESS_RETURN = 0;
8171618 for(register uint64_t i = 16; i > 0; i--)
8181619 {
@@ -824,26 +1625,43 @@
8241625 RET;
8251626
8261627
827-case /*printnr___*/0xAED929BE9B400000LLU:
1628+case /*printnr___*/0xAED929BE9B400000LLU:// SP 0
1629+// VERIFY SP
1630+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8281631
1632+
8291633 ACCESS_RETURN = ACCESS_ARG(0); // pass-through argument
8301634 fprintf(stdout, "%0lluLLU", (long long unsigned int)ACCESS_ARG(0));
8311635 RET;
8321636
8331637
834-case /*printid___*/0xAED929BE47C00000LLU:
1638+case /*printid___*/0xAED929BE47C00000LLU:// SP 0
1639+// VERIFY SP
1640+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8351641
836- CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(0));
837-CALLEND(1LLU, 0xFFFFFFFFFFFFFFADLLU, 0x7AAA28829BE47C00LLU);
838-case 0xFFFFFFFFFFFFFFADLLU:
8391642
1643+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1644+// SP 5
1645+// VERIFY SP
1646+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1647+PUSH(ACCESS_ARG(0));
1648+// SP 6
1649+// VERIFY SP
1650+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1651+CALLEND(1LLU, 0xFFFFFFFFFFFFFFA7LLU, 0x7AAA28829BE47C00LLU);
1652+case 0xFFFFFFFFFFFFFFA7LLU:
1653+// SP 1
1654+
8401655 ACCESS_RETURN = ACCESS_ARG(0); // pass-through argument
8411656 fprintf(stdout, "0x%0llXLLU", (long long unsigned int)ACCESS_ARG(0));
8421657 RET;
8431658
8441659
845-case /*debugid___*/0x7E07708A47C00000LLU:
1660+case /*debugid___*/0x7E07708A47C00000LLU:// SP 0
1661+// VERIFY SP
1662+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8461663
1664+
8471665 for(register uint64_t i = 10; i > 0; i--)
8481666 {
8491667 if(((ACCESS_ARG(0) >> (i * 6 - 2)) & 0x3F) < 1)
@@ -863,8 +1681,11 @@
8631681 RET;
8641682
8651683
866-case /*commentid_*/0x7AAA28829BE47C00LLU:
1684+case /*commentid_*/0x7AAA28829BE47C00LLU:// SP 0
1685+// VERIFY SP
1686+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8671687
1688+
8681689 fprintf(stdout, "/*");
8691690 for(register uint64_t i = 10; i > 0; i--)
8701691 {
@@ -886,8 +1707,11 @@
8861707 RET;
8871708
8881709
889-case /*parseid___*/0xADCB6E8247C00000LLU:
1710+case /*parseid___*/0xADCB6E8247C00000LLU:// SP 0
1711+// VERIFY SP
1712+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
8901713
1714+
8911715 c$$$ = fgetc(stdin); // XXX use get
8921716 ACCESS_RETURN = 0;
8931717 // A label consists of ten symbols each of which can be underscore, upper, dollar, lower, digit (this takes up 60 bits) - followed by up to 15 primes (4 bits).
@@ -920,926 +1744,2038 @@
9201744 RET;
9211745
9221746
923-case /*PARSEID___*/0x4014931491000000LLU:
1747+case /*PARSEID___*/0x4014931491000000LLU:// SP 0
1748+// VERIFY SP
1749+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9241750
925- CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFACLLU, 0xADCB6E8247C00000LLU);
926-case 0xFFFFFFFFFFFFFFACLLU:
927-CALLEND(1LLU, 0xFFFFFFFFFFFFFFABLLU, 0xAED929BE47C00000LLU);
928-case 0xFFFFFFFFFFFFFFABLLU:
9291751
1752+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1753+// SP 5
1754+// VERIFY SP
1755+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1756+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
1757+// SP 10
1758+// VERIFY SP
1759+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1760+CALLEND(0LLU, 0xFFFFFFFFFFFFFFA6LLU, 0xADCB6E8247C00000LLU);
1761+case 0xFFFFFFFFFFFFFFA6LLU:
1762+// SP 6
1763+CALLEND(1LLU, 0xFFFFFFFFFFFFFFA5LLU, 0xAED929BE47C00000LLU);
1764+case 0xFFFFFFFFFFFFFFA5LLU:
1765+// SP 1
1766+
9301767 fprintf(stdout, "%c", 58);
9311768 ACCESS_RETURN = ACCESS_CURRENT;
9321769 RET;
9331770
9341771
935-case /*verbatim__*/0xC60B5D72F9280000LLU:
1772+case /*verbatim__*/0xC60B5D72F9280000LLU:// SP 0
1773+// VERIFY SP
1774+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9361775
937- case 0xFFFFFFFFFFFFFFAALLU: // loop to here
1776+
1777+ case 0xFFFFFFFFFFFFFFA4LLU: // loop to here
9381778 // predicate
939-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFA8LLU, 0xAE08260000000000LLU);
940-case 0xFFFFFFFFFFFFFFA8LLU:
941-PUSH(58LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFFA7LLU, 0xA60B000000000000LLU);
942-case 0xFFFFFFFFFFFFFFA7LLU:
943-if(!ACCESS_CURRENT)
944- JUMP(0xFFFFFFFFFFFFFFA9LLU); // skip loop
1779+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1780+// SP 5
1781+// VERIFY SP
1782+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1783+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
1784+// SP 10
1785+// VERIFY SP
1786+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1787+CALLEND(0LLU, 0xFFFFFFFFFFFFFFA2LLU, 0xAE08260000000000LLU);
1788+case 0xFFFFFFFFFFFFFFA2LLU:
1789+// SP 6
1790+PUSH(58LLU);// SP 7
1791+// VERIFY SP
1792+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1793+CALLEND(2LLU, 0xFFFFFFFFFFFFFFA1LLU, 0xA60B000000000000LLU);
1794+case 0xFFFFFFFFFFFFFFA1LLU:
1795+// SP 1
1796+if(!POP)
1797+// SP 0
1798+ JUMP(0xFFFFFFFFFFFFFFA3LLU); // skip loop
9451799 // loop
9461800
947- PUSH(0); // place-holder for result of block
948-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1801+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1802+// SP 1
1803+// VERIFY SP
1804+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9491805 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
9501806
9511807 // predicate
952-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFA4LLU, 0x81E8EA0000000000LLU);
953-case 0xFFFFFFFFFFFFFFA4LLU:
954-PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFFA3LLU, 0x8AFB400000000000LLU);
955-case 0xFFFFFFFFFFFFFFA3LLU:
956-if(!ACCESS_CURRENT)
957- JUMP(0xFFFFFFFFFFFFFFA6LLU); // skip consequent
1808+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1809+// SP 6
1810+// VERIFY SP
1811+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1812+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
1813+// SP 11
1814+// VERIFY SP
1815+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1816+CALLEND(0LLU, 0xFFFFFFFFFFFFFF9ELLU, 0x81E8EA0000000000LLU);
1817+case 0xFFFFFFFFFFFFFF9ELLU:
1818+// SP 7
1819+PUSH(255LLU);// SP 8
1820+// VERIFY SP
1821+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1822+CALLEND(2LLU, 0xFFFFFFFFFFFFFF9DLLU, 0x8AFB400000000000LLU);
1823+case 0xFFFFFFFFFFFFFF9DLLU:
1824+// SP 2
1825+if(!POP)
1826+// SP 1
1827+ JUMP(0xFFFFFFFFFFFFFFA0LLU); // skip consequent
9581828 // consequent
9591829
960- PUSH(0); // place-holder for result of block
961-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1830+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1831+// SP 2
1832+// VERIFY SP
1833+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9621834 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
9631835
9641836 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
9651837 fprintf(stderr, "EOF in verbatim\n");
9661838 exit(-1);
967- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1839+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1840+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1841+// SP 2
9681842 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
969- JUMP(0xFFFFFFFFFFFFFFA5LLU); // skip alternative
970-case 0xFFFFFFFFFFFFFFA6LLU: // alternative
1843+// SP 1
1844+// VERIFY SP
1845+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1846+ JUMP(0xFFFFFFFFFFFFFF9FLLU); // skip alternative
1847+case 0xFFFFFFFFFFFFFFA0LLU: // alternative
9711848
9721849
973- PUSH(0); // place-holder for result of block
974-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1850+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1851+// SP 2
1852+// VERIFY SP
1853+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9751854 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
9761855
977- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1856+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1857+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1858+// SP 2
9781859 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
979-case 0xFFFFFFFFFFFFFFA5LLU: // skip to here
1860+// SP 1
1861+// VERIFY SP
1862+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1863+case 0xFFFFFFFFFFFFFF9FLLU: // skip to here
9801864
981- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1865+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1866+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1867+// SP 1
9821868 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
983- JUMP(0xFFFFFFFFFFFFFFAALLU); // loop
984-case 0xFFFFFFFFFFFFFFA9LLU: // skip to here
1869+// SP 0
1870+// VERIFY SP
1871+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1872+ JUMP(0xFFFFFFFFFFFFFFA4LLU); // loop
1873+case 0xFFFFFFFFFFFFFFA3LLU: // skip to here
9851874
986- CALLBEGIN(1/*nr of chunks returned*/); PUSH(58LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA2LLU, 0xA1CBDE8C00000000LLU);
987-case 0xFFFFFFFFFFFFFFA2LLU:
1875+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1876+// SP 5
1877+// VERIFY SP
1878+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1879+PUSH(58LLU);// SP 6
1880+// VERIFY SP
1881+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1882+CALLEND(1LLU, 0xFFFFFFFFFFFFFF9CLLU, 0xA1CBDE8C00000000LLU);
1883+case 0xFFFFFFFFFFFFFF9CLLU:
1884+// SP 1
9881885
9891886 RET;
9901887
9911888
992-case /*comment___*/0x7AAA28829BC00000LLU:
1889+case /*comment___*/0x7AAA28829BC00000LLU:// SP 0
1890+// VERIFY SP
1891+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
9931892
994- CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA1LLU, 0xAF0BC00000000000LLU);
995-case 0xFFFFFFFFFFFFFFA1LLU:
996-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA0LLU, 0xAF0BC00000000000LLU);
997-case 0xFFFFFFFFFFFFFFA0LLU:
9981893
999- case 0xFFFFFFFFFFFFFF9FLLU: // loop to here
1000- // predicate
1001-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(10LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF9DLLU, 0xAE08260000000000LLU);
1002-case 0xFFFFFFFFFFFFFF9DLLU:
1003-CALLEND(2LLU, 0xFFFFFFFFFFFFFF9CLLU, 0xA60B000000000000LLU);
1004-case 0xFFFFFFFFFFFFFF9CLLU:
1005-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF9BLLU, 0xAE08260000000000LLU);
1894+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
1895+// SP 5
1896+// VERIFY SP
1897+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1898+PUSH(47LLU);// SP 6
1899+// VERIFY SP
1900+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1901+CALLEND(1LLU, 0xFFFFFFFFFFFFFF9BLLU, 0xAF0BC00000000000LLU);
10061902 case 0xFFFFFFFFFFFFFF9BLLU:
1007-PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF9ALLU, 0x9E0B000000000000LLU);
1903+// SP 1
1904+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
1905+// SP 6
1906+// VERIFY SP
1907+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1908+PUSH(47LLU);// SP 7
1909+// VERIFY SP
1910+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1911+CALLEND(1LLU, 0xFFFFFFFFFFFFFF9ALLU, 0xAF0BC00000000000LLU);
10081912 case 0xFFFFFFFFFFFFFF9ALLU:
1009-CALLEND(2LLU, 0xFFFFFFFFFFFFFF99LLU, 0x7297C00000000000LLU);
1010-case 0xFFFFFFFFFFFFFF99LLU:
1011-if(!ACCESS_CURRENT)
1012- JUMP(0xFFFFFFFFFFFFFF9ELLU); // skip loop
1913+// SP 2
1914+
1915+ case 0xFFFFFFFFFFFFFF99LLU: // loop to here
1916+ // predicate
1917+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
1918+// SP 7
1919+// VERIFY SP
1920+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1921+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
1922+// SP 12
1923+// VERIFY SP
1924+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1925+PUSH(10LLU);// SP 13
1926+// VERIFY SP
1927+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1928+CALLBEGIN(1/*nr of chunks returned*/); // SP 14
1929+// SP 18
1930+// VERIFY SP
1931+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1932+CALLEND(0LLU, 0xFFFFFFFFFFFFFF97LLU, 0xAE08260000000000LLU);
1933+case 0xFFFFFFFFFFFFFF97LLU:
1934+// SP 14
1935+CALLEND(2LLU, 0xFFFFFFFFFFFFFF96LLU, 0xA60B000000000000LLU);
1936+case 0xFFFFFFFFFFFFFF96LLU:
1937+// SP 8
1938+CALLBEGIN(1/*nr of chunks returned*/); // SP 9
1939+// SP 13
1940+// VERIFY SP
1941+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1942+CALLBEGIN(1/*nr of chunks returned*/); // SP 14
1943+// SP 18
1944+// VERIFY SP
1945+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1946+CALLEND(0LLU, 0xFFFFFFFFFFFFFF95LLU, 0xAE08260000000000LLU);
1947+case 0xFFFFFFFFFFFFFF95LLU:
1948+// SP 14
1949+PUSH(255LLU);// SP 15
1950+// VERIFY SP
1951+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1952+CALLEND(2LLU, 0xFFFFFFFFFFFFFF94LLU, 0x9E0B000000000000LLU);
1953+case 0xFFFFFFFFFFFFFF94LLU:
1954+// SP 9
1955+CALLEND(2LLU, 0xFFFFFFFFFFFFFF93LLU, 0x7297C00000000000LLU);
1956+case 0xFFFFFFFFFFFFFF93LLU:
1957+// SP 3
1958+if(!POP)
1959+// SP 2
1960+ JUMP(0xFFFFFFFFFFFFFF98LLU); // skip loop
10131961 // loop
10141962
1015- PUSH(0); // place-holder for result of block
1016-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1963+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
1964+// SP 3
1965+// VERIFY SP
1966+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
10171967 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
10181968
1019- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF98LLU, 0x81E8EA0000000000LLU);
1020-case 0xFFFFFFFFFFFFFF98LLU:
1969+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
1970+// SP 8
1971+// VERIFY SP
1972+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1973+CALLEND(0LLU, 0xFFFFFFFFFFFFFF92LLU, 0x81E8EA0000000000LLU);
1974+case 0xFFFFFFFFFFFFFF92LLU:
1975+// SP 4
10211976
1022- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1977+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
1978+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
1979+// SP 3
10231980 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1024- JUMP(0xFFFFFFFFFFFFFF9FLLU); // loop
1025-case 0xFFFFFFFFFFFFFF9ELLU: // skip to here
1981+// SP 2
1982+// VERIFY SP
1983+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1984+ JUMP(0xFFFFFFFFFFFFFF99LLU); // loop
1985+case 0xFFFFFFFFFFFFFF98LLU: // skip to here
10261986
1027- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF97LLU, 0x81E8EA0000000000LLU);
1028-case 0xFFFFFFFFFFFFFF97LLU:
1987+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
1988+// SP 7
1989+// VERIFY SP
1990+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
1991+CALLEND(0LLU, 0xFFFFFFFFFFFFFF91LLU, 0x81E8EA0000000000LLU);
1992+case 0xFFFFFFFFFFFFFF91LLU:
1993+// SP 3
10291994
10301995 RET;
10311996
10321997
1033-case /*comment___'*/0x7AAA28829BC00001LLU:
1998+case /*comment___'*/0x7AAA28829BC00001LLU:// SP 0
1999+// VERIFY SP
2000+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
10342001
1035- CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF96LLU, 0xAF0BC00000000000LLU);
1036-case 0xFFFFFFFFFFFFFF96LLU:
1037-CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF95LLU, 0xAF0BC00000000000LLU);
1038-case 0xFFFFFFFFFFFFFF95LLU:
10392002
1040- case 0xFFFFFFFFFFFFFF94LLU: // loop to here
1041- // predicate
1042-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF92LLU, 0x81E8EA0000000000LLU);
1043-case 0xFFFFFFFFFFFFFF92LLU:
1044-CALLEND(2LLU, 0xFFFFFFFFFFFFFF91LLU, 0xA60B000000000000LLU);
1045-case 0xFFFFFFFFFFFFFF91LLU:
1046-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF90LLU, 0xAE08260000000000LLU);
2003+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
2004+// SP 5
2005+// VERIFY SP
2006+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2007+PUSH(47LLU);// SP 6
2008+// VERIFY SP
2009+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2010+CALLEND(1LLU, 0xFFFFFFFFFFFFFF90LLU, 0xAF0BC00000000000LLU);
10472011 case 0xFFFFFFFFFFFFFF90LLU:
1048-CALLEND(2LLU, 0xFFFFFFFFFFFFFF8FLLU, 0xA60B000000000000LLU);
2012+// SP 1
2013+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
2014+// SP 6
2015+// VERIFY SP
2016+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2017+PUSH(42LLU);// SP 7
2018+// VERIFY SP
2019+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2020+CALLEND(1LLU, 0xFFFFFFFFFFFFFF8FLLU, 0xAF0BC00000000000LLU);
10492021 case 0xFFFFFFFFFFFFFF8FLLU:
1050-CALLEND(2LLU, 0xFFFFFFFFFFFFFF8ELLU, 0xAAD0000000000000LLU);
1051-case 0xFFFFFFFFFFFFFF8ELLU:
1052-if(!ACCESS_CURRENT)
1053- JUMP(0xFFFFFFFFFFFFFF93LLU); // skip loop
2022+// SP 2
2023+
2024+ case 0xFFFFFFFFFFFFFF8ELLU: // loop to here
2025+ // predicate
2026+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
2027+// SP 7
2028+// VERIFY SP
2029+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2030+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
2031+// SP 12
2032+// VERIFY SP
2033+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2034+PUSH(42LLU);// SP 13
2035+// VERIFY SP
2036+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2037+CALLBEGIN(1/*nr of chunks returned*/); // SP 14
2038+// SP 18
2039+// VERIFY SP
2040+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2041+CALLEND(0LLU, 0xFFFFFFFFFFFFFF8CLLU, 0x81E8EA0000000000LLU);
2042+case 0xFFFFFFFFFFFFFF8CLLU:
2043+// SP 14
2044+CALLEND(2LLU, 0xFFFFFFFFFFFFFF8BLLU, 0xA60B000000000000LLU);
2045+case 0xFFFFFFFFFFFFFF8BLLU:
2046+// SP 8
2047+CALLBEGIN(1/*nr of chunks returned*/); // SP 9
2048+// SP 13
2049+// VERIFY SP
2050+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2051+PUSH(47LLU);// SP 14
2052+// VERIFY SP
2053+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2054+CALLBEGIN(1/*nr of chunks returned*/); // SP 15
2055+// SP 19
2056+// VERIFY SP
2057+if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2058+CALLEND(0LLU, 0xFFFFFFFFFFFFFF8ALLU, 0xAE08260000000000LLU);
2059+case 0xFFFFFFFFFFFFFF8ALLU:
2060+// SP 15
2061+CALLEND(2LLU, 0xFFFFFFFFFFFFFF89LLU, 0xA60B000000000000LLU);
2062+case 0xFFFFFFFFFFFFFF89LLU:
2063+// SP 9
2064+CALLEND(2LLU, 0xFFFFFFFFFFFFFF88LLU, 0xAAD0000000000000LLU);
2065+case 0xFFFFFFFFFFFFFF88LLU:
2066+// SP 3
2067+if(!POP)
2068+// SP 2
2069+ JUMP(0xFFFFFFFFFFFFFF8DLLU); // skip loop
10542070 // loop
10552071
1056- PUSH(0); // place-holder for result of block
1057-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2072+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2073+// SP 3
2074+// VERIFY SP
2075+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
10582076 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
10592077
1060- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2078+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2079+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2080+// SP 3
10612081 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1062- JUMP(0xFFFFFFFFFFFFFF94LLU); // loop
1063-case 0xFFFFFFFFFFFFFF93LLU: // skip to here
2082+// SP 2
2083+// VERIFY SP
2084+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2085+ JUMP(0xFFFFFFFFFFFFFF8ELLU); // loop
2086+case 0xFFFFFFFFFFFFFF8DLLU: // skip to here
10642087
1065- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF8DLLU, 0x81E8EA0000000000LLU);
1066-case 0xFFFFFFFFFFFFFF8DLLU:
2088+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
2089+// SP 7
2090+// VERIFY SP
2091+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2092+CALLEND(0LLU, 0xFFFFFFFFFFFFFF87LLU, 0x81E8EA0000000000LLU);
2093+case 0xFFFFFFFFFFFFFF87LLU:
2094+// SP 3
10672095
10682096 RET;
10692097
10702098
1071-case /*skipws____*/0xBA692BCAE0000000LLU:
2099+case /*skipws____*/0xBA692BCAE0000000LLU:// SP 0
2100+// VERIFY SP
2101+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
10722102
1073- case 0xFFFFFFFFFFFFFF8CLLU: // loop to here
2103+
2104+ case 0xFFFFFFFFFFFFFF86LLU: // loop to here
10742105 // predicate
1075-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF8ALLU, 0xAE08260000000000LLU);
1076-case 0xFFFFFFFFFFFFFF8ALLU:
1077-CALLEND(1LLU, 0xFFFFFFFFFFFFFF89LLU, 0x92EBAB71E8000000LLU);
1078-case 0xFFFFFFFFFFFFFF89LLU:
1079-if(!ACCESS_CURRENT)
1080- JUMP(0xFFFFFFFFFFFFFF8BLLU); // skip loop
2106+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
2107+// SP 5
2108+// VERIFY SP
2109+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2110+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
2111+// SP 10
2112+// VERIFY SP
2113+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2114+CALLEND(0LLU, 0xFFFFFFFFFFFFFF84LLU, 0xAE08260000000000LLU);
2115+case 0xFFFFFFFFFFFFFF84LLU:
2116+// SP 6
2117+CALLEND(1LLU, 0xFFFFFFFFFFFFFF83LLU, 0x92EBAB71E8000000LLU);
2118+case 0xFFFFFFFFFFFFFF83LLU:
2119+// SP 1
2120+if(!POP)
2121+// SP 0
2122+ JUMP(0xFFFFFFFFFFFFFF85LLU); // skip loop
10812123 // loop
10822124
1083- PUSH(0); // place-holder for result of block
1084-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2125+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2126+// SP 1
2127+// VERIFY SP
2128+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
10852129 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
10862130
1087- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF88LLU, 0x81E8EA0000000000LLU);
1088-case 0xFFFFFFFFFFFFFF88LLU:
2131+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
2132+// SP 6
2133+// VERIFY SP
2134+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2135+CALLEND(0LLU, 0xFFFFFFFFFFFFFF82LLU, 0x81E8EA0000000000LLU);
2136+case 0xFFFFFFFFFFFFFF82LLU:
2137+// SP 2
10892138
1090- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2139+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2140+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2141+// SP 1
10912142 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1092- JUMP(0xFFFFFFFFFFFFFF8CLLU); // loop
1093-case 0xFFFFFFFFFFFFFF8BLLU: // skip to here
2143+// SP 0
2144+// VERIFY SP
2145+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2146+ JUMP(0xFFFFFFFFFFFFFF86LLU); // loop
2147+case 0xFFFFFFFFFFFFFF85LLU: // skip to here
10942148
10952149 RET;
10962150
10972151
10982152 // returns 1 if comment found, 0 otherwise
1099-case /*skipcmnt__*/0xBA692B7A8A6F0000LLU:
2153+case /*skipcmnt__*/0xBA692B7A8A6F0000LLU:// SP 0
2154+// VERIFY SP
2155+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11002156
1101- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF87LLU, 0xBA692BCAE0000000LLU);
1102-case 0xFFFFFFFFFFFFFF87LLU:
11032157
2158+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
2159+// SP 5
2160+// VERIFY SP
2161+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2162+CALLEND(0LLU, 0xFFFFFFFFFFFFFF81LLU, 0xBA692BCAE0000000LLU);
2163+case 0xFFFFFFFFFFFFFF81LLU:
2164+// SP 1
11042165
2166+
11052167 // predicate
1106-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF84LLU, 0xA1CBDE8EAAEF0000LLU);
1107-case 0xFFFFFFFFFFFFFF84LLU:
1108-if(!ACCESS_CURRENT)
1109- JUMP(0xFFFFFFFFFFFFFF86LLU); // skip consequent
2168+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
2169+// SP 6
2170+// VERIFY SP
2171+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2172+PUSH(47LLU);// SP 7
2173+// VERIFY SP
2174+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2175+CALLEND(1LLU, 0xFFFFFFFFFFFFFF7ELLU, 0xA1CBDE8EAAEF0000LLU);
2176+case 0xFFFFFFFFFFFFFF7ELLU:
2177+// SP 2
2178+if(!POP)
2179+// SP 1
2180+ JUMP(0xFFFFFFFFFFFFFF80LLU); // skip consequent
11102181 // consequent
11112182
1112- PUSH(0); // place-holder for result of block
1113-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2183+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2184+// SP 2
2185+// VERIFY SP
2186+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11142187 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11152188
11162189 // predicate
1117-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF81LLU, 0xA1CBDE8EAAEF0000LLU);
1118-case 0xFFFFFFFFFFFFFF81LLU:
1119-if(!ACCESS_CURRENT)
1120- JUMP(0xFFFFFFFFFFFFFF83LLU); // skip consequent
2190+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
2191+// SP 7
2192+// VERIFY SP
2193+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2194+PUSH(47LLU);// SP 8
2195+// VERIFY SP
2196+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2197+CALLEND(1LLU, 0xFFFFFFFFFFFFFF7BLLU, 0xA1CBDE8EAAEF0000LLU);
2198+case 0xFFFFFFFFFFFFFF7BLLU:
2199+// SP 3
2200+if(!POP)
2201+// SP 2
2202+ JUMP(0xFFFFFFFFFFFFFF7DLLU); // skip consequent
11212203 // consequent
11222204
1123- PUSH(0); // place-holder for result of block
1124-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2205+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2206+// SP 3
2207+// VERIFY SP
2208+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11252209 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11262210
1127- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF80LLU, 0x7AAA28829BC00000LLU);
1128-case 0xFFFFFFFFFFFFFF80LLU:
2211+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
2212+// SP 8
2213+// VERIFY SP
2214+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2215+CALLEND(0LLU, 0xFFFFFFFFFFFFFF7ALLU, 0x7AAA28829BC00000LLU);
2216+case 0xFFFFFFFFFFFFFF7ALLU:
2217+// SP 4
11292218
1130- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2219+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2220+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2221+// SP 3
11312222 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1132- JUMP(0xFFFFFFFFFFFFFF82LLU); // skip alternative
1133-case 0xFFFFFFFFFFFFFF83LLU: // alternative
2223+// SP 2
2224+// VERIFY SP
2225+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2226+ JUMP(0xFFFFFFFFFFFFFF7CLLU); // skip alternative
2227+case 0xFFFFFFFFFFFFFF7DLLU: // alternative
11342228
11352229
1136- PUSH(0); // place-holder for result of block
1137-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2230+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2231+// SP 3
2232+// VERIFY SP
2233+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11382234 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11392235
11402236 // predicate
1141-CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF7DLLU, 0xA1CBDE8EAAEF0000LLU);
1142-case 0xFFFFFFFFFFFFFF7DLLU:
1143-if(!ACCESS_CURRENT)
1144- JUMP(0xFFFFFFFFFFFFFF7FLLU); // skip consequent
2237+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
2238+// SP 8
2239+// VERIFY SP
2240+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2241+PUSH(42LLU);// SP 9
2242+// VERIFY SP
2243+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2244+CALLEND(1LLU, 0xFFFFFFFFFFFFFF77LLU, 0xA1CBDE8EAAEF0000LLU);
2245+case 0xFFFFFFFFFFFFFF77LLU:
2246+// SP 4
2247+if(!POP)
2248+// SP 3
2249+ JUMP(0xFFFFFFFFFFFFFF79LLU); // skip consequent
11452250 // consequent
11462251
1147- PUSH(0); // place-holder for result of block
1148-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2252+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2253+// SP 4
2254+// VERIFY SP
2255+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11492256 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11502257
1151- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF7CLLU, 0x7AAA28829BC00001LLU);
1152-case 0xFFFFFFFFFFFFFF7CLLU:
2258+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
2259+// SP 9
2260+// VERIFY SP
2261+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2262+CALLEND(0LLU, 0xFFFFFFFFFFFFFF76LLU, 0x7AAA28829BC00001LLU);
2263+case 0xFFFFFFFFFFFFFF76LLU:
2264+// SP 5
11532265
1154- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2266+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2267+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2268+// SP 4
11552269 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1156- JUMP(0xFFFFFFFFFFFFFF7ELLU); // skip alternative
1157-case 0xFFFFFFFFFFFFFF7FLLU: // alternative
2270+// SP 3
2271+// VERIFY SP
2272+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2273+ JUMP(0xFFFFFFFFFFFFFF78LLU); // skip alternative
2274+case 0xFFFFFFFFFFFFFF79LLU: // alternative
11582275
11592276
1160- PUSH(0); // place-holder for result of block
1161-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2277+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2278+// SP 4
2279+// VERIFY SP
2280+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11622281 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11632282
11642283 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
11652284 fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
11662285 exit(-1);
1167- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2286+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2287+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2288+// SP 4
11682289 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1169-case 0xFFFFFFFFFFFFFF7ELLU: // skip to here
2290+// SP 3
2291+// VERIFY SP
2292+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2293+case 0xFFFFFFFFFFFFFF78LLU: // skip to here
11702294
1171- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2295+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2296+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2297+// SP 3
11722298 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1173-case 0xFFFFFFFFFFFFFF82LLU: // skip to here
2299+// SP 2
2300+// VERIFY SP
2301+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2302+case 0xFFFFFFFFFFFFFF7CLLU: // skip to here
11742303
11752304 PUSH(1LLU);
2305+// SP 3
2306+// VERIFY SP
2307+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11762308 ACCESS_RETURN = POP;
2309+// SP 2
2310+// VERIFY SP
2311+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11772312
1178- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2313+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2314+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2315+// SP 2
11792316 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1180- JUMP(0xFFFFFFFFFFFFFF85LLU); // skip alternative
1181-case 0xFFFFFFFFFFFFFF86LLU: // alternative
2317+// SP 1
2318+// VERIFY SP
2319+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2320+ JUMP(0xFFFFFFFFFFFFFF7FLLU); // skip alternative
2321+case 0xFFFFFFFFFFFFFF80LLU: // alternative
11822322
11832323
1184- PUSH(0); // place-holder for result of block
1185-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2324+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2325+// SP 2
2326+// VERIFY SP
2327+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11862328 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
11872329
11882330 PUSH(0LLU);
2331+// SP 3
2332+// VERIFY SP
2333+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11892334 ACCESS_RETURN = POP;
2335+// SP 2
2336+// VERIFY SP
2337+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11902338
1191- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2339+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2340+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2341+// SP 2
11922342 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1193-case 0xFFFFFFFFFFFFFF85LLU: // skip to here
2343+// SP 1
2344+// VERIFY SP
2345+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2346+case 0xFFFFFFFFFFFFFF7FLLU: // skip to here
11942347
11952348 RET;
11962349
11972350
1198-case /*skipcmnts_*/0xBA692B7A8A6FB800LLU:
2351+case /*skipcmnts_*/0xBA692B7A8A6FB800LLU:// SP 0
2352+// VERIFY SP
2353+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
11992354
1200- case 0xFFFFFFFFFFFFFF7BLLU: // loop to here
2355+
2356+ case 0xFFFFFFFFFFFFFF75LLU: // loop to here
12012357 // predicate
1202-CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF79LLU, 0xBA692B7A8A6F0000LLU);
1203-case 0xFFFFFFFFFFFFFF79LLU:
1204-if(!ACCESS_CURRENT)
1205- JUMP(0xFFFFFFFFFFFFFF7ALLU); // skip loop
2358+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
2359+// SP 5
2360+// VERIFY SP
2361+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2362+CALLEND(0LLU, 0xFFFFFFFFFFFFFF73LLU, 0xBA692B7A8A6F0000LLU);
2363+case 0xFFFFFFFFFFFFFF73LLU:
2364+// SP 1
2365+if(!POP)
2366+// SP 0
2367+ JUMP(0xFFFFFFFFFFFFFF74LLU); // skip loop
12062368 // loop
12072369
1208- PUSH(0); // place-holder for result of block
1209-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2370+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2371+// SP 1
2372+// VERIFY SP
2373+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12102374 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12112375
1212- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2376+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2377+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2378+// SP 1
12132379 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1214- JUMP(0xFFFFFFFFFFFFFF7BLLU); // loop
1215-case 0xFFFFFFFFFFFFFF7ALLU: // skip to here
2380+// SP 0
2381+// VERIFY SP
2382+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2383+ JUMP(0xFFFFFFFFFFFFFF75LLU); // loop
2384+case 0xFFFFFFFFFFFFFF74LLU: // skip to here
12162385
12172386 RET;
12182387
12192388
1220-case /*parsebody_*/0xADCB6E81DA9FD000LLU:
2389+case /*parsebody_*/0xADCB6E81DA9FD000LLU:// SP 0
2390+// VERIFY SP
2391+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12212392
1222- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF78LLU, 0xBA692B7A8A6FB800LLU);
1223-case 0xFFFFFFFFFFFFFF78LLU:
12242393
1225- case 0xFFFFFFFFFFFFFF77LLU: // loop to here
2394+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
2395+// SP 5
2396+// VERIFY SP
2397+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2398+CALLEND(0LLU, 0xFFFFFFFFFFFFFF72LLU, 0xBA692B7A8A6FB800LLU);
2399+case 0xFFFFFFFFFFFFFF72LLU:
2400+// SP 1
2401+
2402+ case 0xFFFFFFFFFFFFFF71LLU: // loop to here
12262403 // predicate
1227-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF75LLU, 0xAE08260000000000LLU);
1228-case 0xFFFFFFFFFFFFFF75LLU:
1229-CALLEND(2LLU, 0xFFFFFFFFFFFFFF74LLU, 0xA60B000000000000LLU);
1230-case 0xFFFFFFFFFFFFFF74LLU:
1231-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF73LLU, 0xAE08260000000000LLU);
1232-case 0xFFFFFFFFFFFFFF73LLU:
1233-PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF72LLU, 0x9E0B000000000000LLU);
1234-case 0xFFFFFFFFFFFFFF72LLU:
1235-CALLEND(2LLU, 0xFFFFFFFFFFFFFF71LLU, 0x7297C00000000000LLU);
1236-case 0xFFFFFFFFFFFFFF71LLU:
1237-if(!ACCESS_CURRENT)
1238- JUMP(0xFFFFFFFFFFFFFF76LLU); // skip loop
2404+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
2405+// SP 6
2406+// VERIFY SP
2407+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2408+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
2409+// SP 11
2410+// VERIFY SP
2411+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2412+PUSH(125LLU);// SP 12
2413+// VERIFY SP
2414+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2415+CALLBEGIN(1/*nr of chunks returned*/); // SP 13
2416+// SP 17
2417+// VERIFY SP
2418+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2419+CALLEND(0LLU, 0xFFFFFFFFFFFFFF6FLLU, 0xAE08260000000000LLU);
2420+case 0xFFFFFFFFFFFFFF6FLLU:
2421+// SP 13
2422+CALLEND(2LLU, 0xFFFFFFFFFFFFFF6ELLU, 0xA60B000000000000LLU);
2423+case 0xFFFFFFFFFFFFFF6ELLU:
2424+// SP 7
2425+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
2426+// SP 12
2427+// VERIFY SP
2428+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2429+CALLBEGIN(1/*nr of chunks returned*/); // SP 13
2430+// SP 17
2431+// VERIFY SP
2432+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2433+CALLEND(0LLU, 0xFFFFFFFFFFFFFF6DLLU, 0xAE08260000000000LLU);
2434+case 0xFFFFFFFFFFFFFF6DLLU:
2435+// SP 13
2436+PUSH(255LLU);// SP 14
2437+// VERIFY SP
2438+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2439+CALLEND(2LLU, 0xFFFFFFFFFFFFFF6CLLU, 0x9E0B000000000000LLU);
2440+case 0xFFFFFFFFFFFFFF6CLLU:
2441+// SP 8
2442+CALLEND(2LLU, 0xFFFFFFFFFFFFFF6BLLU, 0x7297C00000000000LLU);
2443+case 0xFFFFFFFFFFFFFF6BLLU:
2444+// SP 2
2445+if(!POP)
2446+// SP 1
2447+ JUMP(0xFFFFFFFFFFFFFF70LLU); // skip loop
12392448 // loop
12402449
1241- PUSH(0); // place-holder for result of block
1242-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2450+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2451+// SP 2
2452+// VERIFY SP
2453+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12432454 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12442455
12452456 // predicate
1246-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF6ELLU, 0xAE08260000000000LLU);
1247-case 0xFFFFFFFFFFFFFF6ELLU:
1248-CALLEND(1LLU, 0xFFFFFFFFFFFFFF6DLLU, 0x92E727AE37000000LLU);
1249-case 0xFFFFFFFFFFFFFF6DLLU:
1250-if(!ACCESS_CURRENT)
1251- JUMP(0xFFFFFFFFFFFFFF70LLU); // skip consequent
2457+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
2458+// SP 7
2459+// VERIFY SP
2460+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2461+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
2462+// SP 12
2463+// VERIFY SP
2464+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2465+CALLEND(0LLU, 0xFFFFFFFFFFFFFF68LLU, 0xAE08260000000000LLU);
2466+case 0xFFFFFFFFFFFFFF68LLU:
2467+// SP 8
2468+CALLEND(1LLU, 0xFFFFFFFFFFFFFF67LLU, 0x92E727AE37000000LLU);
2469+case 0xFFFFFFFFFFFFFF67LLU:
2470+// SP 3
2471+if(!POP)
2472+// SP 2
2473+ JUMP(0xFFFFFFFFFFFFFF6ALLU); // skip consequent
12522474 // consequent
12532475
1254- PUSH(0); // place-holder for result of block
1255-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2476+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2477+// SP 3
2478+// VERIFY SP
2479+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12562480 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12572481
1258- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF6CLLU, 0xADCB6E81E7279C00LLU);
1259-case 0xFFFFFFFFFFFFFF6CLLU:
2482+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
2483+// SP 8
2484+// VERIFY SP
2485+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2486+PUSH(ACCESS_ARG(0));
2487+// SP 9
2488+// VERIFY SP
2489+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2490+CALLEND(1LLU, 0xFFFFFFFFFFFFFF66LLU, 0xADCB6E81E7279C00LLU);
2491+case 0xFFFFFFFFFFFFFF66LLU:
2492+// SP 4
12602493
1261- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2494+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2495+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2496+// SP 3
12622497 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1263- JUMP(0xFFFFFFFFFFFFFF6FLLU); // skip alternative
1264-case 0xFFFFFFFFFFFFFF70LLU: // alternative
2498+// SP 2
2499+// VERIFY SP
2500+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2501+ JUMP(0xFFFFFFFFFFFFFF69LLU); // skip alternative
2502+case 0xFFFFFFFFFFFFFF6ALLU: // alternative
12652503
12662504
1267- PUSH(0); // place-holder for result of block
1268-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2505+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2506+// SP 3
2507+// VERIFY SP
2508+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12692509 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12702510
12712511 // predicate
1272-CALLBEGIN(1/*nr of chunks returned*/); PUSH(58LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF69LLU, 0xA1CBDE8EAAEF0000LLU);
1273-case 0xFFFFFFFFFFFFFF69LLU:
1274-if(!ACCESS_CURRENT)
1275- JUMP(0xFFFFFFFFFFFFFF6BLLU); // skip consequent
2512+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
2513+// SP 8
2514+// VERIFY SP
2515+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2516+PUSH(58LLU);// SP 9
2517+// VERIFY SP
2518+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2519+CALLEND(1LLU, 0xFFFFFFFFFFFFFF63LLU, 0xA1CBDE8EAAEF0000LLU);
2520+case 0xFFFFFFFFFFFFFF63LLU:
2521+// SP 4
2522+if(!POP)
2523+// SP 3
2524+ JUMP(0xFFFFFFFFFFFFFF65LLU); // skip consequent
12762525 // consequent
12772526
1278- PUSH(0); // place-holder for result of block
1279-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2527+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2528+// SP 4
2529+// VERIFY SP
2530+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12802531 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12812532
1282- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF68LLU, 0xC60B5D72F9280000LLU);
1283-case 0xFFFFFFFFFFFFFF68LLU:
2533+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
2534+// SP 9
2535+// VERIFY SP
2536+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2537+CALLEND(0LLU, 0xFFFFFFFFFFFFFF62LLU, 0xC60B5D72F9280000LLU);
2538+case 0xFFFFFFFFFFFFFF62LLU:
2539+// SP 5
12842540 // escape hatch to C
1285- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2541+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2542+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2543+// SP 4
12862544 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1287- JUMP(0xFFFFFFFFFFFFFF6ALLU); // skip alternative
1288-case 0xFFFFFFFFFFFFFF6BLLU: // alternative
2545+// SP 3
2546+// VERIFY SP
2547+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2548+ JUMP(0xFFFFFFFFFFFFFF64LLU); // skip alternative
2549+case 0xFFFFFFFFFFFFFF65LLU: // alternative
12892550
12902551
1291- PUSH(0); // place-holder for result of block
1292-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2552+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2553+// SP 4
2554+// VERIFY SP
2555+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
12932556 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
12942557
12952558 // predicate
1296-CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF65LLU, 0xA1CBDE8EAAEF0000LLU);
1297-case 0xFFFFFFFFFFFFFF65LLU:
1298-if(!ACCESS_CURRENT)
1299- JUMP(0xFFFFFFFFFFFFFF67LLU); // skip consequent
2559+CALLBEGIN(1/*nr of chunks returned*/); // SP 5
2560+// SP 9
2561+// VERIFY SP
2562+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2563+PUSH(123LLU);// SP 10
2564+// VERIFY SP
2565+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2566+CALLEND(1LLU, 0xFFFFFFFFFFFFFF5FLLU, 0xA1CBDE8EAAEF0000LLU);
2567+case 0xFFFFFFFFFFFFFF5FLLU:
2568+// SP 5
2569+if(!POP)
2570+// SP 4
2571+ JUMP(0xFFFFFFFFFFFFFF61LLU); // skip consequent
13002572 // consequent
13012573
1302- PUSH(0); // place-holder for result of block
1303-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2574+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2575+// SP 5
2576+// VERIFY SP
2577+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13042578 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13052579
1306- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF64LLU, 0xADCB6E81D9EA7A60LLU);
1307-case 0xFFFFFFFFFFFFFF64LLU:
2580+ CALLBEGIN(1/*nr of chunks returned*/); // SP 6
2581+// SP 10
2582+// VERIFY SP
2583+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2584+PUSH(ACCESS_ARG(0));
2585+// SP 11
2586+// VERIFY SP
2587+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2588+CALLEND(1LLU, 0xFFFFFFFFFFFFFF5ELLU, 0xADCB6E81D9EA7A60LLU);
2589+case 0xFFFFFFFFFFFFFF5ELLU:
2590+// SP 6
13082591
1309- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2592+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2593+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2594+// SP 5
13102595 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1311- JUMP(0xFFFFFFFFFFFFFF66LLU); // skip alternative
1312-case 0xFFFFFFFFFFFFFF67LLU: // alternative
2596+// SP 4
2597+// VERIFY SP
2598+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2599+ JUMP(0xFFFFFFFFFFFFFF60LLU); // skip alternative
2600+case 0xFFFFFFFFFFFFFF61LLU: // alternative
13132601
13142602
1315- PUSH(0); // place-holder for result of block
1316-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2603+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2604+// SP 5
2605+// VERIFY SP
2606+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13172607 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13182608
13192609 // predicate
1320-CALLBEGIN(1/*nr of chunks returned*/); PUSH(64LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF61LLU, 0xA1CBDE8EAAEF0000LLU);
1321-case 0xFFFFFFFFFFFFFF61LLU:
1322-if(!ACCESS_CURRENT)
1323- JUMP(0xFFFFFFFFFFFFFF63LLU); // skip consequent
2610+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
2611+// SP 10
2612+// VERIFY SP
2613+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2614+PUSH(64LLU);// SP 11
2615+// VERIFY SP
2616+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2617+CALLEND(1LLU, 0xFFFFFFFFFFFFFF5BLLU, 0xA1CBDE8EAAEF0000LLU);
2618+case 0xFFFFFFFFFFFFFF5BLLU:
2619+// SP 6
2620+if(!POP)
2621+// SP 5
2622+ JUMP(0xFFFFFFFFFFFFFF5DLLU); // skip consequent
13242623 // consequent
13252624
1326- PUSH(0); // place-holder for result of block
1327-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2625+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2626+// SP 6
2627+// VERIFY SP
2628+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13282629 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13292630
1330- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF60LLU, 0xADCB6E8328E49E00LLU);
1331-case 0xFFFFFFFFFFFFFF60LLU:
2631+ CALLBEGIN(1/*nr of chunks returned*/); // SP 7
2632+// SP 11
2633+// VERIFY SP
2634+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2635+PUSH(ACCESS_ARG(0));
2636+// SP 12
2637+// VERIFY SP
2638+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2639+CALLEND(1LLU, 0xFFFFFFFFFFFFFF5ALLU, 0xADCB6E8328E49E00LLU);
2640+case 0xFFFFFFFFFFFFFF5ALLU:
2641+// SP 7
13322642
1333- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2643+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2644+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2645+// SP 6
13342646 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1335- JUMP(0xFFFFFFFFFFFFFF62LLU); // skip alternative
1336-case 0xFFFFFFFFFFFFFF63LLU: // alternative
2647+// SP 5
2648+// VERIFY SP
2649+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2650+ JUMP(0xFFFFFFFFFFFFFF5CLLU); // skip alternative
2651+case 0xFFFFFFFFFFFFFF5DLLU: // alternative
13372652
13382653
1339- PUSH(0); // place-holder for result of block
1340-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2654+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2655+// SP 6
2656+// VERIFY SP
2657+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13412658 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13422659
13432660 // predicate
1344-CALLBEGIN(1/*nr of chunks returned*/); PUSH(63LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF5DLLU, 0xA1CBDE8EAAEF0000LLU);
1345-case 0xFFFFFFFFFFFFFF5DLLU:
1346-if(!ACCESS_CURRENT)
1347- JUMP(0xFFFFFFFFFFFFFF5FLLU); // skip consequent
2661+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
2662+// SP 11
2663+// VERIFY SP
2664+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2665+PUSH(63LLU);// SP 12
2666+// VERIFY SP
2667+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2668+CALLEND(1LLU, 0xFFFFFFFFFFFFFF57LLU, 0xA1CBDE8EAAEF0000LLU);
2669+case 0xFFFFFFFFFFFFFF57LLU:
2670+// SP 7
2671+if(!POP)
2672+// SP 6
2673+ JUMP(0xFFFFFFFFFFFFFF59LLU); // skip consequent
13482674 // consequent
13492675
1350- PUSH(0); // place-holder for result of block
1351-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2676+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2677+// SP 7
2678+// VERIFY SP
2679+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13522680 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13532681
1354- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF5CLLU, 0xADCB6E8248400000LLU);
1355-case 0xFFFFFFFFFFFFFF5CLLU:
2682+ CALLBEGIN(1/*nr of chunks returned*/); // SP 8
2683+// SP 12
2684+// VERIFY SP
2685+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2686+PUSH(ACCESS_ARG(0));
2687+// SP 13
2688+// VERIFY SP
2689+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2690+CALLEND(1LLU, 0xFFFFFFFFFFFFFF56LLU, 0xADCB6E8248400000LLU);
2691+case 0xFFFFFFFFFFFFFF56LLU:
2692+// SP 8
13562693
1357- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2694+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2695+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2696+// SP 7
13582697 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1359- JUMP(0xFFFFFFFFFFFFFF5ELLU); // skip alternative
1360-case 0xFFFFFFFFFFFFFF5FLLU: // alternative
2698+// SP 6
2699+// VERIFY SP
2700+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2701+ JUMP(0xFFFFFFFFFFFFFF58LLU); // skip alternative
2702+case 0xFFFFFFFFFFFFFF59LLU: // alternative
13612703
13622704
1363- PUSH(0); // place-holder for result of block
1364-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2705+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2706+// SP 7
2707+// VERIFY SP
2708+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13652709 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13662710
13672711 // predicate
1368-CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF59LLU, 0xA1CBDE8EAAEF0000LLU);
1369-case 0xFFFFFFFFFFFFFF59LLU:
1370-if(!ACCESS_CURRENT)
1371- JUMP(0xFFFFFFFFFFFFFF5BLLU); // skip consequent
2712+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
2713+// SP 12
2714+// VERIFY SP
2715+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2716+PUSH(95LLU);// SP 13
2717+// VERIFY SP
2718+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2719+CALLEND(1LLU, 0xFFFFFFFFFFFFFF53LLU, 0xA1CBDE8EAAEF0000LLU);
2720+case 0xFFFFFFFFFFFFFF53LLU:
2721+// SP 8
2722+if(!POP)
2723+// SP 7
2724+ JUMP(0xFFFFFFFFFFFFFF55LLU); // skip consequent
13722725 // consequent
13732726
1374- PUSH(0); // place-holder for result of block
1375-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2727+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2728+// SP 8
2729+// VERIFY SP
2730+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13762731 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13772732
1378- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF58LLU, 0x72EBA48A9C5CB400LLU);
1379-case 0xFFFFFFFFFFFFFF58LLU:
2733+ CALLBEGIN(1/*nr of chunks returned*/); // SP 9
2734+// SP 13
2735+// VERIFY SP
2736+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2737+CALLEND(0LLU, 0xFFFFFFFFFFFFFF52LLU, 0xBA692B7A8A6FB800LLU);
2738+case 0xFFFFFFFFFFFFFF52LLU:
2739+// SP 9
13802740
1381- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2741+ CALLBEGIN(1/*nr of chunks returned*/); // SP 10
2742+// SP 14
2743+// VERIFY SP
2744+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2745+PUSH(61LLU);// SP 15
2746+// VERIFY SP
2747+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2748+CALLEND(1LLU, 0xFFFFFFFFFFFFFF51LLU, 0xA1CBDE8C00000000LLU);
2749+case 0xFFFFFFFFFFFFFF51LLU:
2750+// SP 10
2751+
2752+ CALLBEGIN(1/*nr of chunks returned*/); // SP 11
2753+// SP 15
2754+// VERIFY SP
2755+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2756+PUSH(ACCESS_ARG(0));
2757+// SP 16
2758+// VERIFY SP
2759+if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2760+CALLEND(1LLU, 0xFFFFFFFFFFFFFF50LLU, 0xADCB6E820CEBB400LLU);
2761+case 0xFFFFFFFFFFFFFF50LLU:
2762+// SP 11
2763+
2764+ fprintf(stdout, "(void)POP;\n");
2765+ SP_ADD_VERIFY(-1);
2766+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2767+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2768+// SP 8
13822769 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1383- JUMP(0xFFFFFFFFFFFFFF5ALLU); // skip alternative
1384-case 0xFFFFFFFFFFFFFF5BLLU: // alternative
2770+// SP 7
2771+// VERIFY SP
2772+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2773+ JUMP(0xFFFFFFFFFFFFFF54LLU); // skip alternative
2774+case 0xFFFFFFFFFFFFFF55LLU: // alternative
13852775
13862776
1387- PUSH(0); // place-holder for result of block
1388-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2777+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2778+// SP 8
2779+// VERIFY SP
2780+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
13892781 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
13902782
13912783 // predicate
1392-CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF55LLU, 0xA1CBDE8EAAEF0000LLU);
1393-case 0xFFFFFFFFFFFFFF55LLU:
1394-if(!ACCESS_CURRENT)
1395- JUMP(0xFFFFFFFFFFFFFF57LLU); // skip consequent
2784+CALLBEGIN(1/*nr of chunks returned*/); // SP 9
2785+// SP 13
2786+// VERIFY SP
2787+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2788+PUSH(96LLU);// SP 14
2789+// VERIFY SP
2790+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2791+CALLEND(1LLU, 0xFFFFFFFFFFFFFF4DLLU, 0xA1CBDE8EAAEF0000LLU);
2792+case 0xFFFFFFFFFFFFFF4DLLU:
2793+// SP 9
2794+if(!POP)
2795+// SP 8
2796+ JUMP(0xFFFFFFFFFFFFFF4FLLU); // skip consequent
13962797 // consequent
13972798
1398- PUSH(0); // place-holder for result of block
1399-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2799+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2800+// SP 9
2801+// VERIFY SP
2802+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14002803 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14012804
1402- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF54LLU, 0x72EBA48A98A7A9D0LLU);
1403-case 0xFFFFFFFFFFFFFF54LLU:
2805+ CALLBEGIN(1/*nr of chunks returned*/); // SP 10
2806+// SP 14
2807+// VERIFY SP
2808+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2809+PUSH(ACCESS_ARG(0));
2810+// SP 15
2811+// VERIFY SP
2812+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2813+CALLEND(1LLU, 0xFFFFFFFFFFFFFF4CLLU, 0x72EBA48A9C5CB400LLU);
2814+case 0xFFFFFFFFFFFFFF4CLLU:
2815+// SP 10
14042816
1405- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2817+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2818+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2819+// SP 9
14062820 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1407- JUMP(0xFFFFFFFFFFFFFF56LLU); // skip alternative
1408-case 0xFFFFFFFFFFFFFF57LLU: // alternative
2821+// SP 8
2822+// VERIFY SP
2823+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2824+ JUMP(0xFFFFFFFFFFFFFF4ELLU); // skip alternative
2825+case 0xFFFFFFFFFFFFFF4FLLU: // alternative
14092826
14102827
1411- PUSH(0); // place-holder for result of block
1412-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2828+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2829+// SP 9
2830+// VERIFY SP
2831+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14132832 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14142833
14152834 // predicate
1416-CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF51LLU, 0xA1CBDE8EAAEF0000LLU);
1417-case 0xFFFFFFFFFFFFFF51LLU:
1418-if(!ACCESS_CURRENT)
1419- JUMP(0xFFFFFFFFFFFFFF53LLU); // skip consequent
2835+CALLBEGIN(1/*nr of chunks returned*/); // SP 10
2836+// SP 14
2837+// VERIFY SP
2838+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2839+PUSH(94LLU);// SP 15
2840+// VERIFY SP
2841+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2842+CALLEND(1LLU, 0xFFFFFFFFFFFFFF49LLU, 0xA1CBDE8EAAEF0000LLU);
2843+case 0xFFFFFFFFFFFFFF49LLU:
2844+// SP 10
2845+if(!POP)
2846+// SP 9
2847+ JUMP(0xFFFFFFFFFFFFFF4BLLU); // skip consequent
14202848 // consequent
14212849
1422- PUSH(0); // place-holder for result of block
1423-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2850+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2851+// SP 10
2852+// VERIFY SP
2853+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14242854 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14252855
1426- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF50LLU, 0x72EBA48A972D8800LLU);
1427-case 0xFFFFFFFFFFFFFF50LLU:
2856+ CALLBEGIN(1/*nr of chunks returned*/); // SP 11
2857+// SP 15
2858+// VERIFY SP
2859+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2860+PUSH(ACCESS_ARG(0));
2861+// SP 16
2862+// VERIFY SP
2863+if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2864+CALLEND(1LLU, 0xFFFFFFFFFFFFFF48LLU, 0x72EBA48A98A7A9D0LLU);
2865+case 0xFFFFFFFFFFFFFF48LLU:
2866+// SP 11
14282867
1429- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2868+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2869+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2870+// SP 10
14302871 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1431- JUMP(0xFFFFFFFFFFFFFF52LLU); // skip alternative
1432-case 0xFFFFFFFFFFFFFF53LLU: // alternative
2872+// SP 9
2873+// VERIFY SP
2874+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2875+ JUMP(0xFFFFFFFFFFFFFF4ALLU); // skip alternative
2876+case 0xFFFFFFFFFFFFFF4BLLU: // alternative
14332877
14342878
1435- PUSH(0); // place-holder for result of block
1436-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2879+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2880+// SP 10
2881+// VERIFY SP
2882+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14372883 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14382884
14392885 // predicate
1440-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF4DLLU, 0xA1CBDE8EAAEF0000LLU);
1441-case 0xFFFFFFFFFFFFFF4DLLU:
1442-if(!ACCESS_CURRENT)
1443- JUMP(0xFFFFFFFFFFFFFF4FLLU); // skip consequent
2886+CALLBEGIN(1/*nr of chunks returned*/); // SP 11
2887+// SP 15
2888+// VERIFY SP
2889+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2890+PUSH(35LLU);// SP 16
2891+// VERIFY SP
2892+if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2893+CALLEND(1LLU, 0xFFFFFFFFFFFFFF45LLU, 0xA1CBDE8EAAEF0000LLU);
2894+case 0xFFFFFFFFFFFFFF45LLU:
2895+// SP 11
2896+if(!POP)
2897+// SP 10
2898+ JUMP(0xFFFFFFFFFFFFFF47LLU); // skip consequent
14442899 // consequent
14452900
1446- PUSH(0); // place-holder for result of block
1447-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2901+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2902+// SP 11
2903+// VERIFY SP
2904+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14482905 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14492906
2907+ CALLBEGIN(1/*nr of chunks returned*/); // SP 12
2908+// SP 16
2909+// VERIFY SP
2910+if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2911+PUSH(ACCESS_ARG(0));
2912+// SP 17
2913+// VERIFY SP
2914+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2915+CALLEND(1LLU, 0xFFFFFFFFFFFFFF44LLU, 0x72EBA48A972D8800LLU);
2916+case 0xFFFFFFFFFFFFFF44LLU:
2917+// SP 12
2918+
2919+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2920+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2921+// SP 11
2922+stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2923+// SP 10
2924+// VERIFY SP
2925+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2926+ JUMP(0xFFFFFFFFFFFFFF46LLU); // skip alternative
2927+case 0xFFFFFFFFFFFFFF47LLU: // alternative
2928+
2929+
2930+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2931+// SP 11
2932+// VERIFY SP
2933+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2934+stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
2935+
14502936 // predicate
1451-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF4ALLU, 0xA1CBDE8EAAEF0000LLU);
1452-case 0xFFFFFFFFFFFFFF4ALLU:
1453-if(!ACCESS_CURRENT)
1454- JUMP(0xFFFFFFFFFFFFFF4CLLU); // skip consequent
2937+CALLBEGIN(1/*nr of chunks returned*/); // SP 12
2938+// SP 16
2939+// VERIFY SP
2940+if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2941+PUSH(47LLU);// SP 17
2942+// VERIFY SP
2943+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2944+CALLEND(1LLU, 0xFFFFFFFFFFFFFF41LLU, 0xA1CBDE8EAAEF0000LLU);
2945+case 0xFFFFFFFFFFFFFF41LLU:
2946+// SP 12
2947+if(!POP)
2948+// SP 11
2949+ JUMP(0xFFFFFFFFFFFFFF43LLU); // skip consequent
14552950 // consequent
14562951
1457- PUSH(0); // place-holder for result of block
1458-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2952+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2953+// SP 12
2954+// VERIFY SP
2955+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14592956 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14602957
1461- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF49LLU, 0x7AAA28829BC00000LLU);
1462-case 0xFFFFFFFFFFFFFF49LLU:
2958+ // predicate
2959+CALLBEGIN(1/*nr of chunks returned*/); // SP 13
2960+// SP 17
2961+// VERIFY SP
2962+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2963+PUSH(47LLU);// SP 18
2964+// VERIFY SP
2965+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2966+CALLEND(1LLU, 0xFFFFFFFFFFFFFF3ELLU, 0xA1CBDE8EAAEF0000LLU);
2967+case 0xFFFFFFFFFFFFFF3ELLU:
2968+// SP 13
2969+if(!POP)
2970+// SP 12
2971+ JUMP(0xFFFFFFFFFFFFFF40LLU); // skip consequent
2972+// consequent
14632973
1464- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2974+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2975+// SP 13
2976+// VERIFY SP
2977+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2978+stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
2979+
2980+ CALLBEGIN(1/*nr of chunks returned*/); // SP 14
2981+// SP 18
2982+// VERIFY SP
2983+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2984+CALLEND(0LLU, 0xFFFFFFFFFFFFFF3DLLU, 0x7AAA28829BC00000LLU);
2985+case 0xFFFFFFFFFFFFFF3DLLU:
2986+// SP 14
2987+
2988+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
2989+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
2990+// SP 13
14652991 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1466- JUMP(0xFFFFFFFFFFFFFF4BLLU); // skip alternative
1467-case 0xFFFFFFFFFFFFFF4CLLU: // alternative
2992+// SP 12
2993+// VERIFY SP
2994+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
2995+ JUMP(0xFFFFFFFFFFFFFF3FLLU); // skip alternative
2996+case 0xFFFFFFFFFFFFFF40LLU: // alternative
14682997
1469-
1470- PUSH(0); // place-holder for result of block
1471-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
2998+
2999+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3000+// SP 13
3001+// VERIFY SP
3002+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14723003 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14733004
1474- // predicate
1475-CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF46LLU, 0xA1CBDE8EAAEF0000LLU);
1476-case 0xFFFFFFFFFFFFFF46LLU:
1477-if(!ACCESS_CURRENT)
1478- JUMP(0xFFFFFFFFFFFFFF48LLU); // skip consequent
3005+ // predicate
3006+CALLBEGIN(1/*nr of chunks returned*/); // SP 14
3007+// SP 18
3008+// VERIFY SP
3009+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3010+PUSH(42LLU);// SP 19
3011+// VERIFY SP
3012+if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3013+CALLEND(1LLU, 0xFFFFFFFFFFFFFF3ALLU, 0xA1CBDE8EAAEF0000LLU);
3014+case 0xFFFFFFFFFFFFFF3ALLU:
3015+// SP 14
3016+if(!POP)
3017+// SP 13
3018+ JUMP(0xFFFFFFFFFFFFFF3CLLU); // skip consequent
14793019 // consequent
14803020
1481- PUSH(0); // place-holder for result of block
1482-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3021+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3022+// SP 14
3023+// VERIFY SP
3024+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14833025 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14843026
1485- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF45LLU, 0x7AAA28829BC00001LLU);
1486-case 0xFFFFFFFFFFFFFF45LLU:
3027+ CALLBEGIN(1/*nr of chunks returned*/); // SP 15
3028+// SP 19
3029+// VERIFY SP
3030+if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3031+CALLEND(0LLU, 0xFFFFFFFFFFFFFF39LLU, 0x7AAA28829BC00001LLU);
3032+case 0xFFFFFFFFFFFFFF39LLU:
3033+// SP 15
14873034
1488- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3035+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3036+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3037+// SP 14
14893038 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1490- JUMP(0xFFFFFFFFFFFFFF47LLU); // skip alternative
1491-case 0xFFFFFFFFFFFFFF48LLU: // alternative
3039+// SP 13
3040+// VERIFY SP
3041+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3042+ JUMP(0xFFFFFFFFFFFFFF3BLLU); // skip alternative
3043+case 0xFFFFFFFFFFFFFF3CLLU: // alternative
14923044
1493-
1494- PUSH(0); // place-holder for result of block
1495-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3045+
3046+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3047+// SP 14
3048+// VERIFY SP
3049+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
14963050 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
14973051
1498- fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
1499- fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
1500- exit(-1);
1501- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3052+ fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
3053+ fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
3054+ exit(-1);
3055+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3056+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3057+// SP 14
15023058 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1503-case 0xFFFFFFFFFFFFFF47LLU: // skip to here
3059+// SP 13
3060+// VERIFY SP
3061+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3062+case 0xFFFFFFFFFFFFFF3BLLU: // skip to here
15043063
1505- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3064+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3065+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3066+// SP 13
15063067 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1507-case 0xFFFFFFFFFFFFFF4BLLU: // skip to here
3068+// SP 12
3069+// VERIFY SP
3070+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3071+case 0xFFFFFFFFFFFFFF3FLLU: // skip to here
15083072
1509- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3073+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3074+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3075+// SP 12
15103076 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1511- JUMP(0xFFFFFFFFFFFFFF4ELLU); // skip alternative
1512-case 0xFFFFFFFFFFFFFF4FLLU: // alternative
3077+// SP 11
3078+// VERIFY SP
3079+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3080+ JUMP(0xFFFFFFFFFFFFFF42LLU); // skip alternative
3081+case 0xFFFFFFFFFFFFFF43LLU: // alternative
15133082
1514-
1515- PUSH(0); // place-holder for result of block
1516-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3083+
3084+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3085+// SP 12
3086+// VERIFY SP
3087+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
15173088 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
15183089
1519- // predicate
1520-CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF42LLU, 0xA1CBDE8EAAEF0000LLU);
1521-case 0xFFFFFFFFFFFFFF42LLU:
1522-if(!ACCESS_CURRENT)
1523- JUMP(0xFFFFFFFFFFFFFF44LLU); // skip consequent
3090+ // predicate
3091+CALLBEGIN(1/*nr of chunks returned*/); // SP 13
3092+// SP 17
3093+// VERIFY SP
3094+if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3095+PUSH(125LLU);// SP 18
3096+// VERIFY SP
3097+if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3098+CALLEND(1LLU, 0xFFFFFFFFFFFFFF36LLU, 0xA1CBDE8EAAEF0000LLU);
3099+case 0xFFFFFFFFFFFFFF36LLU:
3100+// SP 13
3101+if(!POP)
3102+// SP 12
3103+ JUMP(0xFFFFFFFFFFFFFF38LLU); // skip consequent
15243104 // consequent
15253105
1526- PUSH(0); // place-holder for result of block
1527-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3106+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3107+// SP 13
3108+// VERIFY SP
3109+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
15283110 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
15293111
1530- fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
1531- fprintf(stderr, "superfluous closing curly brace '}'\n");
1532- exit(-1);
1533- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3112+ fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
3113+ fprintf(stderr, "superfluous closing curly brace '}'\n");
3114+ exit(-1);
3115+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3116+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3117+// SP 13
15343118 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1535- JUMP(0xFFFFFFFFFFFFFF43LLU); // skip alternative
1536-case 0xFFFFFFFFFFFFFF44LLU: // alternative
3119+// SP 12
3120+// VERIFY SP
3121+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3122+ JUMP(0xFFFFFFFFFFFFFF37LLU); // skip alternative
3123+case 0xFFFFFFFFFFFFFF38LLU: // alternative
15373124
1538-
1539- PUSH(0); // place-holder for result of block
1540-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3125+
3126+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3127+// SP 13
3128+// VERIFY SP
3129+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
15413130 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
15423131
1543- fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
1544- fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
1545- exit(-1);
1546- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3132+ fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
3133+ fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
3134+ exit(-1);
3135+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3136+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3137+// SP 13
15473138 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1548-case 0xFFFFFFFFFFFFFF43LLU: // skip to here
3139+// SP 12
3140+// VERIFY SP
3141+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3142+case 0xFFFFFFFFFFFFFF37LLU: // skip to here
15493143
1550- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3144+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3145+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3146+// SP 12
15513147 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1552-case 0xFFFFFFFFFFFFFF4ELLU: // skip to here
3148+// SP 11
3149+// VERIFY SP
3150+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3151+case 0xFFFFFFFFFFFFFF42LLU: // skip to here
15533152
1554- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3153+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3154+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3155+// SP 11
15553156 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1556-case 0xFFFFFFFFFFFFFF52LLU: // skip to here
3157+// SP 10
3158+// VERIFY SP
3159+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3160+case 0xFFFFFFFFFFFFFF46LLU: // skip to here
15573161
1558- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3162+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3163+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3164+// SP 10
15593165 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1560-case 0xFFFFFFFFFFFFFF56LLU: // skip to here
3166+// SP 9
3167+// VERIFY SP
3168+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3169+case 0xFFFFFFFFFFFFFF4ALLU: // skip to here
15613170
1562- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3171+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3172+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3173+// SP 9
15633174 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1564-case 0xFFFFFFFFFFFFFF5ALLU: // skip to here
3175+// SP 8
3176+// VERIFY SP
3177+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3178+case 0xFFFFFFFFFFFFFF4ELLU: // skip to here
15653179
1566- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3180+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3181+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3182+// SP 8
15673183 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1568-case 0xFFFFFFFFFFFFFF5ELLU: // skip to here
3184+// SP 7
3185+// VERIFY SP
3186+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3187+case 0xFFFFFFFFFFFFFF54LLU: // skip to here
15693188
1570- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3189+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3190+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3191+// SP 7
15713192 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1572-case 0xFFFFFFFFFFFFFF62LLU: // skip to here
3193+// SP 6
3194+// VERIFY SP
3195+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3196+case 0xFFFFFFFFFFFFFF58LLU: // skip to here
15733197
1574- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3198+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3199+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3200+// SP 6
15753201 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1576-case 0xFFFFFFFFFFFFFF66LLU: // skip to here
3202+// SP 5
3203+// VERIFY SP
3204+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3205+case 0xFFFFFFFFFFFFFF5CLLU: // skip to here
15773206
1578- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3207+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3208+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3209+// SP 5
15793210 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1580-case 0xFFFFFFFFFFFFFF6ALLU: // skip to here
3211+// SP 4
3212+// VERIFY SP
3213+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3214+case 0xFFFFFFFFFFFFFF60LLU: // skip to here
15813215
1582- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3216+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3217+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3218+// SP 4
15833219 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1584-case 0xFFFFFFFFFFFFFF6FLLU: // skip to here
3220+// SP 3
3221+// VERIFY SP
3222+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3223+case 0xFFFFFFFFFFFFFF64LLU: // skip to here
15853224
1586- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF41LLU, 0xBA692B7A8A6FB800LLU);
1587-case 0xFFFFFFFFFFFFFF41LLU:
3225+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3226+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3227+// SP 3
3228+stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
3229+// SP 2
3230+// VERIFY SP
3231+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3232+case 0xFFFFFFFFFFFFFF69LLU: // skip to here
15883233
1589- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3234+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3235+// SP 7
3236+// VERIFY SP
3237+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3238+CALLEND(0LLU, 0xFFFFFFFFFFFFFF35LLU, 0xBA692B7A8A6FB800LLU);
3239+case 0xFFFFFFFFFFFFFF35LLU:
3240+// SP 3
3241+
3242+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3243+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3244+// SP 2
15903245 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1591- JUMP(0xFFFFFFFFFFFFFF77LLU); // loop
1592-case 0xFFFFFFFFFFFFFF76LLU: // skip to here
3246+// SP 1
3247+// VERIFY SP
3248+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3249+ JUMP(0xFFFFFFFFFFFFFF71LLU); // loop
3250+case 0xFFFFFFFFFFFFFF70LLU: // skip to here
15933251
1594- CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF40LLU, 0xA1CBDE8C00000000LLU);
1595-case 0xFFFFFFFFFFFFFF40LLU:
3252+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3253+// SP 6
3254+// VERIFY SP
3255+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3256+PUSH(125LLU);// SP 7
3257+// VERIFY SP
3258+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3259+CALLEND(1LLU, 0xFFFFFFFFFFFFFF34LLU, 0xA1CBDE8C00000000LLU);
3260+case 0xFFFFFFFFFFFFFF34LLU:
3261+// SP 2
15963262
15973263 RET;
15983264
15993265
1600-case /*parseblock*/0xADCB6E81D9EA7A60LLU:
3266+case /*parseblock*/0xADCB6E81D9EA7A60LLU:// SP 0
3267+// VERIFY SP
3268+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16013269
1602- fprintf(stdout, "PUSH(0); // place-holder for result of block\n");
3270+
3271+ //:fprintf(stdout, "PUSH(0); // place-holder for result of block\n");:
3272+ //:SP_ADD_VERIFY(1);:
16033273 fprintf(stdout, "PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block\n");
3274+ SP_ADD_VERIFY(1);
3275+ ACCESS_RETURN = SP; // HACK store estimate in return
16043276 fprintf(stdout, "stack$$$[BLKINF_IDX] = sp$$$; // store base of current block\n");
16053277 //fprintf(stdout, "fprintf(stderr, \"STORE %llu\\\n\", (long long unsigned int)sp$$$);\n");
16063278
1607- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3FLLU, 0xADCB6E81DA9FD000LLU);
1608-case 0xFFFFFFFFFFFFFF3FLLU:
3279+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3280+// SP 5
3281+// VERIFY SP
3282+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3283+PUSH(ACCESS_ARG(0));
3284+// SP 6
3285+// VERIFY SP
3286+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3287+CALLEND(1LLU, 0xFFFFFFFFFFFFFF33LLU, 0xADCB6E81DA9FD000LLU);
3288+case 0xFFFFFFFFFFFFFF33LLU:
3289+// SP 1
16093290
16103291
1611- fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }");
3292+ fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }\n");
16123293 fprintf(stdout, "sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block\n");
3294+ SP_SET(ACCESS_RETURN);
16133295 //fprintf(stdout, "fprintf(stderr, "RETRIEVE %llu\n", (long long unsigned int)sp$$$);\n");
16143296 fprintf(stdout, "stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block\n");
3297+ SP_ADD_VERIFY(-1);
16153298 RET;
16163299
16173300
1618-case /*parsefnnew*/0xADCB6E821A698320LLU:
3301+case /*parsefnnew*/0xADCB6E821A698320LLU:// SP 0
3302+// VERIFY SP
3303+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16193304
1620- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3ELLU, 0xBA692B7A8A6FB800LLU);
1621-case 0xFFFFFFFFFFFFFF3ELLU:
16223305
3306+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3307+// SP 5
3308+// VERIFY SP
3309+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3310+CALLEND(0LLU, 0xFFFFFFFFFFFFFF32LLU, 0xBA692B7A8A6FB800LLU);
3311+case 0xFFFFFFFFFFFFFF32LLU:
3312+// SP 1
3313+
16233314 // predicate
1624-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3BLLU, 0xAE08260000000000LLU);
1625-case 0xFFFFFFFFFFFFFF3BLLU:
1626-PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF3ALLU, 0x9E0B000000000000LLU);
1627-case 0xFFFFFFFFFFFFFF3ALLU:
1628-if(!ACCESS_CURRENT)
1629- JUMP(0xFFFFFFFFFFFFFF3DLLU); // skip consequent
3315+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3316+// SP 6
3317+// VERIFY SP
3318+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3319+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
3320+// SP 11
3321+// VERIFY SP
3322+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3323+CALLEND(0LLU, 0xFFFFFFFFFFFFFF2FLLU, 0xAE08260000000000LLU);
3324+case 0xFFFFFFFFFFFFFF2FLLU:
3325+// SP 7
3326+PUSH(255LLU);// SP 8
3327+// VERIFY SP
3328+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3329+CALLEND(2LLU, 0xFFFFFFFFFFFFFF2ELLU, 0x9E0B000000000000LLU);
3330+case 0xFFFFFFFFFFFFFF2ELLU:
3331+// SP 2
3332+if(!POP)
3333+// SP 1
3334+ JUMP(0xFFFFFFFFFFFFFF31LLU); // skip consequent
16303335 // consequent
16313336
1632- PUSH(0); // place-holder for result of block
1633-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3337+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3338+// SP 2
3339+// VERIFY SP
3340+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16343341 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
16353342
16363343 fputs("case ", stdout);
1637- CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF39LLU, 0x4014931491000000LLU);
1638-case 0xFFFFFFFFFFFFFF39LLU:
1639-CALLEND(1LLU, 0xFFFFFFFFFFFFFF38LLU, 0xADCB6E821A400000LLU);
1640-case 0xFFFFFFFFFFFFFF38LLU:
3344+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3345+// SP 7
3346+// VERIFY SP
3347+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3348+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
3349+// SP 12
3350+// VERIFY SP
3351+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3352+CALLEND(0LLU, 0xFFFFFFFFFFFFFF2DLLU, 0x4014931491000000LLU);
3353+case 0xFFFFFFFFFFFFFF2DLLU:
3354+// SP 8
3355+CALLEND(1LLU, 0xFFFFFFFFFFFFFF2CLLU, 0xADCB6E821A400000LLU);
3356+case 0xFFFFFFFFFFFFFF2CLLU:
3357+// SP 3
16413358
1642- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3359+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3360+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3361+// SP 2
16433362 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1644- JUMP(0xFFFFFFFFFFFFFF3CLLU); // skip alternative
1645-case 0xFFFFFFFFFFFFFF3DLLU: // alternative
3363+// SP 1
3364+// VERIFY SP
3365+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3366+ JUMP(0xFFFFFFFFFFFFFF30LLU); // skip alternative
3367+case 0xFFFFFFFFFFFFFF31LLU: // alternative
16463368
16473369
1648- PUSH(0); // place-holder for result of block
1649-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3370+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3371+// SP 2
3372+// VERIFY SP
3373+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16503374 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
16513375
1652- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3376+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3377+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3378+// SP 2
16533379 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1654-case 0xFFFFFFFFFFFFFF3CLLU: // skip to here
3380+// SP 1
3381+// VERIFY SP
3382+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3383+case 0xFFFFFFFFFFFFFF30LLU: // skip to here
16553384
16563385 RET;
16573386
16583387
1659-case /*parsefn___*/0xADCB6E821A400000LLU:
3388+case /*parsefn___*/0xADCB6E821A400000LLU:// SP 0
3389+// VERIFY SP
3390+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16603391
1661- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF37LLU, 0xBA692B7A8A6FB800LLU);
1662-case 0xFFFFFFFFFFFFFF37LLU:
16633392
1664- CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF36LLU, 0xA1CBDE8C00000000LLU);
1665-case 0xFFFFFFFFFFFFFF36LLU:
3393+ SP_SET_VERIFY(0);
3394+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3395+// SP 5
3396+// VERIFY SP
3397+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3398+CALLEND(0LLU, 0xFFFFFFFFFFFFFF2BLLU, 0xBA692B7A8A6FB800LLU);
3399+case 0xFFFFFFFFFFFFFF2BLLU:
3400+// SP 1
16663401
1667- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF35LLU, 0xADCB6E81DA9FD000LLU);
1668-case 0xFFFFFFFFFFFFFF35LLU:
3402+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3403+// SP 6
3404+// VERIFY SP
3405+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3406+PUSH(123LLU);// SP 7
3407+// VERIFY SP
3408+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3409+CALLEND(1LLU, 0xFFFFFFFFFFFFFF2ALLU, 0xA1CBDE8C00000000LLU);
3410+case 0xFFFFFFFFFFFFFF2ALLU:
3411+// SP 2
16693412
3413+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3414+// SP 7
3415+// VERIFY SP
3416+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3417+PUSH(0LLU);// SP 8
3418+// VERIFY SP
3419+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3420+CALLEND(1LLU, 0xFFFFFFFFFFFFFF29LLU, 0xADCB6E81DA9FD000LLU);
3421+case 0xFFFFFFFFFFFFFF29LLU:
3422+// SP 3
3423+
16703424 fputs("RET;\n", stdout);
16713425 RET;
16723426
16733427
1674-case /*parsefns__*/0xADCB6E821A6E0000LLU:
3428+case /*parsefns__*/0xADCB6E821A6E0000LLU:// SP 0
3429+// VERIFY SP
3430+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16753431
1676- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF34LLU, 0xBA692B7A8A6FB800LLU);
1677-case 0xFFFFFFFFFFFFFF34LLU:
16783432
1679- case 0xFFFFFFFFFFFFFF33LLU: // loop to here
3433+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3434+// SP 5
3435+// VERIFY SP
3436+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3437+CALLEND(0LLU, 0xFFFFFFFFFFFFFF28LLU, 0xBA692B7A8A6FB800LLU);
3438+case 0xFFFFFFFFFFFFFF28LLU:
3439+// SP 1
3440+
3441+ case 0xFFFFFFFFFFFFFF27LLU: // loop to here
16803442 // predicate
1681-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF31LLU, 0xAE08260000000000LLU);
1682-case 0xFFFFFFFFFFFFFF31LLU:
1683-PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF30LLU, 0x9E0B000000000000LLU);
1684-case 0xFFFFFFFFFFFFFF30LLU:
1685-if(!ACCESS_CURRENT)
1686- JUMP(0xFFFFFFFFFFFFFF32LLU); // skip loop
3443+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3444+// SP 6
3445+// VERIFY SP
3446+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3447+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
3448+// SP 11
3449+// VERIFY SP
3450+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3451+CALLEND(0LLU, 0xFFFFFFFFFFFFFF25LLU, 0xAE08260000000000LLU);
3452+case 0xFFFFFFFFFFFFFF25LLU:
3453+// SP 7
3454+PUSH(255LLU);// SP 8
3455+// VERIFY SP
3456+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3457+CALLEND(2LLU, 0xFFFFFFFFFFFFFF24LLU, 0x9E0B000000000000LLU);
3458+case 0xFFFFFFFFFFFFFF24LLU:
3459+// SP 2
3460+if(!POP)
3461+// SP 1
3462+ JUMP(0xFFFFFFFFFFFFFF26LLU); // skip loop
16873463 // loop
16883464
1689- PUSH(0); // place-holder for result of block
1690-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3465+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3466+// SP 2
3467+// VERIFY SP
3468+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
16913469 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
16923470
16933471 // predicate
1694-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF2DLLU, 0xAE08260000000000LLU);
1695-case 0xFFFFFFFFFFFFFF2DLLU:
1696-CALLEND(1LLU, 0xFFFFFFFFFFFFFF2CLLU, 0x92E727AE37000000LLU);
1697-case 0xFFFFFFFFFFFFFF2CLLU:
1698-if(!ACCESS_CURRENT)
1699- JUMP(0xFFFFFFFFFFFFFF2FLLU); // skip consequent
3472+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3473+// SP 7
3474+// VERIFY SP
3475+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3476+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
3477+// SP 12
3478+// VERIFY SP
3479+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3480+CALLEND(0LLU, 0xFFFFFFFFFFFFFF21LLU, 0xAE08260000000000LLU);
3481+case 0xFFFFFFFFFFFFFF21LLU:
3482+// SP 8
3483+CALLEND(1LLU, 0xFFFFFFFFFFFFFF20LLU, 0x92E727AE37000000LLU);
3484+case 0xFFFFFFFFFFFFFF20LLU:
3485+// SP 3
3486+if(!POP)
3487+// SP 2
3488+ JUMP(0xFFFFFFFFFFFFFF23LLU); // skip consequent
17003489 // consequent
17013490
1702- PUSH(0); // place-holder for result of block
1703-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3491+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3492+// SP 3
3493+// VERIFY SP
3494+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17043495 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17053496
1706- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF2BLLU, 0xADCB6E821A698320LLU);
1707-case 0xFFFFFFFFFFFFFF2BLLU:
3497+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
3498+// SP 8
3499+// VERIFY SP
3500+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3501+CALLEND(0LLU, 0xFFFFFFFFFFFFFF1FLLU, 0xADCB6E821A698320LLU);
3502+case 0xFFFFFFFFFFFFFF1FLLU:
3503+// SP 4
17083504
1709- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3505+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3506+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3507+// SP 3
17103508 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1711- JUMP(0xFFFFFFFFFFFFFF2ELLU); // skip alternative
1712-case 0xFFFFFFFFFFFFFF2FLLU: // alternative
3509+// SP 2
3510+// VERIFY SP
3511+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3512+ JUMP(0xFFFFFFFFFFFFFF22LLU); // skip alternative
3513+case 0xFFFFFFFFFFFFFF23LLU: // alternative
17133514
17143515
1715- PUSH(0); // place-holder for result of block
1716-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3516+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3517+// SP 3
3518+// VERIFY SP
3519+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17173520 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17183521
17193522 // predicate
1720-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF28LLU, 0xA1CBDE8EAAEF0000LLU);
1721-case 0xFFFFFFFFFFFFFF28LLU:
1722-if(!ACCESS_CURRENT)
1723- JUMP(0xFFFFFFFFFFFFFF2ALLU); // skip consequent
3523+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
3524+// SP 8
3525+// VERIFY SP
3526+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3527+PUSH(47LLU);// SP 9
3528+// VERIFY SP
3529+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3530+CALLEND(1LLU, 0xFFFFFFFFFFFFFF1CLLU, 0xA1CBDE8EAAEF0000LLU);
3531+case 0xFFFFFFFFFFFFFF1CLLU:
3532+// SP 4
3533+if(!POP)
3534+// SP 3
3535+ JUMP(0xFFFFFFFFFFFFFF1ELLU); // skip consequent
17243536 // consequent
17253537
1726- PUSH(0); // place-holder for result of block
1727-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3538+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3539+// SP 4
3540+// VERIFY SP
3541+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17283542 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17293543
17303544 // predicate
1731-CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF25LLU, 0xA1CBDE8EAAEF0000LLU);
1732-case 0xFFFFFFFFFFFFFF25LLU:
1733-if(!ACCESS_CURRENT)
1734- JUMP(0xFFFFFFFFFFFFFF27LLU); // skip consequent
3545+CALLBEGIN(1/*nr of chunks returned*/); // SP 5
3546+// SP 9
3547+// VERIFY SP
3548+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3549+PUSH(47LLU);// SP 10
3550+// VERIFY SP
3551+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3552+CALLEND(1LLU, 0xFFFFFFFFFFFFFF19LLU, 0xA1CBDE8EAAEF0000LLU);
3553+case 0xFFFFFFFFFFFFFF19LLU:
3554+// SP 5
3555+if(!POP)
3556+// SP 4
3557+ JUMP(0xFFFFFFFFFFFFFF1BLLU); // skip consequent
17353558 // consequent
17363559
1737- PUSH(0); // place-holder for result of block
1738-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3560+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3561+// SP 5
3562+// VERIFY SP
3563+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17393564 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17403565
1741- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF24LLU, 0x7AAA28829BC00000LLU);
1742-case 0xFFFFFFFFFFFFFF24LLU:
3566+ CALLBEGIN(1/*nr of chunks returned*/); // SP 6
3567+// SP 10
3568+// VERIFY SP
3569+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3570+CALLEND(0LLU, 0xFFFFFFFFFFFFFF18LLU, 0x7AAA28829BC00000LLU);
3571+case 0xFFFFFFFFFFFFFF18LLU:
3572+// SP 6
17433573
1744- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3574+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3575+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3576+// SP 5
17453577 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1746- JUMP(0xFFFFFFFFFFFFFF26LLU); // skip alternative
1747-case 0xFFFFFFFFFFFFFF27LLU: // alternative
3578+// SP 4
3579+// VERIFY SP
3580+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3581+ JUMP(0xFFFFFFFFFFFFFF1ALLU); // skip alternative
3582+case 0xFFFFFFFFFFFFFF1BLLU: // alternative
17483583
17493584
1750- PUSH(0); // place-holder for result of block
1751-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3585+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3586+// SP 5
3587+// VERIFY SP
3588+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17523589 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17533590
17543591 // predicate
1755-CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF21LLU, 0xA1CBDE8EAAEF0000LLU);
1756-case 0xFFFFFFFFFFFFFF21LLU:
1757-if(!ACCESS_CURRENT)
1758- JUMP(0xFFFFFFFFFFFFFF23LLU); // skip consequent
3592+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
3593+// SP 10
3594+// VERIFY SP
3595+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3596+PUSH(42LLU);// SP 11
3597+// VERIFY SP
3598+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3599+CALLEND(1LLU, 0xFFFFFFFFFFFFFF15LLU, 0xA1CBDE8EAAEF0000LLU);
3600+case 0xFFFFFFFFFFFFFF15LLU:
3601+// SP 6
3602+if(!POP)
3603+// SP 5
3604+ JUMP(0xFFFFFFFFFFFFFF17LLU); // skip consequent
17593605 // consequent
17603606
1761- PUSH(0); // place-holder for result of block
1762-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3607+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3608+// SP 6
3609+// VERIFY SP
3610+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17633611 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17643612
1765- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF20LLU, 0x7AAA28829BC00001LLU);
1766-case 0xFFFFFFFFFFFFFF20LLU:
3613+ CALLBEGIN(1/*nr of chunks returned*/); // SP 7
3614+// SP 11
3615+// VERIFY SP
3616+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3617+CALLEND(0LLU, 0xFFFFFFFFFFFFFF14LLU, 0x7AAA28829BC00001LLU);
3618+case 0xFFFFFFFFFFFFFF14LLU:
3619+// SP 7
17673620
1768- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3621+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3622+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3623+// SP 6
17693624 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1770- JUMP(0xFFFFFFFFFFFFFF22LLU); // skip alternative
1771-case 0xFFFFFFFFFFFFFF23LLU: // alternative
3625+// SP 5
3626+// VERIFY SP
3627+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3628+ JUMP(0xFFFFFFFFFFFFFF16LLU); // skip alternative
3629+case 0xFFFFFFFFFFFFFF17LLU: // alternative
17723630
17733631
1774- PUSH(0); // place-holder for result of block
1775-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3632+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3633+// SP 6
3634+// VERIFY SP
3635+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17763636 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17773637
17783638 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
17793639 fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get
17803640 exit(-1);
1781- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3641+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3642+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3643+// SP 6
17823644 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1783-case 0xFFFFFFFFFFFFFF22LLU: // skip to here
3645+// SP 5
3646+// VERIFY SP
3647+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3648+case 0xFFFFFFFFFFFFFF16LLU: // skip to here
17843649
1785- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3650+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3651+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3652+// SP 5
17863653 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1787-case 0xFFFFFFFFFFFFFF26LLU: // skip to here
3654+// SP 4
3655+// VERIFY SP
3656+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3657+case 0xFFFFFFFFFFFFFF1ALLU: // skip to here
17883658
1789- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3659+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3660+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3661+// SP 4
17903662 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1791- JUMP(0xFFFFFFFFFFFFFF29LLU); // skip alternative
1792-case 0xFFFFFFFFFFFFFF2ALLU: // alternative
3663+// SP 3
3664+// VERIFY SP
3665+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3666+ JUMP(0xFFFFFFFFFFFFFF1DLLU); // skip alternative
3667+case 0xFFFFFFFFFFFFFF1ELLU: // alternative
17933668
17943669
1795- PUSH(0); // place-holder for result of block
1796-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3670+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3671+// SP 4
3672+// VERIFY SP
3673+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
17973674 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
17983675
17993676 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
18003677 fprintf(stderr, "expected function definition but found unexpected '%c' (%d)\n", ungetc(fgetc(stdin), stdin), (int)ungetc(fgetc(stdin), stdin));
18013678 exit(-1);
1802- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3679+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3680+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3681+// SP 4
18033682 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1804-case 0xFFFFFFFFFFFFFF29LLU: // skip to here
3683+// SP 3
3684+// VERIFY SP
3685+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3686+case 0xFFFFFFFFFFFFFF1DLLU: // skip to here
18053687
1806- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3688+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3689+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3690+// SP 3
18073691 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1808-case 0xFFFFFFFFFFFFFF2ELLU: // skip to here
3692+// SP 2
3693+// VERIFY SP
3694+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3695+case 0xFFFFFFFFFFFFFF22LLU: // skip to here
18093696
1810- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1FLLU, 0xBA692B7A8A6FB800LLU);
1811-case 0xFFFFFFFFFFFFFF1FLLU:
3697+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3698+// SP 7
3699+// VERIFY SP
3700+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3701+CALLEND(0LLU, 0xFFFFFFFFFFFFFF13LLU, 0xBA692B7A8A6FB800LLU);
3702+case 0xFFFFFFFFFFFFFF13LLU:
3703+// SP 3
18123704
1813- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3705+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3706+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3707+// SP 2
18143708 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1815- JUMP(0xFFFFFFFFFFFFFF33LLU); // loop
1816-case 0xFFFFFFFFFFFFFF32LLU: // skip to here
3709+// SP 1
3710+// VERIFY SP
3711+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3712+ JUMP(0xFFFFFFFFFFFFFF27LLU); // loop
3713+case 0xFFFFFFFFFFFFFF26LLU: // skip to here
18173714
18183715 RET;
18193716
18203717
1821-case /*parsewhile*/0xADCB6E8328E49E00LLU:
3718+case /*parsewhile*/0xADCB6E8328E49E00LLU:// SP 0
3719+// VERIFY SP
3720+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
18223721
3722+
18233723 fprintf(stdout, "case 0x%0llXLLU%c // loop to here\n", (long long unsigned int)--ADDR, 58);
18243724 ACCESS_RETURN = --ADDR; // HACK store addr in return
1825- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1ELLU, 0xBA692B7A8A6FB800LLU);
1826-case 0xFFFFFFFFFFFFFF1ELLU:
3725+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3726+// SP 5
3727+// VERIFY SP
3728+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3729+CALLEND(0LLU, 0xFFFFFFFFFFFFFF12LLU, 0xBA692B7A8A6FB800LLU);
3730+case 0xFFFFFFFFFFFFFF12LLU:
3731+// SP 1
18273732
18283733 fprintf(stdout, "// predicate\n");
1829- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1DLLU, 0xADCB6E820CEBB400LLU);
1830-case 0xFFFFFFFFFFFFFF1DLLU:
3734+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3735+// SP 6
3736+// VERIFY SP
3737+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3738+PUSH(ACCESS_ARG(0));
3739+// SP 7
3740+// VERIFY SP
3741+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3742+CALLEND(1LLU, 0xFFFFFFFFFFFFFF11LLU, 0xADCB6E820CEBB400LLU);
3743+case 0xFFFFFFFFFFFFFF11LLU:
3744+// SP 2
18313745
1832- fprintf(stdout, "if(!ACCESS_CURRENT)\n");
3746+ fprintf(stdout, "if(!POP)\n"); SP_ADD(-1); // XXX VERIFY CRASHES HERE XXX
18333747 fprintf(stdout, " JUMP(0x%0llXLLU); // skip loop\n", (long long unsigned int)ACCESS_RETURN);
18343748 fprintf(stdout, "// loop\n");
1835- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1CLLU, 0xBA692B7A8A6FB800LLU);
1836-case 0xFFFFFFFFFFFFFF1CLLU:
3749+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3750+// SP 7
3751+// VERIFY SP
3752+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3753+CALLEND(0LLU, 0xFFFFFFFFFFFFFF10LLU, 0xBA692B7A8A6FB800LLU);
3754+case 0xFFFFFFFFFFFFFF10LLU:
3755+// SP 3
18373756
1838- CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF1BLLU, 0xA1CBDE8C00000000LLU);
1839-case 0xFFFFFFFFFFFFFF1BLLU:
3757+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
3758+// SP 8
3759+// VERIFY SP
3760+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3761+PUSH(123LLU);// SP 9
3762+// VERIFY SP
3763+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3764+CALLEND(1LLU, 0xFFFFFFFFFFFFFF0FLLU, 0xA1CBDE8C00000000LLU);
3765+case 0xFFFFFFFFFFFFFF0FLLU:
3766+// SP 4
18403767
1841- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1ALLU, 0xADCB6E81D9EA7A60LLU);
1842-case 0xFFFFFFFFFFFFFF1ALLU:
3768+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
3769+// SP 9
3770+// VERIFY SP
3771+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3772+PUSH(ACCESS_ARG(0));
3773+// SP 10
3774+// VERIFY SP
3775+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3776+CALLEND(1LLU, 0xFFFFFFFFFFFFFF0ELLU, 0xADCB6E81D9EA7A60LLU);
3777+case 0xFFFFFFFFFFFFFF0ELLU:
3778+// SP 5
18433779
18443780 fprintf(stdout, " JUMP(0x%0llXLLU); // loop\n", (long long unsigned int)ACCESS_RETURN + 1);
18453781 fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);
@@ -1846,37 +3782,86 @@
18463782 RET;
18473783
18483784
1849-case /*parseif___*/0xADCB6E8248400000LLU:
3785+case /*parseif___*/0xADCB6E8248400000LLU:// SP 0
3786+// VERIFY SP
3787+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
18503788
3789+
18513790 --ADDR; // reserve label
18523791 --ADDR; // reserve label
18533792 ACCESS_RETURN = ADDR; // HACK store addr in return
1854- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF19LLU, 0xBA692B7A8A6FB800LLU);
1855-case 0xFFFFFFFFFFFFFF19LLU:
3793+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3794+// SP 5
3795+// VERIFY SP
3796+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3797+CALLEND(0LLU, 0xFFFFFFFFFFFFFF0DLLU, 0xBA692B7A8A6FB800LLU);
3798+case 0xFFFFFFFFFFFFFF0DLLU:
3799+// SP 1
18563800
18573801 fprintf(stdout, "// predicate\n");
1858- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF18LLU, 0xADCB6E820CEBB400LLU);
1859-case 0xFFFFFFFFFFFFFF18LLU:
3802+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
3803+// SP 6
3804+// VERIFY SP
3805+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3806+PUSH(ACCESS_ARG(0));
3807+// SP 7
3808+// VERIFY SP
3809+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3810+CALLEND(1LLU, 0xFFFFFFFFFFFFFF0CLLU, 0xADCB6E820CEBB400LLU);
3811+case 0xFFFFFFFFFFFFFF0CLLU:
3812+// SP 2
18603813
1861- fprintf(stdout, "if(!ACCESS_CURRENT)\n");
3814+ fprintf(stdout, "if(!POP)\n"); SP_ADD(-1); // XXX VERIFY CRASHES HERE XXX
18623815 fprintf(stdout, " JUMP(0x%0llXLLU); // skip consequent\n", (long long unsigned int)ACCESS_RETURN + 1);
18633816 fprintf(stdout, "// consequent\n");
1864- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF17LLU, 0xBA692B7A8A6FB800LLU);
1865-case 0xFFFFFFFFFFFFFF17LLU:
3817+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
3818+// SP 7
3819+// VERIFY SP
3820+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3821+CALLEND(0LLU, 0xFFFFFFFFFFFFFF0BLLU, 0xBA692B7A8A6FB800LLU);
3822+case 0xFFFFFFFFFFFFFF0BLLU:
3823+// SP 3
18663824
1867- CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF16LLU, 0xA1CBDE8C00000000LLU);
1868-case 0xFFFFFFFFFFFFFF16LLU:
3825+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
3826+// SP 8
3827+// VERIFY SP
3828+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3829+PUSH(123LLU);// SP 9
3830+// VERIFY SP
3831+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3832+CALLEND(1LLU, 0xFFFFFFFFFFFFFF0ALLU, 0xA1CBDE8C00000000LLU);
3833+case 0xFFFFFFFFFFFFFF0ALLU:
3834+// SP 4
18693835
1870- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF15LLU, 0xADCB6E81D9EA7A60LLU);
1871-case 0xFFFFFFFFFFFFFF15LLU:
3836+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
3837+// SP 9
3838+// VERIFY SP
3839+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3840+PUSH(ACCESS_ARG(0));
3841+// SP 10
3842+// VERIFY SP
3843+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3844+CALLEND(1LLU, 0xFFFFFFFFFFFFFF09LLU, 0xADCB6E81D9EA7A60LLU);
3845+case 0xFFFFFFFFFFFFFF09LLU:
3846+// SP 5
18723847
18733848 fprintf(stdout, " JUMP(0x%0llXLLU); // skip alternative\n", (long long unsigned int)ACCESS_RETURN);
18743849 fprintf(stdout, "case 0x%0llXLLU%c // alternative\n", (long long unsigned int)ACCESS_RETURN + 1, 58);
1875- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF14LLU, 0xBA692B7A8A6FB800LLU);
1876-case 0xFFFFFFFFFFFFFF14LLU:
3850+ CALLBEGIN(1/*nr of chunks returned*/); // SP 6
3851+// SP 10
3852+// VERIFY SP
3853+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3854+CALLEND(0LLU, 0xFFFFFFFFFFFFFF08LLU, 0xBA692B7A8A6FB800LLU);
3855+case 0xFFFFFFFFFFFFFF08LLU:
3856+// SP 6
18773857
1878- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF13LLU, 0xADCB6E8247C00000LLU);
1879-case 0xFFFFFFFFFFFFFF13LLU:
3858+ CALLBEGIN(1/*nr of chunks returned*/); // SP 7
3859+// SP 11
3860+// VERIFY SP
3861+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3862+CALLEND(0LLU, 0xFFFFFFFFFFFFFF07LLU, 0xADCB6E8247C00000LLU);
3863+case 0xFFFFFFFFFFFFFF07LLU:
3864+// SP 7
18803865
18813866 if(0x827BA00000000000LLU != ACCESS_CURRENT)
18823867 {
@@ -1884,36 +3869,73 @@
18843869 fprintf(stderr, "missing keyword \"else\"\n");
18853870 exit(-1);
18863871 }
1887- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF12LLU, 0xBA692B7A8A6FB800LLU);
1888-case 0xFFFFFFFFFFFFFF12LLU:
3872+ CALLBEGIN(1/*nr of chunks returned*/); // SP 8
3873+// SP 12
3874+// VERIFY SP
3875+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3876+CALLEND(0LLU, 0xFFFFFFFFFFFFFF06LLU, 0xBA692B7A8A6FB800LLU);
3877+case 0xFFFFFFFFFFFFFF06LLU:
3878+// SP 8
18893879
18903880 // predicate
1891-CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF0FLLU, 0xA1CBDE8EAAEF0000LLU);
1892-case 0xFFFFFFFFFFFFFF0FLLU:
1893-if(!ACCESS_CURRENT)
1894- JUMP(0xFFFFFFFFFFFFFF11LLU); // skip consequent
3881+CALLBEGIN(1/*nr of chunks returned*/); // SP 9
3882+// SP 13
3883+// VERIFY SP
3884+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3885+PUSH(123LLU);// SP 14
3886+// VERIFY SP
3887+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3888+CALLEND(1LLU, 0xFFFFFFFFFFFFFF03LLU, 0xA1CBDE8EAAEF0000LLU);
3889+case 0xFFFFFFFFFFFFFF03LLU:
3890+// SP 9
3891+if(!POP)
3892+// SP 8
3893+ JUMP(0xFFFFFFFFFFFFFF05LLU); // skip consequent
18953894 // consequent
18963895
1897- PUSH(0); // place-holder for result of block
1898-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3896+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3897+// SP 9
3898+// VERIFY SP
3899+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
18993900 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
19003901
1901- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0ELLU, 0xADCB6E81D9EA7A60LLU);
1902-case 0xFFFFFFFFFFFFFF0ELLU:
3902+ CALLBEGIN(1/*nr of chunks returned*/); // SP 10
3903+// SP 14
3904+// VERIFY SP
3905+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3906+PUSH(ACCESS_ARG(0));
3907+// SP 15
3908+// VERIFY SP
3909+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3910+CALLEND(1LLU, 0xFFFFFFFFFFFFFF02LLU, 0xADCB6E81D9EA7A60LLU);
3911+case 0xFFFFFFFFFFFFFF02LLU:
3912+// SP 10
19033913
19043914 fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);
1905- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3915+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3916+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3917+// SP 9
19063918 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1907- JUMP(0xFFFFFFFFFFFFFF10LLU); // skip alternative
1908-case 0xFFFFFFFFFFFFFF11LLU: // alternative
3919+// SP 8
3920+// VERIFY SP
3921+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3922+ JUMP(0xFFFFFFFFFFFFFF04LLU); // skip alternative
3923+case 0xFFFFFFFFFFFFFF05LLU: // alternative
19093924
19103925
1911- PUSH(0); // place-holder for result of block
1912-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3926+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
3927+// SP 9
3928+// VERIFY SP
3929+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19133930 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
19143931
1915- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0DLLU, 0xADCB6E8247C00000LLU);
1916-case 0xFFFFFFFFFFFFFF0DLLU:
3932+ CALLBEGIN(1/*nr of chunks returned*/); // SP 10
3933+// SP 14
3934+// VERIFY SP
3935+if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3936+CALLEND(0LLU, 0xFFFFFFFFFFFFFF01LLU, 0xADCB6E8247C00000LLU);
3937+case 0xFFFFFFFFFFFFFF01LLU:
3938+// SP 10
19173939
19183940 if(10524912329164849152LLU != ACCESS_CURRENT) // XXX omitting block in case of else-if is broken XXX
19193941 {
@@ -1921,284 +3943,589 @@
19213943 fprintf(stdout, "expected either keyword \"if\" or open block '{'\n");
19223944 exit(-1);
19233945 }
1924- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0CLLU, 0xADCB6E8248400000LLU);
1925-case 0xFFFFFFFFFFFFFF0CLLU:
3946+ CALLBEGIN(1/*nr of chunks returned*/); // SP 11
3947+// SP 15
3948+// VERIFY SP
3949+if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3950+CALLEND(0LLU, 0xFFFFFFFFFFFFFF00LLU, 0xADCB6E8248400000LLU);
3951+case 0xFFFFFFFFFFFFFF00LLU:
3952+// SP 11
19263953
1927- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3954+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
3955+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
3956+// SP 9
19283957 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1929-case 0xFFFFFFFFFFFFFF10LLU: // skip to here
3958+// SP 8
3959+// VERIFY SP
3960+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3961+case 0xFFFFFFFFFFFFFF04LLU: // skip to here
19303962
19313963 RET;
19323964
19333965
1934-case /*parsecall_*/0xADCB6E81E7279C00LLU:
3966+case /*parsecall_*/0xADCB6E81E7279C00LLU:// SP 0
3967+// VERIFY SP
3968+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19353969
1936- CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0BLLU, 0xADCB6E8247C00000LLU);
1937-case 0xFFFFFFFFFFFFFF0BLLU:
1938-PUSH(0LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF0ALLU, 0xADCB6E81E7279F80LLU);
1939-case 0xFFFFFFFFFFFFFF0ALLU:
19403970
3971+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
3972+// SP 5
3973+// VERIFY SP
3974+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3975+PUSH(ACCESS_ARG(0));
3976+// SP 6
3977+// VERIFY SP
3978+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3979+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
3980+// SP 11
3981+// VERIFY SP
3982+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3983+CALLEND(0LLU, 0xFFFFFFFFFFFFFEFFLLU, 0xADCB6E8247C00000LLU);
3984+case 0xFFFFFFFFFFFFFEFFLLU:
3985+// SP 7
3986+PUSH(0LLU);// SP 8
3987+// VERIFY SP
3988+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
3989+CALLEND(3LLU, 0xFFFFFFFFFFFFFEFELLU, 0xADCB6E81E7279F80LLU);
3990+case 0xFFFFFFFFFFFFFEFELLU:
3991+// SP 1
3992+
19413993 RET;
19423994
19433995
1944-case /*parsecall2*/0xADCB6E81E7279F80LLU:
3996+case /*parsecall2*/0xADCB6E81E7279F80LLU:// SP 0
3997+// VERIFY SP
3998+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19453999
1946- ACCESS_RETURN = ACCESS_ARG(0); // HACK store id in return value
19474000
4001+ ACCESS_RETURN = ACCESS_ARG(1); // HACK store id in return value
4002+
19484003 fputs("CALLBEGIN(1/*nr of chunks returned*/); ", stdout); // NOTE do NOT enclose in block because a case-label can appear inbetween if nested call
4004+ SP_ADD(1);
4005+ ACCESS_ARG(0) = SP; // XXX HACK store estimate in argument XXX
4006+ SP_ADD_VERIFY(4);
19494007
19504008 // predicate
1951-CALLBEGIN(1/*nr of chunks returned*/); PUSH(40LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF07LLU, 0xA1CBDE8EAAEF0000LLU);
1952-case 0xFFFFFFFFFFFFFF07LLU:
1953-if(!ACCESS_CURRENT)
1954- JUMP(0xFFFFFFFFFFFFFF09LLU); // skip consequent
4009+CALLBEGIN(1/*nr of chunks returned*/); // SP 1
4010+// SP 5
4011+// VERIFY SP
4012+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4013+PUSH(40LLU);// SP 6
4014+// VERIFY SP
4015+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4016+CALLEND(1LLU, 0xFFFFFFFFFFFFFEFBLLU, 0xA1CBDE8EAAEF0000LLU);
4017+case 0xFFFFFFFFFFFFFEFBLLU:
4018+// SP 1
4019+if(!POP)
4020+// SP 0
4021+ JUMP(0xFFFFFFFFFFFFFEFDLLU); // skip consequent
19554022 // consequent
19564023
1957- PUSH(0); // place-holder for result of block
1958-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4024+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4025+// SP 1
4026+// VERIFY SP
4027+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19594028 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
19604029
1961- case 0xFFFFFFFFFFFFFF06LLU: // loop to here
4030+ case 0xFFFFFFFFFFFFFEFALLU: // loop to here
19624031 // predicate
1963-CALLBEGIN(1/*nr of chunks returned*/); PUSH(41LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF04LLU, 0xAE08260000000000LLU);
1964-case 0xFFFFFFFFFFFFFF04LLU:
1965-CALLEND(2LLU, 0xFFFFFFFFFFFFFF03LLU, 0xA60B000000000000LLU);
1966-case 0xFFFFFFFFFFFFFF03LLU:
1967-if(!ACCESS_CURRENT)
1968- JUMP(0xFFFFFFFFFFFFFF05LLU); // skip loop
4032+CALLBEGIN(1/*nr of chunks returned*/); // SP 2
4033+// SP 6
4034+// VERIFY SP
4035+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4036+PUSH(41LLU);// SP 7
4037+// VERIFY SP
4038+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4039+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
4040+// SP 12
4041+// VERIFY SP
4042+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4043+CALLEND(0LLU, 0xFFFFFFFFFFFFFEF8LLU, 0xAE08260000000000LLU);
4044+case 0xFFFFFFFFFFFFFEF8LLU:
4045+// SP 8
4046+CALLEND(2LLU, 0xFFFFFFFFFFFFFEF7LLU, 0xA60B000000000000LLU);
4047+case 0xFFFFFFFFFFFFFEF7LLU:
4048+// SP 2
4049+if(!POP)
4050+// SP 1
4051+ JUMP(0xFFFFFFFFFFFFFEF9LLU); // skip loop
19694052 // loop
19704053
1971- PUSH(0); // place-holder for result of block
1972-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4054+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4055+// SP 2
4056+// VERIFY SP
4057+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19734058 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
19744059
19754060 // predicate
1976-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF00LLU, 0xAE08260000000000LLU);
1977-case 0xFFFFFFFFFFFFFF00LLU:
1978-CALLEND(1LLU, 0xFFFFFFFFFFFFFEFFLLU, 0x92E7E48A4BC00000LLU);
1979-case 0xFFFFFFFFFFFFFEFFLLU:
1980-if(!ACCESS_CURRENT)
1981- JUMP(0xFFFFFFFFFFFFFF02LLU); // skip consequent
4061+CALLBEGIN(1/*nr of chunks returned*/); // SP 3
4062+// SP 7
4063+// VERIFY SP
4064+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4065+CALLBEGIN(1/*nr of chunks returned*/); // SP 8
4066+// SP 12
4067+// VERIFY SP
4068+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4069+CALLEND(0LLU, 0xFFFFFFFFFFFFFEF4LLU, 0xAE08260000000000LLU);
4070+case 0xFFFFFFFFFFFFFEF4LLU:
4071+// SP 8
4072+CALLEND(1LLU, 0xFFFFFFFFFFFFFEF3LLU, 0x92E7E48A4BC00000LLU);
4073+case 0xFFFFFFFFFFFFFEF3LLU:
4074+// SP 3
4075+if(!POP)
4076+// SP 2
4077+ JUMP(0xFFFFFFFFFFFFFEF6LLU); // skip consequent
19824078 // consequent
19834079
1984- PUSH(0); // place-holder for result of block
1985-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4080+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4081+// SP 3
4082+// VERIFY SP
4083+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
19864084 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
19874085
1988- CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(1));
1989-CALLEND(1LLU, 0xFFFFFFFFFFFFFEFELLU, 0xAF0BA37AAA6EBC00LLU);
1990-case 0xFFFFFFFFFFFFFEFELLU:
4086+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
4087+// SP 8
4088+// VERIFY SP
4089+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4090+PUSH(ACCESS_ARG(2));
4091+// SP 9
4092+// VERIFY SP
4093+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4094+CALLEND(1LLU, 0xFFFFFFFFFFFFFEF2LLU, 0xAF0BA37AAA6EBC00LLU);
4095+case 0xFFFFFFFFFFFFFEF2LLU:
4096+// SP 4
19914097
1992- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4098+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4099+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4100+// SP 3
19934101 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
1994- JUMP(0xFFFFFFFFFFFFFF01LLU); // skip alternative
1995-case 0xFFFFFFFFFFFFFF02LLU: // alternative
4102+// SP 2
4103+// VERIFY SP
4104+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4105+ JUMP(0xFFFFFFFFFFFFFEF5LLU); // skip alternative
4106+case 0xFFFFFFFFFFFFFEF6LLU: // alternative
19964107
19974108
1998- PUSH(0); // place-holder for result of block
1999-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4109+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4110+// SP 3
4111+// VERIFY SP
4112+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20004113 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20014114
20024115 // predicate
2003-CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEFBLLU, 0xAE08260000000000LLU);
2004-case 0xFFFFFFFFFFFFFEFBLLU:
2005-CALLEND(1LLU, 0xFFFFFFFFFFFFFEFALLU, 0x92E727AE37000000LLU);
2006-case 0xFFFFFFFFFFFFFEFALLU:
2007-if(!ACCESS_CURRENT)
2008- JUMP(0xFFFFFFFFFFFFFEFDLLU); // skip consequent
4116+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
4117+// SP 8
4118+// VERIFY SP
4119+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4120+CALLBEGIN(1/*nr of chunks returned*/); // SP 9
4121+// SP 13
4122+// VERIFY SP
4123+if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4124+CALLEND(0LLU, 0xFFFFFFFFFFFFFEEFLLU, 0xAE08260000000000LLU);
4125+case 0xFFFFFFFFFFFFFEEFLLU:
4126+// SP 9
4127+CALLEND(1LLU, 0xFFFFFFFFFFFFFEEELLU, 0x92E727AE37000000LLU);
4128+case 0xFFFFFFFFFFFFFEEELLU:
4129+// SP 4
4130+if(!POP)
4131+// SP 3
4132+ JUMP(0xFFFFFFFFFFFFFEF1LLU); // skip consequent
20094133 // consequent
20104134
2011- PUSH(0); // place-holder for result of block
2012-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4135+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4136+// SP 4
4137+// VERIFY SP
4138+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20134139 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20144140
2015- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF9LLU, 0xADCB6E81E7279C00LLU);
2016-case 0xFFFFFFFFFFFFFEF9LLU:
4141+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
4142+// SP 9
4143+// VERIFY SP
4144+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4145+PUSH(ACCESS_ARG(0));
4146+// SP 10
4147+// VERIFY SP
4148+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4149+CALLEND(1LLU, 0xFFFFFFFFFFFFFEEDLLU, 0xADCB6E81E7279C00LLU);
4150+case 0xFFFFFFFFFFFFFEEDLLU:
4151+// SP 5
20174152
2018- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4153+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4154+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4155+// SP 4
20194156 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2020- JUMP(0xFFFFFFFFFFFFFEFCLLU); // skip alternative
2021-case 0xFFFFFFFFFFFFFEFDLLU: // alternative
4157+// SP 3
4158+// VERIFY SP
4159+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4160+ JUMP(0xFFFFFFFFFFFFFEF0LLU); // skip alternative
4161+case 0xFFFFFFFFFFFFFEF1LLU: // alternative
20224162
20234163
2024- PUSH(0); // place-holder for result of block
2025-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4164+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4165+// SP 4
4166+// VERIFY SP
4167+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20264168 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20274169
20284170 // predicate
2029-CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEF6LLU, 0xA1CBDE8EAAEF0000LLU);
2030-case 0xFFFFFFFFFFFFFEF6LLU:
2031-if(!ACCESS_CURRENT)
2032- JUMP(0xFFFFFFFFFFFFFEF8LLU); // skip consequent
4171+CALLBEGIN(1/*nr of chunks returned*/); // SP 5
4172+// SP 9
4173+// VERIFY SP
4174+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4175+PUSH(35LLU);// SP 10
4176+// VERIFY SP
4177+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4178+CALLEND(1LLU, 0xFFFFFFFFFFFFFEEALLU, 0xA1CBDE8EAAEF0000LLU);
4179+case 0xFFFFFFFFFFFFFEEALLU:
4180+// SP 5
4181+if(!POP)
4182+// SP 4
4183+ JUMP(0xFFFFFFFFFFFFFEECLLU); // skip consequent
20334184 // consequent
20344185
2035- PUSH(0); // place-holder for result of block
2036-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4186+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4187+// SP 5
4188+// VERIFY SP
4189+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20374190 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20384191
2039- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF5LLU, 0xAF0BA372D8800000LLU);
2040-case 0xFFFFFFFFFFFFFEF5LLU:
4192+ CALLBEGIN(1/*nr of chunks returned*/); // SP 6
4193+// SP 10
4194+// VERIFY SP
4195+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4196+CALLEND(0LLU, 0xFFFFFFFFFFFFFEE9LLU, 0xAF0BA372D8800000LLU);
4197+case 0xFFFFFFFFFFFFFEE9LLU:
4198+// SP 6
20414199
2042- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4200+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4201+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4202+// SP 5
20434203 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2044- JUMP(0xFFFFFFFFFFFFFEF7LLU); // skip alternative
2045-case 0xFFFFFFFFFFFFFEF8LLU: // alternative
4204+// SP 4
4205+// VERIFY SP
4206+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4207+ JUMP(0xFFFFFFFFFFFFFEEBLLU); // skip alternative
4208+case 0xFFFFFFFFFFFFFEECLLU: // alternative
20464209
20474210
2048- PUSH(0); // place-holder for result of block
2049-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4211+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4212+// SP 5
4213+// VERIFY SP
4214+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20504215 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20514216
20524217 // predicate
2053-CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEF2LLU, 0xA1CBDE8EAAEF0000LLU);
2054-case 0xFFFFFFFFFFFFFEF2LLU:
2055-if(!ACCESS_CURRENT)
2056- JUMP(0xFFFFFFFFFFFFFEF4LLU); // skip consequent
4218+CALLBEGIN(1/*nr of chunks returned*/); // SP 6
4219+// SP 10
4220+// VERIFY SP
4221+if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4222+PUSH(94LLU);// SP 11
4223+// VERIFY SP
4224+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4225+CALLEND(1LLU, 0xFFFFFFFFFFFFFEE6LLU, 0xA1CBDE8EAAEF0000LLU);
4226+case 0xFFFFFFFFFFFFFEE6LLU:
4227+// SP 6
4228+if(!POP)
4229+// SP 5
4230+ JUMP(0xFFFFFFFFFFFFFEE8LLU); // skip consequent
20574231 // consequent
20584232
2059- PUSH(0); // place-holder for result of block
2060-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4233+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4234+// SP 6
4235+// VERIFY SP
4236+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20614237 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20624238
2063- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF1LLU, 0xAF0BA38A7A9D0000LLU);
2064-case 0xFFFFFFFFFFFFFEF1LLU:
4239+ CALLBEGIN(1/*nr of chunks returned*/); // SP 7
4240+// SP 11
4241+// VERIFY SP
4242+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4243+CALLEND(0LLU, 0xFFFFFFFFFFFFFEE5LLU, 0xAF0BA38A7A9D0000LLU);
4244+case 0xFFFFFFFFFFFFFEE5LLU:
4245+// SP 7
20654246
2066- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4247+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4248+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4249+// SP 6
20674250 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2068- JUMP(0xFFFFFFFFFFFFFEF3LLU); // skip alternative
2069-case 0xFFFFFFFFFFFFFEF4LLU: // alternative
4251+// SP 5
4252+// VERIFY SP
4253+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4254+ JUMP(0xFFFFFFFFFFFFFEE7LLU); // skip alternative
4255+case 0xFFFFFFFFFFFFFEE8LLU: // alternative
20704256
20714257
2072- PUSH(0); // place-holder for result of block
2073-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4258+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4259+// SP 6
4260+// VERIFY SP
4261+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20744262 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20754263
20764264 // predicate
2077-CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEEELLU, 0xA1CBDE8EAAEF0000LLU);
2078-case 0xFFFFFFFFFFFFFEEELLU:
2079-if(!ACCESS_CURRENT)
2080- JUMP(0xFFFFFFFFFFFFFEF0LLU); // skip consequent
4265+CALLBEGIN(1/*nr of chunks returned*/); // SP 7
4266+// SP 11
4267+// VERIFY SP
4268+if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4269+PUSH(96LLU);// SP 12
4270+// VERIFY SP
4271+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4272+CALLEND(1LLU, 0xFFFFFFFFFFFFFEE2LLU, 0xA1CBDE8EAAEF0000LLU);
4273+case 0xFFFFFFFFFFFFFEE2LLU:
4274+// SP 7
4275+if(!POP)
4276+// SP 6
4277+ JUMP(0xFFFFFFFFFFFFFEE4LLU); // skip consequent
20814278 // consequent
20824279
2083- PUSH(0); // place-holder for result of block
2084-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4280+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4281+// SP 7
4282+// VERIFY SP
4283+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20854284 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20864285
2087- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEEDLLU, 0xAF0BA3C5CB400000LLU);
2088-case 0xFFFFFFFFFFFFFEEDLLU:
4286+ CALLBEGIN(1/*nr of chunks returned*/); // SP 8
4287+// SP 12
4288+// VERIFY SP
4289+if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4290+CALLEND(0LLU, 0xFFFFFFFFFFFFFEE1LLU, 0xAF0BA3C5CB400000LLU);
4291+case 0xFFFFFFFFFFFFFEE1LLU:
4292+// SP 8
20894293
2090- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4294+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4295+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4296+// SP 7
20914297 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2092- JUMP(0xFFFFFFFFFFFFFEEFLLU); // skip alternative
2093-case 0xFFFFFFFFFFFFFEF0LLU: // alternative
4298+// SP 6
4299+// VERIFY SP
4300+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4301+ JUMP(0xFFFFFFFFFFFFFEE3LLU); // skip alternative
4302+case 0xFFFFFFFFFFFFFEE4LLU: // alternative
20944303
20954304
2096- PUSH(0); // place-holder for result of block
2097-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4305+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4306+// SP 7
4307+// VERIFY SP
4308+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
20984309 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
20994310
21004311 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
21014312 fprintf(stderr, "missing ')' in call???\n");
21024313 exit(-1);
2103- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4314+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4315+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4316+// SP 7
21044317 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2105-case 0xFFFFFFFFFFFFFEEFLLU: // skip to here
4318+// SP 6
4319+// VERIFY SP
4320+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4321+case 0xFFFFFFFFFFFFFEE3LLU: // skip to here
21064322
2107- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4323+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4324+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4325+// SP 6
21084326 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2109-case 0xFFFFFFFFFFFFFEF3LLU: // skip to here
4327+// SP 5
4328+// VERIFY SP
4329+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4330+case 0xFFFFFFFFFFFFFEE7LLU: // skip to here
21104331
2111- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4332+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4333+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4334+// SP 5
21124335 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2113-case 0xFFFFFFFFFFFFFEF7LLU: // skip to here
4336+// SP 4
4337+// VERIFY SP
4338+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4339+case 0xFFFFFFFFFFFFFEEBLLU: // skip to here
21144340
2115- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4341+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4342+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4343+// SP 4
21164344 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2117-case 0xFFFFFFFFFFFFFEFCLLU: // skip to here
4345+// SP 3
4346+// VERIFY SP
4347+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4348+case 0xFFFFFFFFFFFFFEF0LLU: // skip to here
21184349
2119- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4350+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4351+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4352+// SP 3
21204353 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2121-case 0xFFFFFFFFFFFFFF01LLU: // skip to here
4354+// SP 2
4355+// VERIFY SP
4356+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4357+case 0xFFFFFFFFFFFFFEF5LLU: // skip to here
21224358
2123- ACCESS_ARG(1)++;
2124- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEECLLU, 0xBA692B7A8A6FB800LLU);
2125-case 0xFFFFFFFFFFFFFEECLLU:
4359+ ACCESS_ARG(2)++;
4360+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
4361+// SP 7
4362+// VERIFY SP
4363+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4364+CALLEND(0LLU, 0xFFFFFFFFFFFFFEE0LLU, 0xBA692B7A8A6FB800LLU);
4365+case 0xFFFFFFFFFFFFFEE0LLU:
4366+// SP 3
21264367
21274368 // predicate
2128-CALLBEGIN(1/*nr of chunks returned*/); PUSH(44LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEE9LLU, 0xA1CBDE8EAAEF0000LLU);
2129-case 0xFFFFFFFFFFFFFEE9LLU:
2130-if(!ACCESS_CURRENT)
2131- JUMP(0xFFFFFFFFFFFFFEEBLLU); // skip consequent
4369+CALLBEGIN(1/*nr of chunks returned*/); // SP 4
4370+// SP 8
4371+// VERIFY SP
4372+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4373+PUSH(44LLU);// SP 9
4374+// VERIFY SP
4375+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4376+CALLEND(1LLU, 0xFFFFFFFFFFFFFEDDLLU, 0xA1CBDE8EAAEF0000LLU);
4377+case 0xFFFFFFFFFFFFFEDDLLU:
4378+// SP 4
4379+if(!POP)
4380+// SP 3
4381+ JUMP(0xFFFFFFFFFFFFFEDFLLU); // skip consequent
21324382 // consequent
21334383
2134- PUSH(0); // place-holder for result of block
2135-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4384+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4385+// SP 4
4386+// VERIFY SP
4387+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
21364388 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
21374389
2138- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE8LLU, 0xBA692B7A8A6FB800LLU);
2139-case 0xFFFFFFFFFFFFFEE8LLU:
4390+ CALLBEGIN(1/*nr of chunks returned*/); // SP 5
4391+// SP 9
4392+// VERIFY SP
4393+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4394+CALLEND(0LLU, 0xFFFFFFFFFFFFFEDCLLU, 0xBA692B7A8A6FB800LLU);
4395+case 0xFFFFFFFFFFFFFEDCLLU:
4396+// SP 5
21404397
2141- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4398+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4399+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4400+// SP 4
21424401 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2143- JUMP(0xFFFFFFFFFFFFFEEALLU); // skip alternative
2144-case 0xFFFFFFFFFFFFFEEBLLU: // alternative
4402+// SP 3
4403+// VERIFY SP
4404+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4405+ JUMP(0xFFFFFFFFFFFFFEDELLU); // skip alternative
4406+case 0xFFFFFFFFFFFFFEDFLLU: // alternative
21454407
21464408
2147- PUSH(0); // place-holder for result of block
2148-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4409+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4410+// SP 4
4411+// VERIFY SP
4412+if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
21494413 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
21504414
2151- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4415+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4416+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4417+// SP 4
21524418 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2153-case 0xFFFFFFFFFFFFFEEALLU: // skip to here
4419+// SP 3
4420+// VERIFY SP
4421+if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4422+case 0xFFFFFFFFFFFFFEDELLU: // skip to here
21544423
2155- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4424+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4425+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4426+// SP 2
21564427 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2157- JUMP(0xFFFFFFFFFFFFFF06LLU); // loop
2158-case 0xFFFFFFFFFFFFFF05LLU: // skip to here
4428+// SP 1
4429+// VERIFY SP
4430+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4431+ JUMP(0xFFFFFFFFFFFFFEFALLU); // loop
4432+case 0xFFFFFFFFFFFFFEF9LLU: // skip to here
21594433
2160- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4434+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4435+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4436+// SP 1
21614437 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2162- JUMP(0xFFFFFFFFFFFFFF08LLU); // skip alternative
2163-case 0xFFFFFFFFFFFFFF09LLU: // alternative
4438+// SP 0
4439+// VERIFY SP
4440+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4441+ JUMP(0xFFFFFFFFFFFFFEFCLLU); // skip alternative
4442+case 0xFFFFFFFFFFFFFEFDLLU: // alternative
21644443
21654444
2166- PUSH(0); // place-holder for result of block
2167-PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4445+ PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block
4446+// SP 1
4447+// VERIFY SP
4448+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
21684449 stack$$$[BLKINF_IDX] = sp$$$; // store base of current block
21694450
21704451 fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);
21714452 fprintf(stderr, "missing '(' in call\n");
21724453 exit(-1);
2173- if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4454+ if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }
4455+sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block
4456+// SP 1
21744457 stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block
2175-case 0xFFFFFFFFFFFFFF08LLU: // skip to here
4458+// SP 0
4459+// VERIFY SP
4460+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4461+case 0xFFFFFFFFFFFFFEFCLLU: // skip to here
21764462
21774463
2178- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE7LLU, 0xBA692B0000000000LLU);
2179-case 0xFFFFFFFFFFFFFEE7LLU:
4464+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
4465+// SP 5
4466+// VERIFY SP
4467+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4468+CALLEND(0LLU, 0xFFFFFFFFFFFFFEDBLLU, 0xBA692B0000000000LLU);
4469+case 0xFFFFFFFFFFFFFEDBLLU:
4470+// SP 1
21804471
4472+
21814473 fprintf(stdout, "CALLEND(");
2182- CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(1));
2183-CALLEND(1LLU, 0xFFFFFFFFFFFFFEE6LLU, 0xAED929BE9B400000LLU);
2184-case 0xFFFFFFFFFFFFFEE6LLU:
4474+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
4475+// SP 6
4476+// VERIFY SP
4477+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4478+PUSH(ACCESS_ARG(2));
4479+// SP 7
4480+// VERIFY SP
4481+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4482+CALLEND(1LLU, 0xFFFFFFFFFFFFFEDALLU, 0xAED929BE9B400000LLU);
4483+case 0xFFFFFFFFFFFFFEDALLU:
4484+// SP 2
21854485 // number of arguments
21864486 fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value
4487+ // SP is zero here but no need to use & can't verify - position not reached (because of break):
21874488 fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58);
4489+ SP_SET(ACCESS_ARG(0)); // restore stack to pre-call state
21884490 RET;
21894491
21904492
2191-case /*prologue__*/0xAEDAA7AA2C200000LLU:
4493+case /*prologue__*/0xAEDAA7AA2C200000LLU:// SP 0
4494+// VERIFY SP
4495+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
21924496
2193- if(sp$$$ != 0LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 0\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;
2194- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE5LLU, 0xADCB6E829B400000LLU);
2195-case 0xFFFFFFFFFFFFFEE5LLU:
4497+
4498+ if(sp$$$ != 0LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 0\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;
4499+// SP 1
4500+// VERIFY SP
4501+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4502+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
4503+// SP 6
4504+// VERIFY SP
4505+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4506+CALLEND(0LLU, 0xFFFFFFFFFFFFFED9LLU, 0xADCB6E829B400000LLU);
4507+case 0xFFFFFFFFFFFFFED9LLU:
4508+// SP 2
21964509 stack$$$[sb$$$ + 0LLU] = POP;
4510+// SP 1
4511+// VERIFY SP
4512+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
21974513 // memory size
2198- if(sp$$$ != 1LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 1\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;
2199- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE4LLU, 0xADCB6E829B400000LLU);
2200-case 0xFFFFFFFFFFFFFEE4LLU:
4514+ if(sp$$$ != 1LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 1\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;
4515+// SP 2
4516+// VERIFY SP
4517+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4518+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
4519+// SP 7
4520+// VERIFY SP
4521+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4522+CALLEND(0LLU, 0xFFFFFFFFFFFFFED8LLU, 0xADCB6E829B400000LLU);
4523+case 0xFFFFFFFFFFFFFED8LLU:
4524+// SP 3
22014525 stack$$$[sb$$$ + 1LLU] = POP;
4526+// SP 2
4527+// VERIFY SP
4528+if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22024529 // global count
22034530
22044531 stack$$$[GLOBMAX_IDX] = ACCESS_VAR(1);
@@ -2231,11 +4558,20 @@
22314558 fputs("#define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, \"returned to 0x%0llXLLU\\n\", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; }\n", stdout);
22324559 fputs("#define ADDR stack$$$[ADDR_IDX]\n", stdout);
22334560 fputs("\n", stdout);
4561+ fputs("uint64_t SP = 0;\n", stdout);
4562+ fputs("void SP_TRACK() { fprintf(stdout, \"// SP %llu\\n\", (long long unsigned int)SP); }\n", stdout);
4563+ fputs("void SP_VERIFY() { fprintf(stdout, \"// VERIFY SP\\nif(sp$$$ != %lluLLU) { fprintf(stderr, \\\"verify failed, sp %cllu != %llu SP in line %cd\\\\n\\\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\\n\", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); }\n", stdout);
4564+ fputs("uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout);
4565+ fputs("uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; }\n", stdout);
4566+ fputs("uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout);
4567+ fputs("uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; }\n", stdout);
4568+ fputs("\n", stdout);
22344569 fputs("int32_t main()\n", stdout);
22354570 fputs("{\n", stdout);
22364571 fprintf(stdout, " uint64_t *stack$$$ = malloc(8 * %lluLLU);\n", (long long unsigned int)ACCESS_VAR(0));
22374572 fprintf(stdout, " register uint64_t sb$$$ = %llu; // skip space reserved for globals\n", (long long unsigned int)stack$$$[GLOBMAX_IDX]); // stack base
22384573 fputs(" register uint64_t sp$$$ = 0;\n", stdout); // function-LOCAL stack pointer
4574+ SP_SET_VERIFY(0);
22394575 fputs(" register uint64_t sz$$$ = 0;\n", stdout); // number of arguments (without return-value)
22404576 fputs(" register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol\n", stdout);
22414577 fputs(" register uint64_t c$$$;\n", stdout);
@@ -2248,8 +4584,11 @@
22484584 RET;
22494585
22504586
2251-case /*epilogue__*/0x82B927AA2C200000LLU:
4587+case /*epilogue__*/0x82B927AA2C200000LLU:// SP 0
4588+// VERIFY SP
4589+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22524590
4591+
22534592
22544593 fprintf(stdout, " default%c\n", 58);
22554594 fputs(" fn$$$ = ~0;\n", stdout);
@@ -2265,36 +4604,88 @@
22654604 RET;
22664605
22674606
2268-case /*main______*/0xA1C9290000000000LLU:
4607+case /*main______*/0xA1C9290000000000LLU:// SP 0
4608+// VERIFY SP
4609+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22694610
4611+
22704612 // initialize globals
22714613 // ^0 DON'T touch limit of global variables - stack-pointer already set!
22724614 //^1=0 // XXX THIS FAILS - WHY?! XXX
2273- CALLBEGIN(1/*nr of chunks returned*/); PUSH(0LLU);PUSH(1LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFEE3LLU, 0xBB07400000000000LLU);
2274-case 0xFFFFFFFFFFFFFEE3LLU:
4615+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
4616+// SP 5
4617+// VERIFY SP
4618+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4619+PUSH(0LLU);// SP 6
4620+// VERIFY SP
4621+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4622+PUSH(1LLU);// SP 7
4623+// VERIFY SP
4624+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4625+CALLEND(2LLU, 0xFFFFFFFFFFFFFED7LLU, 0xBB07400000000000LLU);
4626+case 0xFFFFFFFFFFFFFED7LLU:
4627+// SP 1
22754628 stack$$$[1LLU] = POP;
4629+// SP 0
4630+// VERIFY SP
4631+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22764632 // internal address counter for automatically generated labels (marks) starting from highest inaccessible label FFFFFFFFFFFFFFFF encoding "9999999999" counting down to smallest inaccessible label D800000000000000 encoding "0000000000" decrementing without check because we will run out of memory long before we run out of labels
22774633 PUSH(0LLU);
4634+// SP 1
4635+// VERIFY SP
4636+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22784637 stack$$$[2LLU] = POP;
4638+// SP 0
4639+// VERIFY SP
4640+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22794641 // information of current block
22804642 PUSH(0LLU);
4643+// SP 1
4644+// VERIFY SP
4645+if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22814646 stack$$$[3LLU] = POP;
4647+// SP 0
4648+// VERIFY SP
4649+if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
22824650 // line-number
22834651
2284- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE2LLU, 0xAEDAA7AA2C200000LLU);
2285-case 0xFFFFFFFFFFFFFEE2LLU:
4652+ CALLBEGIN(1/*nr of chunks returned*/); // SP 1
4653+// SP 5
4654+// VERIFY SP
4655+if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4656+CALLEND(0LLU, 0xFFFFFFFFFFFFFED6LLU, 0xAEDAA7AA2C200000LLU);
4657+case 0xFFFFFFFFFFFFFED6LLU:
4658+// SP 1
22864659
22874660
2288- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE1LLU, 0xADCB6E821A6E0000LLU);
2289-case 0xFFFFFFFFFFFFFEE1LLU:
4661+ CALLBEGIN(1/*nr of chunks returned*/); // SP 2
4662+// SP 6
4663+// VERIFY SP
4664+if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4665+CALLEND(0LLU, 0xFFFFFFFFFFFFFED5LLU, 0xADCB6E821A6E0000LLU);
4666+case 0xFFFFFFFFFFFFFED5LLU:
4667+// SP 2
22904668
22914669
2292- CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE0LLU, 0x82B927AA2C200000LLU);
2293-case 0xFFFFFFFFFFFFFEE0LLU:
4670+ CALLBEGIN(1/*nr of chunks returned*/); // SP 3
4671+// SP 7
4672+// VERIFY SP
4673+if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4674+CALLEND(0LLU, 0xFFFFFFFFFFFFFED4LLU, 0x82B927AA2C200000LLU);
4675+case 0xFFFFFFFFFFFFFED4LLU:
4676+// SP 3
22944677
22954678
2296- CALLBEGIN(1/*nr of chunks returned*/); PUSH(0LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEDFLLU, 0x83392F0000000000LLU);
2297-case 0xFFFFFFFFFFFFFEDFLLU:
4679+ CALLBEGIN(1/*nr of chunks returned*/); // SP 4
4680+// SP 8
4681+// VERIFY SP
4682+if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4683+PUSH(0LLU);// SP 9
4684+// VERIFY SP
4685+if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); }
4686+CALLEND(1LLU, 0xFFFFFFFFFFFFFED3LLU, 0x83392F0000000000LLU);
4687+case 0xFFFFFFFFFFFFFED3LLU:
4688+// SP 4
22984689
22994690 RET;
23004691
--- trunk/experimental/compiler.source.c (revision 147)
+++ trunk/experimental/compiler.source.c (revision 148)
@@ -195,6 +195,7 @@
195195 :fprintf(stdout, "PUSH(");:
196196 echonr()
197197 :fprintf(stdout, "LLU);\n");:
198+ :SP_ADD_VERIFY(1);:
198199 }
199200 else
200201 {
@@ -216,9 +217,18 @@
216217 }
217218 else
218219 {
219- :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
220- :fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));:
221- :exit(-1);:
220+ ? matchopt(40)
221+ {
222+ parseexpr(#0)
223+ skipcmnts()
224+ match(41)
225+ }
226+ else
227+ {
228+ :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
229+ :fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));:
230+ :exit(-1);:
231+ }
222232 }
223233 }
224234 }
@@ -230,7 +240,7 @@
230240 {
231241 skipcmnts()
232242 match(61)
233- parseexpr()
243+ parseexpr(#0)
234244 }
235245
236246 assignglob
@@ -248,9 +258,10 @@
248258 exit(-1);
249259 }:
250260
251- parseexpr'()
261+ parseexpr'(#0)
252262
253263 :fprintf(stdout, "stack$$$[%lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);:
264+ :SP_ADD_VERIFY(-1);:
254265 }
255266
256267 assignvar
@@ -258,9 +269,10 @@
258269 :ACCESS_RETURN = 0;:
259270 ? matchopt(96)
260271 {
261- parseexpr'()
272+ parseexpr'(#0)
262273
263274 :fprintf(stdout, "ACCESS_RETURN = POP;\n");:
275+ :SP_ADD_VERIFY(-1);:
264276 }
265277 else
266278 {
@@ -269,11 +281,13 @@
269281 :ACCESS_RETURN *= 10;:
270282 :ACCESS_RETURN += fgetc(stdin) - '0';: // XXX use get
271283 }
272- :fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);:
284+ :fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);:
285+ :SP_ADD_VERIFY(1);:
273286
274- parseexpr'()
287+ parseexpr'(#0)
275288
276289 :fprintf(stdout, "stack$$$[sb$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);:
290+ :SP_ADD_VERIFY(-1);:
277291 }
278292 }
279293
@@ -284,9 +298,10 @@
284298 {
285299 skip()
286300
287- parseexpr'()
301+ parseexpr'(#0)
288302
289303 :fprintf(stdout, "ACCESS_RETURN = POP;\n");:
304+ :SP_ADD_VERIFY(-1);:
290305 }
291306 else
292307 {
@@ -295,11 +310,11 @@
295310 :ACCESS_RETURN *= 10;:
296311 :ACCESS_RETURN += fgetc(stdin) - '0';: // XXX use get
297312 }
298- :fprintf(stdout, "if(sp$$$ != %lluLLU) { fprintf(stderr, \"ARG SP %cllu != %llu\\n\", (long long unsigned int)sp$$$); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);:
299313
300- parseexpr'()
314+ parseexpr'(#0)
301315
302316 :fprintf(stdout, "stack$$$[sb$$$ - sz$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);:
317+ :SP_ADD_VERIFY(-1);:
303318 }
304319 }
305320
@@ -337,6 +352,7 @@
337352 :fprintf(stdout, "PUSH(");:
338353 parseglob()
339354 :fprintf(stdout, ");\n");:
355+ :SP_ADD_VERIFY(1);:
340356 }
341357
342358 pushvar
@@ -346,6 +362,7 @@
346362 :fprintf(stdout, "PUSH(");:
347363 parsevar()
348364 :fprintf(stdout, ");\n");:
365+ :SP_ADD_VERIFY(1);:
349366 }
350367
351368 pusharg
@@ -355,6 +372,7 @@
355372 :fprintf(stdout, "PUSH(");:
356373 parsearg()
357374 :fprintf(stdout, ");\n");:
375+ :SP_ADD_VERIFY(1);:
358376 }
359377
360378 pushconst
@@ -364,6 +382,7 @@
364382 :fprintf(stdout, "PUSH(");:
365383 echonr()
366384 :fputs("LLU);", stdout);:
385+ :SP_ADD_VERIFY(1);/*SP_VERIFY();*/:
367386 }
368387
369388 parsechar
@@ -580,7 +599,7 @@
580599 {
581600 ? isalpha(peek())
582601 {
583- parsecall()
602+ parsecall(#0)
584603 }
585604 else
586605 {
@@ -592,51 +611,77 @@
592611 {
593612 ? matchopt(123)
594613 {
595- parseblock()
614+ parseblock(#0)
596615 }
597616 else
598617 {
599618 ? matchopt(64)
600619 {
601- parsewhile()
620+ parsewhile(#0)
602621 }
603622 else
604623 {
605624 ? matchopt(63)
606625 {
607- parseif()
626+ parseif(#0)
608627 }
609628 else
610629 {
611- ? matchopt(96)
630+ ? matchopt(95)
612631 {
613- assignvar()
632+ skipcmnts()
633+ match(61)
634+ parseexpr(#0)
635+ :fprintf(stdout, "(void)POP;\n");:
636+ :SP_ADD_VERIFY(-1);:
614637 }
615638 else
616639 {
617- ? matchopt(94)
640+ ? matchopt(96)
618641 {
619- assignglob()
642+ assignvar(#0)
620643 }
621644 else
622645 {
623- ? matchopt(35)
646+ ? matchopt(94)
624647 {
625- assignarg()
648+ assignglob(#0)
626649 }
627650 else
628651 {
629- ? matchopt(47)
652+ ? matchopt(35)
630653 {
654+ assignarg(#0)
655+ }
656+ else
657+ {
631658 ? matchopt(47)
632659 {
633- comment()
660+ ? matchopt(47)
661+ {
662+ comment()
663+ }
664+ else
665+ {
666+ ? matchopt(42)
667+ {
668+ comment'()
669+ }
670+ else
671+ {
672+ :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
673+ :fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin));: // XXX use get
674+ :exit(-1);:
675+ }
676+ }
634677 }
635678 else
636679 {
637- ? matchopt(42)
680+ ? matchopt(125)
638681 {
639- comment'()
682+ :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
683+ :fprintf(stderr, "superfluous closing curly brace '}'\n");:
684+ :exit(-1);:
640685 }
641686 else
642687 {
@@ -646,21 +691,6 @@
646691 }
647692 }
648693 }
649- else
650- {
651- ? matchopt(125)
652- {
653- :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
654- :fprintf(stderr, "superfluous closing curly brace '}'\n");:
655- :exit(-1);:
656- }
657- else
658- {
659- :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);:
660- :fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin));: // XXX use get
661- :exit(-1);:
662- }
663- }
664694 }
665695 }
666696 }
@@ -676,17 +706,22 @@
676706
677707 parseblock
678708 {
679- :fprintf(stdout, "PUSH(0); // place-holder for result of block\n");:
709+ //:fprintf(stdout, "PUSH(0); // place-holder for result of block\n");:
710+ //:SP_ADD_VERIFY(1);:
680711 :fprintf(stdout, "PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block\n");:
712+ :SP_ADD_VERIFY(1);:
713+ :ACCESS_RETURN = SP;: // HACK store estimate in return
681714 :fprintf(stdout, "stack$$$[BLKINF_IDX] = sp$$$; // store base of current block\n");:
682715 ://fprintf(stdout, "fprintf(stderr, \"STORE %llu\\\n\", (long long unsigned int)sp$$$);\n");:
683716
684- parsebody()
717+ parsebody(#0)
685718
686- :fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }");:
719+ :fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }\n");:
687720 :fprintf(stdout, "sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block\n");:
721+ :SP_SET(ACCESS_RETURN);:
688722 ://fprintf(stdout, "fprintf(stderr, "RETRIEVE %llu\n", (long long unsigned int)sp$$$);\n");:
689723 :fprintf(stdout, "stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block\n");:
724+ :SP_ADD_VERIFY(-1);:
690725 }
691726
692727 parsefnnew
@@ -704,9 +739,10 @@
704739
705740 parsefn
706741 {
742+ :SP_SET_VERIFY(0);:
707743 skipcmnts()
708744 match(123)
709- parsebody()
745+ parsebody(0)
710746 :fputs("RET;\n", stdout);:
711747 }
712748
@@ -758,13 +794,13 @@
758794 :ACCESS_RETURN = --ADDR; // HACK store addr in return:
759795 skipcmnts()
760796 :fprintf(stdout, "// predicate\n");:
761- parseexpr()
762- :fprintf(stdout, "if(!ACCESS_CURRENT)\n");:
797+ parseexpr(#0)
798+ :fprintf(stdout, "if(!POP)\n");: :SP_ADD(-1);: // XXX VERIFY CRASHES HERE XXX
763799 :fprintf(stdout, " JUMP(0x%0llXLLU); // skip loop\n", (long long unsigned int)ACCESS_RETURN);:
764800 :fprintf(stdout, "// loop\n");:
765801 skipcmnts()
766802 match(123)
767- parseblock()
803+ parseblock(#0)
768804 :fprintf(stdout, " JUMP(0x%0llXLLU); // loop\n", (long long unsigned int)ACCESS_RETURN + 1);:
769805 :fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);:
770806 }
@@ -776,13 +812,13 @@
776812 :ACCESS_RETURN = ADDR; // HACK store addr in return:
777813 skipcmnts()
778814 :fprintf(stdout, "// predicate\n");:
779- parseexpr()
780- :fprintf(stdout, "if(!ACCESS_CURRENT)\n");:
815+ parseexpr(#0)
816+ :fprintf(stdout, "if(!POP)\n");: :SP_ADD(-1);: // XXX VERIFY CRASHES HERE XXX
781817 :fprintf(stdout, " JUMP(0x%0llXLLU); // skip consequent\n", (long long unsigned int)ACCESS_RETURN + 1);:
782818 :fprintf(stdout, "// consequent\n");:
783819 skipcmnts()
784820 match(123)
785- parseblock()
821+ parseblock(#0)
786822 :fprintf(stdout, " JUMP(0x%0llXLLU); // skip alternative\n", (long long unsigned int)ACCESS_RETURN);:
787823 :fprintf(stdout, "case 0x%0llXLLU%c // alternative\n", (long long unsigned int)ACCESS_RETURN + 1, 58);:
788824 skipcmnts()
@@ -796,7 +832,7 @@
796832 skipcmnts()
797833 ? matchopt(123)
798834 {
799- parseblock()
835+ parseblock(#0)
800836 :fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);:
801837 }
802838 else
@@ -814,14 +850,17 @@
814850
815851 parsecall
816852 {
817- parsecall2(parseid(),0)
853+ parsecall2(#0,parseid(),0)
818854 }
819855
820856 parsecall2
821857 {
822- :ACCESS_RETURN = ACCESS_ARG(0); // HACK store id in return value:
858+ :ACCESS_RETURN = ACCESS_ARG(1); // HACK store id in return value:
823859
824860 :fputs("CALLBEGIN(1/*nr of chunks returned*/); ", stdout); // NOTE do NOT enclose in block because a case-label can appear inbetween if nested call:
861+ :SP_ADD(1);:
862+ :ACCESS_ARG(0) = SP; // XXX HACK store estimate in argument XXX:
863+ :SP_ADD_VERIFY(4);:
825864
826865 ? matchopt(40)
827866 {
@@ -829,13 +868,13 @@
829868 {
830869 ? isdigit(peek())
831870 {
832- pushconst(#1)
871+ pushconst(#2)
833872 }
834873 else
835874 {
836875 ? isalpha(peek())
837876 {
838- parsecall()
877+ parsecall(#0)
839878 }
840879 else
841880 {
@@ -865,7 +904,7 @@
865904 }
866905 }
867906 }
868- :ACCESS_ARG(1)++;:
907+ :ACCESS_ARG(2)++;:
869908 skipcmnts()
870909 ? matchopt(44)
871910 {
@@ -884,10 +923,13 @@
884923 }
885924
886925 skip()
926+
887927 :fprintf(stdout, "CALLEND(");:
888- printnr(#1) // number of arguments
889- :fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value
890- fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58);:
928+ printnr(#2) // number of arguments
929+ :fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value:
930+ // SP is zero here but no need to use & can't verify - position not reached (because of break):
931+ :fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58);:
932+ :SP_SET(ACCESS_ARG(0)); // restore stack to pre-call state:
891933 }
892934
893935 prologue
@@ -925,11 +967,20 @@
925967 fputs("#define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, \"returned to 0x%0llXLLU\\n\", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; }\n", stdout);
926968 fputs("#define ADDR stack$$$[ADDR_IDX]\n", stdout);
927969 fputs("\n", stdout);
970+ fputs("uint64_t SP = 0;\n", stdout);
971+ fputs("void SP_TRACK() { fprintf(stdout, \"// SP %llu\\n\", (long long unsigned int)SP); }\n", stdout);
972+ fputs("void SP_VERIFY() { fprintf(stdout, \"// VERIFY SP\\nif(sp$$$ != %lluLLU) { fprintf(stderr, \\\"verify failed, sp %cllu != %llu SP in line %cd\\\\n\\\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\\n\", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); }\n", stdout);
973+ fputs("uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout);
974+ fputs("uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; }\n", stdout);
975+ fputs("uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout);
976+ fputs("uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; }\n", stdout);
977+ fputs("\n", stdout);
928978 fputs("int32_t main()\n", stdout);
929979 fputs("{\n", stdout);
930980 fprintf(stdout, " uint64_t *stack$$$ = malloc(8 * %lluLLU);\n", (long long unsigned int)ACCESS_VAR(0));
931981 fprintf(stdout, " register uint64_t sb$$$ = %llu; // skip space reserved for globals\n", (long long unsigned int)stack$$$[GLOBMAX_IDX]); // stack base
932982 fputs(" register uint64_t sp$$$ = 0;\n", stdout); // function-LOCAL stack pointer
983+ SP_SET_VERIFY(0);
933984 fputs(" register uint64_t sz$$$ = 0;\n", stdout); // number of arguments (without return-value)
934985 fputs(" register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol\n", stdout);
935986 fputs(" register uint64_t c$$$;\n", stdout);
Afficher sur ancien navigateur de dépôt.