• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revisão1169 (tree)
Hora2021-02-24 06:01:40
Autorjakobthomsen

Mensagem de Log

fix memory-leak on exception in if-pop construct

Mudança Sumário

Diff

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1168)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1169)
@@ -22929,7 +22929,7 @@
2292922929 }
2293022930 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0])
2293122931 {
22932- label = 1897LLU; // jump to alternative
22932+ label = 1898LLU; // jump to alternative
2293322933 break;
2293422934 }
2293522935
@@ -22939,7 +22939,7 @@
2293922939 // case
2294022940 if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0])
2294122941 {
22942- label = 1900LLU; // jump to alternative
22942+ label = 1901LLU; // jump to alternative
2294322943 break;
2294422944 }
2294522945
@@ -22950,7 +22950,7 @@
2295022950 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2295122951 if(!newstack)
2295222952 {
22953- label = 1901LLU; // throw: begin to unroll stack
22953+ label = 1902LLU; // throw: begin to unroll stack
2295422954 break;
2295522955 }
2295622956
@@ -22957,9 +22957,9 @@
2295722957 newstack[15LLU] = 9876543210LLU; // overflow-marker
2295822958 // call equtype from ProcCall
2295922959 newstack[0] = (uint64_t)stack; // backup stack location
22960- newstack[1] = 1902LLU;
22960+ newstack[1] = 1903LLU;
2296122961 newstack[2] = base;
22962- newstack[3] = 1903LLU;
22962+ newstack[3] = 1904LLU;
2296322963 // arguments for call to equtype
2296422964 newstack[5LLU] = stack[base + 39]/*dsttype*/;
2296522965 newstack[6LLU] = stack[base + 41]/*srctype*/;
@@ -22969,7 +22969,7 @@
2296922969 label = 342LLU; // equtype
2297022970 break;
2297122971 }
22972- case 1902LLU: // copy-back deleter (equtype to ProcCall)
22972+ case 1903LLU: // copy-back deleter (equtype to ProcCall)
2297322973 {
2297422974 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2297522975 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -22981,10 +22981,10 @@
2298122981 }
2298222982 Free(15LLU + 1, sizeof(uint64_t), stack);
2298322983 stack = oldstack;
22984- label = 1901LLU; // continue to unroll stack
22984+ label = 1902LLU; // continue to unroll stack
2298522985 break;
2298622986 }
22987- case 1903LLU: // return from equtype to ProcCall
22987+ case 1904LLU: // return from equtype to ProcCall
2298822988 {
2298922989 uint64_t *oldstack = (uint64_t *)stack[0];
2299022990 // copy mutable arguments back from call to equtype
@@ -22999,21 +22999,21 @@
2299922999 stack = oldstack;
2300023000 if(!stack[base + 18]/*isequal*/)
2300123001 {
23002- label = 1904LLU; // jump to alternative
23002+ label = 1905LLU; // jump to alternative
2300323003 break;
2300423004 }
2300523005
2300623006 // consequent
23007- label = 1905LLU; // consequent complete
23007+ label = 1906LLU; // consequent complete
2300823008 break;
2300923009 }
23010- case 1904LLU: // alternative
23010+ case 1905LLU: // alternative
2301123011 {
2301223012 fprintf(stderr, "%s", "in function ");
2301323013 // call reportid from ProcCall
23014- stack[base + 43LLU] = 1906LLU/*throw to this address*/;
23014+ stack[base + 43LLU] = 1907LLU/*throw to this address*/;
2301523015 stack[base + 44LLU] = base;
23016- stack[base + 45LLU] = 1907LLU;
23016+ stack[base + 45LLU] = 1908LLU;
2301723017 // arguments for call to reportid
2301823018 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2301923019 // set stack-base & callee-address
@@ -23021,21 +23021,21 @@
2302123021 label = 18446744073709551586LLU; // reportid
2302223022 break;
2302323023 }
23024- case 1906LLU: // copy-back deleter (reportid to ProcCall)
23024+ case 1907LLU: // copy-back deleter (reportid to ProcCall)
2302523025 {
2302623026 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2302723027 // copy mutable arguments back from call to reportid
23028- label = 1901LLU; // continue to roll stack
23028+ label = 1902LLU; // continue to roll stack
2302923029 break;
2303023030 }
23031- case 1907LLU: // return from reportid to ProcCall
23031+ case 1908LLU: // return from reportid to ProcCall
2303223032 {
2303323033 // copy mutable arguments back from call to reportid
2303423034 fprintf(stderr, "%s", " call to ");
2303523035 // call reportid from ProcCall
23036- stack[base + 43LLU] = 1908LLU/*throw to this address*/;
23036+ stack[base + 43LLU] = 1909LLU/*throw to this address*/;
2303723037 stack[base + 44LLU] = base;
23038- stack[base + 45LLU] = 1909LLU;
23038+ stack[base + 45LLU] = 1910LLU;
2303923039 // arguments for call to reportid
2304023040 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2304123041 // set stack-base & callee-address
@@ -23043,21 +23043,21 @@
2304323043 label = 18446744073709551586LLU; // reportid
2304423044 break;
2304523045 }
23046- case 1908LLU: // copy-back deleter (reportid to ProcCall)
23046+ case 1909LLU: // copy-back deleter (reportid to ProcCall)
2304723047 {
2304823048 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2304923049 // copy mutable arguments back from call to reportid
23050- label = 1901LLU; // continue to roll stack
23050+ label = 1902LLU; // continue to roll stack
2305123051 break;
2305223052 }
23053- case 1909LLU: // return from reportid to ProcCall
23053+ case 1910LLU: // return from reportid to ProcCall
2305423054 {
2305523055 // copy mutable arguments back from call to reportid
2305623056 fprintf(stderr, "%s", " at position ");
2305723057 // call reportnr from ProcCall
23058- stack[base + 43LLU] = 1910LLU/*throw to this address*/;
23058+ stack[base + 43LLU] = 1911LLU/*throw to this address*/;
2305923059 stack[base + 44LLU] = base;
23060- stack[base + 45LLU] = 1911LLU;
23060+ stack[base + 45LLU] = 1912LLU;
2306123061 // arguments for call to reportnr
2306223062 stack[base + 46LLU] = stack[base + 32]/*index*/;
2306323063 // set stack-base & callee-address
@@ -23065,14 +23065,14 @@
2306523065 label = 18446744073709551589LLU; // reportnr
2306623066 break;
2306723067 }
23068- case 1910LLU: // copy-back deleter (reportnr to ProcCall)
23068+ case 1911LLU: // copy-back deleter (reportnr to ProcCall)
2306923069 {
2307023070 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2307123071 // copy mutable arguments back from call to reportnr
23072- label = 1901LLU; // continue to roll stack
23072+ label = 1902LLU; // continue to roll stack
2307323073 break;
2307423074 }
23075- case 1911LLU: // return from reportnr to ProcCall
23075+ case 1912LLU: // return from reportnr to ProcCall
2307623076 {
2307723077 // copy mutable arguments back from call to reportnr
2307823078 fprintf(stderr, "%s", " cannot return source of type ");
@@ -23079,7 +23079,7 @@
2307923079 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2308023080 if(!newstack)
2308123081 {
23082- label = 1901LLU; // throw: begin to unroll stack
23082+ label = 1902LLU; // throw: begin to unroll stack
2308323083 break;
2308423084 }
2308523085
@@ -23086,9 +23086,9 @@
2308623086 newstack[10LLU] = 9876543210LLU; // overflow-marker
2308723087 // call reporttype from ProcCall
2308823088 newstack[0] = (uint64_t)stack; // backup stack location
23089- newstack[1] = 1912LLU;
23089+ newstack[1] = 1913LLU;
2309023090 newstack[2] = base;
23091- newstack[3] = 1913LLU;
23091+ newstack[3] = 1914LLU;
2309223092 // arguments for call to reporttype
2309323093 newstack[4LLU] = stack[base + 41]/*srctype*/;
2309423094 stack = newstack;
@@ -23097,7 +23097,7 @@
2309723097 label = 316LLU; // reporttype
2309823098 break;
2309923099 }
23100- case 1912LLU: // copy-back deleter (reporttype to ProcCall)
23100+ case 1913LLU: // copy-back deleter (reporttype to ProcCall)
2310123101 {
2310223102 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2310323103 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -23109,10 +23109,10 @@
2310923109 }
2311023110 Free(10LLU + 1, sizeof(uint64_t), stack);
2311123111 stack = oldstack;
23112- label = 1901LLU; // continue to unroll stack
23112+ label = 1902LLU; // continue to unroll stack
2311323113 break;
2311423114 }
23115- case 1913LLU: // return from reporttype to ProcCall
23115+ case 1914LLU: // return from reporttype to ProcCall
2311623116 {
2311723117 uint64_t *oldstack = (uint64_t *)stack[0];
2311823118 // copy mutable arguments back from call to reporttype
@@ -23127,7 +23127,7 @@
2312723127 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2312823128 if(!newstack)
2312923129 {
23130- label = 1901LLU; // throw: begin to unroll stack
23130+ label = 1902LLU; // throw: begin to unroll stack
2313123131 break;
2313223132 }
2313323133
@@ -23134,9 +23134,9 @@
2313423134 newstack[10LLU] = 9876543210LLU; // overflow-marker
2313523135 // call reporttype from ProcCall
2313623136 newstack[0] = (uint64_t)stack; // backup stack location
23137- newstack[1] = 1914LLU;
23137+ newstack[1] = 1915LLU;
2313823138 newstack[2] = base;
23139- newstack[3] = 1915LLU;
23139+ newstack[3] = 1916LLU;
2314023140 // arguments for call to reporttype
2314123141 newstack[4LLU] = stack[base + 39]/*dsttype*/;
2314223142 stack = newstack;
@@ -23145,7 +23145,7 @@
2314523145 label = 316LLU; // reporttype
2314623146 break;
2314723147 }
23148- case 1914LLU: // copy-back deleter (reporttype to ProcCall)
23148+ case 1915LLU: // copy-back deleter (reporttype to ProcCall)
2314923149 {
2315023150 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2315123151 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -23157,10 +23157,10 @@
2315723157 }
2315823158 Free(10LLU + 1, sizeof(uint64_t), stack);
2315923159 stack = oldstack;
23160- label = 1901LLU; // continue to unroll stack
23160+ label = 1902LLU; // continue to unroll stack
2316123161 break;
2316223162 }
23163- case 1915LLU: // return from reporttype to ProcCall
23163+ case 1916LLU: // return from reporttype to ProcCall
2316423164 {
2316523165 uint64_t *oldstack = (uint64_t *)stack[0];
2316623166 // copy mutable arguments back from call to reporttype
@@ -23173,16 +23173,16 @@
2317323173 stack = oldstack;
2317423174 fprintf(stderr, "%s", "\n");
2317523175 exit(-1);
23176- label = 1905LLU; // alternative complete
23176+ label = 1906LLU; // alternative complete
2317723177 break;
2317823178 }
23179- case 1905LLU: // completed if-then-else
23179+ case 1906LLU: // completed if-then-else
2318023180 {
2318123181 stack[base + 30]/*sum*/ = 0;
2318223182 // call add from ProcCall
23183- stack[base + 43LLU] = 1916LLU/*throw to this address*/;
23183+ stack[base + 43LLU] = 1917LLU/*throw to this address*/;
2318423184 stack[base + 44LLU] = base;
23185- stack[base + 45LLU] = 1917LLU;
23185+ stack[base + 45LLU] = 1918LLU;
2318623186 // arguments for call to add
2318723187 stack[base + 47LLU] = 4LLU;
2318823188 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -23191,22 +23191,22 @@
2319123191 label = 18446744073709551605LLU; // add
2319223192 break;
2319323193 }
23194- case 1916LLU: // copy-back deleter (add to ProcCall)
23194+ case 1917LLU: // copy-back deleter (add to ProcCall)
2319523195 {
2319623196 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2319723197 // copy mutable arguments back from call to add
23198- label = 1901LLU; // continue to roll stack
23198+ label = 1902LLU; // continue to roll stack
2319923199 break;
2320023200 }
23201- case 1917LLU: // return from add to ProcCall
23201+ case 1918LLU: // return from add to ProcCall
2320223202 {
2320323203 // copy mutable arguments back from call to add
2320423204 // copy back results provided by call to add
2320523205 stack[base + 30] = stack[base + 46LLU];
2320623206 // call add from ProcCall
23207- stack[base + 43LLU] = 1918LLU/*throw to this address*/;
23207+ stack[base + 43LLU] = 1919LLU/*throw to this address*/;
2320823208 stack[base + 44LLU] = base;
23209- stack[base + 45LLU] = 1919LLU;
23209+ stack[base + 45LLU] = 1920LLU;
2321023210 // arguments for call to add
2321123211 stack[base + 47LLU] = stack[base + 32]/*index*/;
2321223212 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -23215,14 +23215,14 @@
2321523215 label = 18446744073709551605LLU; // add
2321623216 break;
2321723217 }
23218- case 1918LLU: // copy-back deleter (add to ProcCall)
23218+ case 1919LLU: // copy-back deleter (add to ProcCall)
2321923219 {
2322023220 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2322123221 // copy mutable arguments back from call to add
23222- label = 1901LLU; // continue to roll stack
23222+ label = 1902LLU; // continue to roll stack
2322323223 break;
2322423224 }
23225- case 1919LLU: // return from add to ProcCall
23225+ case 1920LLU: // return from add to ProcCall
2322623226 {
2322723227 // copy mutable arguments back from call to add
2322823228 // copy back results provided by call to add
@@ -23229,9 +23229,9 @@
2322923229 stack[base + 30] = stack[base + 46LLU];
2323023230 printf("%s", "\n old");
2323123231 // call emitvaridx from ProcCall
23232- stack[base + 43LLU] = 1920LLU/*throw to this address*/;
23232+ stack[base + 43LLU] = 1921LLU/*throw to this address*/;
2323323233 stack[base + 44LLU] = base;
23234- stack[base + 45LLU] = 1921LLU;
23234+ stack[base + 45LLU] = 1922LLU;
2323523235 // arguments for call to emitvaridx
2323623236 stack[base + 46LLU] = stack[base + 40]/*INDEX*/;
2323723237 // set stack-base & callee-address
@@ -23239,21 +23239,21 @@
2323923239 label = 691LLU; // emitvaridx
2324023240 break;
2324123241 }
23242- case 1920LLU: // copy-back deleter (emitvaridx to ProcCall)
23242+ case 1921LLU: // copy-back deleter (emitvaridx to ProcCall)
2324323243 {
2324423244 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n");
2324523245 // copy mutable arguments back from call to emitvaridx
23246- label = 1901LLU; // continue to roll stack
23246+ label = 1902LLU; // continue to roll stack
2324723247 break;
2324823248 }
23249- case 1921LLU: // return from emitvaridx to ProcCall
23249+ case 1922LLU: // return from emitvaridx to ProcCall
2325023250 {
2325123251 // copy mutable arguments back from call to emitvaridx
2325223252 printf("%s", " = stack[");
2325323253 // call printnr from ProcCall
23254- stack[base + 43LLU] = 1922LLU/*throw to this address*/;
23254+ stack[base + 43LLU] = 1923LLU/*throw to this address*/;
2325523255 stack[base + 44LLU] = base;
23256- stack[base + 45LLU] = 1923LLU;
23256+ stack[base + 45LLU] = 1924LLU;
2325723257 // arguments for call to printnr
2325823258 stack[base + 46LLU] = stack[base + 30]/*sum*/;
2325923259 // set stack-base & callee-address
@@ -23261,54 +23261,54 @@
2326123261 label = 18446744073709551590LLU; // printnr
2326223262 break;
2326323263 }
23264- case 1922LLU: // copy-back deleter (printnr to ProcCall)
23264+ case 1923LLU: // copy-back deleter (printnr to ProcCall)
2326523265 {
2326623266 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2326723267 // copy mutable arguments back from call to printnr
23268- label = 1901LLU; // continue to roll stack
23268+ label = 1902LLU; // continue to roll stack
2326923269 break;
2327023270 }
23271- case 1923LLU: // return from printnr to ProcCall
23271+ case 1924LLU: // return from printnr to ProcCall
2327223272 {
2327323273 // copy mutable arguments back from call to printnr
2327423274 printf("%s", "LLU];");
2327523275 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2327623276 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
23277- label = 1899LLU; // case complete
23277+ label = 1900LLU; // case complete
2327823278 break;
2327923279 }
23280- case 1901LLU: // copy-back deleter (switch)
23280+ case 1902LLU: // copy-back deleter (switch)
2328123281 {
2328223282 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2328323283 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
23284- label = 1898LLU; // continue to unroll stack
23284+ label = 1899LLU; // continue to unroll stack
2328523285 break;
2328623286 }
23287- case 1900LLU: // try next case
23287+ case 1901LLU: // try next case
2328823288 {
2328923289 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2329023290 exit(-1);
2329123291 }
23292- case 1899LLU: // completed switch
23292+ case 1900LLU: // completed switch
2329323293 {
2329423294 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2329523295 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
23296- label = 1896LLU; // case complete
23296+ label = 1897LLU; // case complete
2329723297 break;
2329823298 }
23299- case 1898LLU: // copy-back deleter (switch)
23299+ case 1899LLU: // copy-back deleter (switch)
2330023300 {
2330123301 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2330223302 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
23303- label = 1889LLU; // continue to unroll stack
23303+ label = 1896LLU; // continue to unroll stack
2330423304 break;
2330523305 }
23306- case 1897LLU: // try next case
23306+ case 1898LLU: // try next case
2330723307 {
2330823308 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2330923309 exit(-1);
2331023310 }
23311- case 1896LLU: // completed switch
23311+ case 1897LLU: // completed switch
2331223312 {
2331323313
2331423314 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -23316,7 +23316,7 @@
2331623316 newstack[0] = (uint64_t)stack; // backup stack location
2331723317 newstack[1] = 1234567890;
2331823318 newstack[2] = base;
23319- newstack[3] = 1924LLU;
23319+ newstack[3] = 1925LLU;
2332023320 stack = newstack;
2332123321 // set stack-base & callee-address
2332223322 base = 4/*deloffset*/;
@@ -23323,7 +23323,7 @@
2332323323 label = 379LLU; // ~typeidx
2332423324 break;
2332523325 }
23326- case 1924LLU: // return from ~typeidx to ProcCall
23326+ case 1925LLU: // return from ~typeidx to ProcCall
2332723327 {
2332823328 stack = (uint64_t *)stack[0];
2332923329 // releasing toplevel container
@@ -23332,13 +23332,37 @@
2333223332 label = 1895LLU; // consequent complete
2333323333 break;
2333423334 }
23335+ case 1896LLU: // copy-back deleter (if pop)
23336+ {
23337+
23338+ uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
23339+ // call ~typeidx from ProcCall
23340+ newstack[0] = (uint64_t)stack; // backup stack location
23341+ newstack[1] = 1234567890;
23342+ newstack[2] = base;
23343+ newstack[3] = 1926LLU;
23344+ stack = newstack;
23345+ // set stack-base & callee-address
23346+ base = 4/*deloffset*/;
23347+ label = 379LLU; // ~typeidx
23348+ break;
23349+ }
23350+ case 1926LLU: // return from ~typeidx to ProcCall
23351+ {
23352+ stack = (uint64_t *)stack[0];
23353+ // releasing toplevel container
23354+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
23355+
23356+ label = 1889LLU; // consequent complete
23357+ break;
23358+ }
2333523359 case 1894LLU: // alternative
2333623360 {
2333723361 fprintf(stderr, "%s", "in function ");
2333823362 // call reportid from ProcCall
23339- stack[base + 39LLU] = 1925LLU/*throw to this address*/;
23363+ stack[base + 39LLU] = 1927LLU/*throw to this address*/;
2334023364 stack[base + 40LLU] = base;
23341- stack[base + 41LLU] = 1926LLU;
23365+ stack[base + 41LLU] = 1928LLU;
2334223366 // arguments for call to reportid
2334323367 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2334423368 // set stack-base & callee-address
@@ -23346,7 +23370,7 @@
2334623370 label = 18446744073709551586LLU; // reportid
2334723371 break;
2334823372 }
23349- case 1925LLU: // copy-back deleter (reportid to ProcCall)
23373+ case 1927LLU: // copy-back deleter (reportid to ProcCall)
2335023374 {
2335123375 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2335223376 // copy mutable arguments back from call to reportid
@@ -23353,14 +23377,14 @@
2335323377 label = 1889LLU; // continue to roll stack
2335423378 break;
2335523379 }
23356- case 1926LLU: // return from reportid to ProcCall
23380+ case 1928LLU: // return from reportid to ProcCall
2335723381 {
2335823382 // copy mutable arguments back from call to reportid
2335923383 fprintf(stderr, "%s", " call to ");
2336023384 // call reportid from ProcCall
23361- stack[base + 39LLU] = 1927LLU/*throw to this address*/;
23385+ stack[base + 39LLU] = 1929LLU/*throw to this address*/;
2336223386 stack[base + 40LLU] = base;
23363- stack[base + 41LLU] = 1928LLU;
23387+ stack[base + 41LLU] = 1930LLU;
2336423388 // arguments for call to reportid
2336523389 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2336623390 // set stack-base & callee-address
@@ -23368,7 +23392,7 @@
2336823392 label = 18446744073709551586LLU; // reportid
2336923393 break;
2337023394 }
23371- case 1927LLU: // copy-back deleter (reportid to ProcCall)
23395+ case 1929LLU: // copy-back deleter (reportid to ProcCall)
2337223396 {
2337323397 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2337423398 // copy mutable arguments back from call to reportid
@@ -23375,14 +23399,14 @@
2337523399 label = 1889LLU; // continue to roll stack
2337623400 break;
2337723401 }
23378- case 1928LLU: // return from reportid to ProcCall
23402+ case 1930LLU: // return from reportid to ProcCall
2337923403 {
2338023404 // copy mutable arguments back from call to reportid
2338123405 fprintf(stderr, "%s", " at position ");
2338223406 // call reportnr from ProcCall
23383- stack[base + 39LLU] = 1929LLU/*throw to this address*/;
23407+ stack[base + 39LLU] = 1931LLU/*throw to this address*/;
2338423408 stack[base + 40LLU] = base;
23385- stack[base + 41LLU] = 1930LLU;
23409+ stack[base + 41LLU] = 1932LLU;
2338623410 // arguments for call to reportnr
2338723411 stack[base + 42LLU] = stack[base + 32]/*index*/;
2338823412 // set stack-base & callee-address
@@ -23390,7 +23414,7 @@
2339023414 label = 18446744073709551589LLU; // reportnr
2339123415 break;
2339223416 }
23393- case 1929LLU: // copy-back deleter (reportnr to ProcCall)
23417+ case 1931LLU: // copy-back deleter (reportnr to ProcCall)
2339423418 {
2339523419 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2339623420 // copy mutable arguments back from call to reportnr
@@ -23397,7 +23421,7 @@
2339723421 label = 1889LLU; // continue to roll stack
2339823422 break;
2339923423 }
23400- case 1930LLU: // return from reportnr to ProcCall
23424+ case 1932LLU: // return from reportnr to ProcCall
2340123425 {
2340223426 // copy mutable arguments back from call to reportnr
2340323427 fprintf(stderr, "%s", " not enough destination-variables for results");
@@ -23432,9 +23456,9 @@
2343223456 {
2343323457 printf("%s", "\n if(stack[");
2343423458 // call printnr from ProcCall
23435- stack[base + 35LLU] = 1931LLU/*throw to this address*/;
23459+ stack[base + 35LLU] = 1933LLU/*throw to this address*/;
2343623460 stack[base + 36LLU] = base;
23437- stack[base + 37LLU] = 1932LLU;
23461+ stack[base + 37LLU] = 1934LLU;
2343823462 // arguments for call to printnr
2343923463 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2344023464 // set stack-base & callee-address
@@ -23442,7 +23466,7 @@
2344223466 label = 18446744073709551590LLU; // printnr
2344323467 break;
2344423468 }
23445- case 1931LLU: // copy-back deleter (printnr to ProcCall)
23469+ case 1933LLU: // copy-back deleter (printnr to ProcCall)
2344623470 {
2344723471 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2344823472 // copy mutable arguments back from call to printnr
@@ -23449,7 +23473,7 @@
2344923473 label = 1612LLU; // continue to roll stack
2345023474 break;
2345123475 }
23452- case 1932LLU: // return from printnr to ProcCall
23476+ case 1934LLU: // return from printnr to ProcCall
2345323477 {
2345423478 // copy mutable arguments back from call to printnr
2345523479 printf("%s", "LLU] != 9876543210LLU)");
@@ -23456,9 +23480,9 @@
2345623480 printf("%s", "\n {");
2345723481 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2345823482 // call printid from ProcCall
23459- stack[base + 35LLU] = 1933LLU/*throw to this address*/;
23483+ stack[base + 35LLU] = 1935LLU/*throw to this address*/;
2346023484 stack[base + 36LLU] = base;
23461- stack[base + 37LLU] = 1934LLU;
23485+ stack[base + 37LLU] = 1936LLU;
2346223486 // arguments for call to printid
2346323487 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2346423488 // set stack-base & callee-address
@@ -23466,7 +23490,7 @@
2346623490 label = 18446744073709551587LLU; // printid
2346723491 break;
2346823492 }
23469- case 1933LLU: // copy-back deleter (printid to ProcCall)
23493+ case 1935LLU: // copy-back deleter (printid to ProcCall)
2347023494 {
2347123495 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2347223496 // copy mutable arguments back from call to printid
@@ -23473,7 +23497,7 @@
2347323497 label = 1612LLU; // continue to roll stack
2347423498 break;
2347523499 }
23476- case 1934LLU: // return from printid to ProcCall
23500+ case 1936LLU: // return from printid to ProcCall
2347723501 {
2347823502 // copy mutable arguments back from call to printid
2347923503 printf("%s", ")!\");");
@@ -23481,9 +23505,9 @@
2348123505 printf("%s", "\n }");
2348223506 printf("%s", "\n Free(");
2348323507 // call printnr from ProcCall
23484- stack[base + 35LLU] = 1935LLU/*throw to this address*/;
23508+ stack[base + 35LLU] = 1937LLU/*throw to this address*/;
2348523509 stack[base + 36LLU] = base;
23486- stack[base + 37LLU] = 1936LLU;
23510+ stack[base + 37LLU] = 1938LLU;
2348723511 // arguments for call to printnr
2348823512 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2348923513 // set stack-base & callee-address
@@ -23491,7 +23515,7 @@
2349123515 label = 18446744073709551590LLU; // printnr
2349223516 break;
2349323517 }
23494- case 1935LLU: // copy-back deleter (printnr to ProcCall)
23518+ case 1937LLU: // copy-back deleter (printnr to ProcCall)
2349523519 {
2349623520 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2349723521 // copy mutable arguments back from call to printnr
@@ -23498,7 +23522,7 @@
2349823522 label = 1612LLU; // continue to roll stack
2349923523 break;
2350023524 }
23501- case 1936LLU: // return from printnr to ProcCall
23525+ case 1938LLU: // return from printnr to ProcCall
2350223526 {
2350323527 // copy mutable arguments back from call to printnr
2350423528 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
@@ -23509,9 +23533,9 @@
2350923533 case 1606LLU: // alternative
2351023534 {
2351123535 // call add from ProcCall
23512- stack[base + 33LLU] = 1937LLU/*throw to this address*/;
23536+ stack[base + 33LLU] = 1939LLU/*throw to this address*/;
2351323537 stack[base + 34LLU] = base;
23514- stack[base + 35LLU] = 1938LLU;
23538+ stack[base + 35LLU] = 1940LLU;
2351523539 // arguments for call to add
2351623540 stack[base + 37LLU] = 1LLU;
2351723541 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -23520,7 +23544,7 @@
2352023544 label = 18446744073709551605LLU; // add
2352123545 break;
2352223546 }
23523- case 1937LLU: // copy-back deleter (add to ProcCall)
23547+ case 1939LLU: // copy-back deleter (add to ProcCall)
2352423548 {
2352523549 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2352623550 // copy mutable arguments back from call to add
@@ -23527,15 +23551,15 @@
2352723551 label = 1604LLU; // continue to roll stack
2352823552 break;
2352923553 }
23530- case 1938LLU: // return from add to ProcCall
23554+ case 1940LLU: // return from add to ProcCall
2353123555 {
2353223556 // copy mutable arguments back from call to add
2353323557 // copy back results provided by call to add
2353423558 stack[base + 17] = stack[base + 36LLU];
23535- label = 1940LLU; // skip deleter
23559+ label = 1942LLU; // skip deleter
2353623560 break;
2353723561 }
23538- case 1939LLU: // deleter
23562+ case 1941LLU: // deleter
2353923563 {
2354023564 // throw from ProcCall
2354123565 if(!stack[base + 33])
@@ -23548,14 +23572,14 @@
2354823572 label = 1604LLU; // continue unrolling stack, delete next variable
2354923573 break;
2355023574 }
23551- case 1940LLU: // skipped deleter
23575+ case 1942LLU: // skipped deleter
2355223576 {
2355323577 stack[base + 33] = stack[base + 17]/*label*/;
2355423578 printf("%s", "\n // call ");
2355523579 // call printid from ProcCall
23556- stack[base + 34LLU] = 1941LLU/*throw to this address*/;
23580+ stack[base + 34LLU] = 1943LLU/*throw to this address*/;
2355723581 stack[base + 35LLU] = base;
23558- stack[base + 36LLU] = 1942LLU;
23582+ stack[base + 36LLU] = 1944LLU;
2355923583 // arguments for call to printid
2356023584 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2356123585 // set stack-base & callee-address
@@ -23563,21 +23587,21 @@
2356323587 label = 18446744073709551587LLU; // printid
2356423588 break;
2356523589 }
23566- case 1941LLU: // copy-back deleter (printid to ProcCall)
23590+ case 1943LLU: // copy-back deleter (printid to ProcCall)
2356723591 {
2356823592 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2356923593 // copy mutable arguments back from call to printid
23570- label = 1939LLU; // continue to roll stack
23594+ label = 1941LLU; // continue to roll stack
2357123595 break;
2357223596 }
23573- case 1942LLU: // return from printid to ProcCall
23597+ case 1944LLU: // return from printid to ProcCall
2357423598 {
2357523599 // copy mutable arguments back from call to printid
2357623600 printf("%s", " from ");
2357723601 // call printid from ProcCall
23578- stack[base + 34LLU] = 1943LLU/*throw to this address*/;
23602+ stack[base + 34LLU] = 1945LLU/*throw to this address*/;
2357923603 stack[base + 35LLU] = base;
23580- stack[base + 36LLU] = 1944LLU;
23604+ stack[base + 36LLU] = 1946LLU;
2358123605 // arguments for call to printid
2358223606 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2358323607 // set stack-base & callee-address
@@ -23585,21 +23609,21 @@
2358523609 label = 18446744073709551587LLU; // printid
2358623610 break;
2358723611 }
23588- case 1943LLU: // copy-back deleter (printid to ProcCall)
23612+ case 1945LLU: // copy-back deleter (printid to ProcCall)
2358923613 {
2359023614 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2359123615 // copy mutable arguments back from call to printid
23592- label = 1939LLU; // continue to roll stack
23616+ label = 1941LLU; // continue to roll stack
2359323617 break;
2359423618 }
23595- case 1944LLU: // return from printid to ProcCall
23619+ case 1946LLU: // return from printid to ProcCall
2359623620 {
2359723621 // copy mutable arguments back from call to printid
2359823622 stack[base + 30]/*sum*/ = 0;
2359923623 // call add from ProcCall
23600- stack[base + 34LLU] = 1945LLU/*throw to this address*/;
23624+ stack[base + 34LLU] = 1947LLU/*throw to this address*/;
2360123625 stack[base + 35LLU] = base;
23602- stack[base + 36LLU] = 1946LLU;
23626+ stack[base + 36LLU] = 1948LLU;
2360323627 // arguments for call to add
2360423628 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2360523629 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23608,22 +23632,22 @@
2360823632 label = 18446744073709551605LLU; // add
2360923633 break;
2361023634 }
23611- case 1945LLU: // copy-back deleter (add to ProcCall)
23635+ case 1947LLU: // copy-back deleter (add to ProcCall)
2361223636 {
2361323637 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2361423638 // copy mutable arguments back from call to add
23615- label = 1939LLU; // continue to roll stack
23639+ label = 1941LLU; // continue to roll stack
2361623640 break;
2361723641 }
23618- case 1946LLU: // return from add to ProcCall
23642+ case 1948LLU: // return from add to ProcCall
2361923643 {
2362023644 // copy mutable arguments back from call to add
2362123645 // copy back results provided by call to add
2362223646 stack[base + 30] = stack[base + 37LLU];
2362323647 // call add from ProcCall
23624- stack[base + 34LLU] = 1947LLU/*throw to this address*/;
23648+ stack[base + 34LLU] = 1949LLU/*throw to this address*/;
2362523649 stack[base + 35LLU] = base;
23626- stack[base + 36LLU] = 1948LLU;
23650+ stack[base + 36LLU] = 1950LLU;
2362723651 // arguments for call to add
2362823652 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
2362923653 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23632,22 +23656,22 @@
2363223656 label = 18446744073709551605LLU; // add
2363323657 break;
2363423658 }
23635- case 1947LLU: // copy-back deleter (add to ProcCall)
23659+ case 1949LLU: // copy-back deleter (add to ProcCall)
2363623660 {
2363723661 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2363823662 // copy mutable arguments back from call to add
23639- label = 1939LLU; // continue to roll stack
23663+ label = 1941LLU; // continue to roll stack
2364023664 break;
2364123665 }
23642- case 1948LLU: // return from add to ProcCall
23666+ case 1950LLU: // return from add to ProcCall
2364323667 {
2364423668 // copy mutable arguments back from call to add
2364523669 // copy back results provided by call to add
2364623670 stack[base + 30] = stack[base + 37LLU];
2364723671 // call add from ProcCall
23648- stack[base + 34LLU] = 1949LLU/*throw to this address*/;
23672+ stack[base + 34LLU] = 1951LLU/*throw to this address*/;
2364923673 stack[base + 35LLU] = base;
23650- stack[base + 36LLU] = 1950LLU;
23674+ stack[base + 36LLU] = 1952LLU;
2365123675 // arguments for call to add
2365223676 stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
2365323677 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23656,22 +23680,22 @@
2365623680 label = 18446744073709551605LLU; // add
2365723681 break;
2365823682 }
23659- case 1949LLU: // copy-back deleter (add to ProcCall)
23683+ case 1951LLU: // copy-back deleter (add to ProcCall)
2366023684 {
2366123685 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2366223686 // copy mutable arguments back from call to add
23663- label = 1939LLU; // continue to roll stack
23687+ label = 1941LLU; // continue to roll stack
2366423688 break;
2366523689 }
23666- case 1950LLU: // return from add to ProcCall
23690+ case 1952LLU: // return from add to ProcCall
2366723691 {
2366823692 // copy mutable arguments back from call to add
2366923693 // copy back results provided by call to add
2367023694 stack[base + 30] = stack[base + 37LLU];
2367123695 // call add from ProcCall
23672- stack[base + 34LLU] = 1951LLU/*throw to this address*/;
23696+ stack[base + 34LLU] = 1953LLU/*throw to this address*/;
2367323697 stack[base + 35LLU] = base;
23674- stack[base + 36LLU] = 1952LLU;
23698+ stack[base + 36LLU] = 1954LLU;
2367523699 // arguments for call to add
2367623700 stack[base + 38LLU] = 0LLU;
2367723701 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23680,14 +23704,14 @@
2368023704 label = 18446744073709551605LLU; // add
2368123705 break;
2368223706 }
23683- case 1951LLU: // copy-back deleter (add to ProcCall)
23707+ case 1953LLU: // copy-back deleter (add to ProcCall)
2368423708 {
2368523709 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2368623710 // copy mutable arguments back from call to add
23687- label = 1939LLU; // continue to roll stack
23711+ label = 1941LLU; // continue to roll stack
2368823712 break;
2368923713 }
23690- case 1952LLU: // return from add to ProcCall
23714+ case 1954LLU: // return from add to ProcCall
2369123715 {
2369223716 // copy mutable arguments back from call to add
2369323717 // copy back results provided by call to add
@@ -23694,9 +23718,9 @@
2369423718 stack[base + 30] = stack[base + 37LLU];
2369523719 printf("%s", "\n stack[base + ");
2369623720 // call printnr from ProcCall
23697- stack[base + 34LLU] = 1953LLU/*throw to this address*/;
23721+ stack[base + 34LLU] = 1955LLU/*throw to this address*/;
2369823722 stack[base + 35LLU] = base;
23699- stack[base + 36LLU] = 1954LLU;
23723+ stack[base + 36LLU] = 1956LLU;
2370023724 // arguments for call to printnr
2370123725 stack[base + 37LLU] = stack[base + 30]/*sum*/;
2370223726 // set stack-base & callee-address
@@ -23704,21 +23728,21 @@
2370423728 label = 18446744073709551590LLU; // printnr
2370523729 break;
2370623730 }
23707- case 1953LLU: // copy-back deleter (printnr to ProcCall)
23731+ case 1955LLU: // copy-back deleter (printnr to ProcCall)
2370823732 {
2370923733 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2371023734 // copy mutable arguments back from call to printnr
23711- label = 1939LLU; // continue to roll stack
23735+ label = 1941LLU; // continue to roll stack
2371223736 break;
2371323737 }
23714- case 1954LLU: // return from printnr to ProcCall
23738+ case 1956LLU: // return from printnr to ProcCall
2371523739 {
2371623740 // copy mutable arguments back from call to printnr
2371723741 printf("%s", "LLU] = ");
2371823742 // call printnr from ProcCall
23719- stack[base + 34LLU] = 1955LLU/*throw to this address*/;
23743+ stack[base + 34LLU] = 1957LLU/*throw to this address*/;
2372023744 stack[base + 35LLU] = base;
23721- stack[base + 36LLU] = 1956LLU;
23745+ stack[base + 36LLU] = 1958LLU;
2372223746 // arguments for call to printnr
2372323747 stack[base + 37LLU] = stack[base + 33]/*labelfail*/;
2372423748 // set stack-base & callee-address
@@ -23726,22 +23750,22 @@
2372623750 label = 18446744073709551590LLU; // printnr
2372723751 break;
2372823752 }
23729- case 1955LLU: // copy-back deleter (printnr to ProcCall)
23753+ case 1957LLU: // copy-back deleter (printnr to ProcCall)
2373023754 {
2373123755 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2373223756 // copy mutable arguments back from call to printnr
23733- label = 1939LLU; // continue to roll stack
23757+ label = 1941LLU; // continue to roll stack
2373423758 break;
2373523759 }
23736- case 1956LLU: // return from printnr to ProcCall
23760+ case 1958LLU: // return from printnr to ProcCall
2373723761 {
2373823762 // copy mutable arguments back from call to printnr
2373923763 printf("%s", "LLU/*throw to this address*/;");
2374023764 stack[base + 30]/*sum*/ = 0;
2374123765 // call add from ProcCall
23742- stack[base + 34LLU] = 1957LLU/*throw to this address*/;
23766+ stack[base + 34LLU] = 1959LLU/*throw to this address*/;
2374323767 stack[base + 35LLU] = base;
23744- stack[base + 36LLU] = 1958LLU;
23768+ stack[base + 36LLU] = 1960LLU;
2374523769 // arguments for call to add
2374623770 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2374723771 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23750,22 +23774,22 @@
2375023774 label = 18446744073709551605LLU; // add
2375123775 break;
2375223776 }
23753- case 1957LLU: // copy-back deleter (add to ProcCall)
23777+ case 1959LLU: // copy-back deleter (add to ProcCall)
2375423778 {
2375523779 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2375623780 // copy mutable arguments back from call to add
23757- label = 1939LLU; // continue to roll stack
23781+ label = 1941LLU; // continue to roll stack
2375823782 break;
2375923783 }
23760- case 1958LLU: // return from add to ProcCall
23784+ case 1960LLU: // return from add to ProcCall
2376123785 {
2376223786 // copy mutable arguments back from call to add
2376323787 // copy back results provided by call to add
2376423788 stack[base + 30] = stack[base + 37LLU];
2376523789 // call add from ProcCall
23766- stack[base + 34LLU] = 1959LLU/*throw to this address*/;
23790+ stack[base + 34LLU] = 1961LLU/*throw to this address*/;
2376723791 stack[base + 35LLU] = base;
23768- stack[base + 36LLU] = 1960LLU;
23792+ stack[base + 36LLU] = 1962LLU;
2376923793 // arguments for call to add
2377023794 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
2377123795 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23774,22 +23798,22 @@
2377423798 label = 18446744073709551605LLU; // add
2377523799 break;
2377623800 }
23777- case 1959LLU: // copy-back deleter (add to ProcCall)
23801+ case 1961LLU: // copy-back deleter (add to ProcCall)
2377823802 {
2377923803 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2378023804 // copy mutable arguments back from call to add
23781- label = 1939LLU; // continue to roll stack
23805+ label = 1941LLU; // continue to roll stack
2378223806 break;
2378323807 }
23784- case 1960LLU: // return from add to ProcCall
23808+ case 1962LLU: // return from add to ProcCall
2378523809 {
2378623810 // copy mutable arguments back from call to add
2378723811 // copy back results provided by call to add
2378823812 stack[base + 30] = stack[base + 37LLU];
2378923813 // call add from ProcCall
23790- stack[base + 34LLU] = 1961LLU/*throw to this address*/;
23814+ stack[base + 34LLU] = 1963LLU/*throw to this address*/;
2379123815 stack[base + 35LLU] = base;
23792- stack[base + 36LLU] = 1962LLU;
23816+ stack[base + 36LLU] = 1964LLU;
2379323817 // arguments for call to add
2379423818 stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
2379523819 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23798,22 +23822,22 @@
2379823822 label = 18446744073709551605LLU; // add
2379923823 break;
2380023824 }
23801- case 1961LLU: // copy-back deleter (add to ProcCall)
23825+ case 1963LLU: // copy-back deleter (add to ProcCall)
2380223826 {
2380323827 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2380423828 // copy mutable arguments back from call to add
23805- label = 1939LLU; // continue to roll stack
23829+ label = 1941LLU; // continue to roll stack
2380623830 break;
2380723831 }
23808- case 1962LLU: // return from add to ProcCall
23832+ case 1964LLU: // return from add to ProcCall
2380923833 {
2381023834 // copy mutable arguments back from call to add
2381123835 // copy back results provided by call to add
2381223836 stack[base + 30] = stack[base + 37LLU];
2381323837 // call add from ProcCall
23814- stack[base + 34LLU] = 1963LLU/*throw to this address*/;
23838+ stack[base + 34LLU] = 1965LLU/*throw to this address*/;
2381523839 stack[base + 35LLU] = base;
23816- stack[base + 36LLU] = 1964LLU;
23840+ stack[base + 36LLU] = 1966LLU;
2381723841 // arguments for call to add
2381823842 stack[base + 38LLU] = 1LLU;
2381923843 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23822,14 +23846,14 @@
2382223846 label = 18446744073709551605LLU; // add
2382323847 break;
2382423848 }
23825- case 1963LLU: // copy-back deleter (add to ProcCall)
23849+ case 1965LLU: // copy-back deleter (add to ProcCall)
2382623850 {
2382723851 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2382823852 // copy mutable arguments back from call to add
23829- label = 1939LLU; // continue to roll stack
23853+ label = 1941LLU; // continue to roll stack
2383023854 break;
2383123855 }
23832- case 1964LLU: // return from add to ProcCall
23856+ case 1966LLU: // return from add to ProcCall
2383323857 {
2383423858 // copy mutable arguments back from call to add
2383523859 // copy back results provided by call to add
@@ -23836,9 +23860,9 @@
2383623860 stack[base + 30] = stack[base + 37LLU];
2383723861 printf("%s", "\n stack[base + ");
2383823862 // call printnr from ProcCall
23839- stack[base + 34LLU] = 1965LLU/*throw to this address*/;
23863+ stack[base + 34LLU] = 1967LLU/*throw to this address*/;
2384023864 stack[base + 35LLU] = base;
23841- stack[base + 36LLU] = 1966LLU;
23865+ stack[base + 36LLU] = 1968LLU;
2384223866 // arguments for call to printnr
2384323867 stack[base + 37LLU] = stack[base + 30]/*sum*/;
2384423868 // set stack-base & callee-address
@@ -23846,22 +23870,22 @@
2384623870 label = 18446744073709551590LLU; // printnr
2384723871 break;
2384823872 }
23849- case 1965LLU: // copy-back deleter (printnr to ProcCall)
23873+ case 1967LLU: // copy-back deleter (printnr to ProcCall)
2385023874 {
2385123875 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2385223876 // copy mutable arguments back from call to printnr
23853- label = 1939LLU; // continue to roll stack
23877+ label = 1941LLU; // continue to roll stack
2385423878 break;
2385523879 }
23856- case 1966LLU: // return from printnr to ProcCall
23880+ case 1968LLU: // return from printnr to ProcCall
2385723881 {
2385823882 // copy mutable arguments back from call to printnr
2385923883 printf("%s", "LLU] = base;");
2386023884 stack[base + 30]/*sum*/ = 0;
2386123885 // call add from ProcCall
23862- stack[base + 34LLU] = 1967LLU/*throw to this address*/;
23886+ stack[base + 34LLU] = 1969LLU/*throw to this address*/;
2386323887 stack[base + 35LLU] = base;
23864- stack[base + 36LLU] = 1968LLU;
23888+ stack[base + 36LLU] = 1970LLU;
2386523889 // arguments for call to add
2386623890 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2386723891 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23870,22 +23894,22 @@
2387023894 label = 18446744073709551605LLU; // add
2387123895 break;
2387223896 }
23873- case 1967LLU: // copy-back deleter (add to ProcCall)
23897+ case 1969LLU: // copy-back deleter (add to ProcCall)
2387423898 {
2387523899 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2387623900 // copy mutable arguments back from call to add
23877- label = 1939LLU; // continue to roll stack
23901+ label = 1941LLU; // continue to roll stack
2387823902 break;
2387923903 }
23880- case 1968LLU: // return from add to ProcCall
23904+ case 1970LLU: // return from add to ProcCall
2388123905 {
2388223906 // copy mutable arguments back from call to add
2388323907 // copy back results provided by call to add
2388423908 stack[base + 30] = stack[base + 37LLU];
2388523909 // call add from ProcCall
23886- stack[base + 34LLU] = 1969LLU/*throw to this address*/;
23910+ stack[base + 34LLU] = 1971LLU/*throw to this address*/;
2388723911 stack[base + 35LLU] = base;
23888- stack[base + 36LLU] = 1970LLU;
23912+ stack[base + 36LLU] = 1972LLU;
2388923913 // arguments for call to add
2389023914 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
2389123915 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23894,22 +23918,22 @@
2389423918 label = 18446744073709551605LLU; // add
2389523919 break;
2389623920 }
23897- case 1969LLU: // copy-back deleter (add to ProcCall)
23921+ case 1971LLU: // copy-back deleter (add to ProcCall)
2389823922 {
2389923923 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2390023924 // copy mutable arguments back from call to add
23901- label = 1939LLU; // continue to roll stack
23925+ label = 1941LLU; // continue to roll stack
2390223926 break;
2390323927 }
23904- case 1970LLU: // return from add to ProcCall
23928+ case 1972LLU: // return from add to ProcCall
2390523929 {
2390623930 // copy mutable arguments back from call to add
2390723931 // copy back results provided by call to add
2390823932 stack[base + 30] = stack[base + 37LLU];
2390923933 // call add from ProcCall
23910- stack[base + 34LLU] = 1971LLU/*throw to this address*/;
23934+ stack[base + 34LLU] = 1973LLU/*throw to this address*/;
2391123935 stack[base + 35LLU] = base;
23912- stack[base + 36LLU] = 1972LLU;
23936+ stack[base + 36LLU] = 1974LLU;
2391323937 // arguments for call to add
2391423938 stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
2391523939 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23918,22 +23942,22 @@
2391823942 label = 18446744073709551605LLU; // add
2391923943 break;
2392023944 }
23921- case 1971LLU: // copy-back deleter (add to ProcCall)
23945+ case 1973LLU: // copy-back deleter (add to ProcCall)
2392223946 {
2392323947 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2392423948 // copy mutable arguments back from call to add
23925- label = 1939LLU; // continue to roll stack
23949+ label = 1941LLU; // continue to roll stack
2392623950 break;
2392723951 }
23928- case 1972LLU: // return from add to ProcCall
23952+ case 1974LLU: // return from add to ProcCall
2392923953 {
2393023954 // copy mutable arguments back from call to add
2393123955 // copy back results provided by call to add
2393223956 stack[base + 30] = stack[base + 37LLU];
2393323957 // call add from ProcCall
23934- stack[base + 34LLU] = 1973LLU/*throw to this address*/;
23958+ stack[base + 34LLU] = 1975LLU/*throw to this address*/;
2393523959 stack[base + 35LLU] = base;
23936- stack[base + 36LLU] = 1974LLU;
23960+ stack[base + 36LLU] = 1976LLU;
2393723961 // arguments for call to add
2393823962 stack[base + 38LLU] = 2LLU;
2393923963 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -23942,22 +23966,22 @@
2394223966 label = 18446744073709551605LLU; // add
2394323967 break;
2394423968 }
23945- case 1973LLU: // copy-back deleter (add to ProcCall)
23969+ case 1975LLU: // copy-back deleter (add to ProcCall)
2394623970 {
2394723971 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2394823972 // copy mutable arguments back from call to add
23949- label = 1939LLU; // continue to roll stack
23973+ label = 1941LLU; // continue to roll stack
2395023974 break;
2395123975 }
23952- case 1974LLU: // return from add to ProcCall
23976+ case 1976LLU: // return from add to ProcCall
2395323977 {
2395423978 // copy mutable arguments back from call to add
2395523979 // copy back results provided by call to add
2395623980 stack[base + 30] = stack[base + 37LLU];
2395723981 // call add from ProcCall
23958- stack[base + 34LLU] = 1975LLU/*throw to this address*/;
23982+ stack[base + 34LLU] = 1977LLU/*throw to this address*/;
2395923983 stack[base + 35LLU] = base;
23960- stack[base + 36LLU] = 1976LLU;
23984+ stack[base + 36LLU] = 1978LLU;
2396123985 // arguments for call to add
2396223986 stack[base + 38LLU] = 1LLU;
2396323987 stack[base + 39LLU] = stack[base + 17]/*label*/;
@@ -23966,14 +23990,14 @@
2396623990 label = 18446744073709551605LLU; // add
2396723991 break;
2396823992 }
23969- case 1975LLU: // copy-back deleter (add to ProcCall)
23993+ case 1977LLU: // copy-back deleter (add to ProcCall)
2397023994 {
2397123995 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2397223996 // copy mutable arguments back from call to add
23973- label = 1939LLU; // continue to roll stack
23997+ label = 1941LLU; // continue to roll stack
2397423998 break;
2397523999 }
23976- case 1976LLU: // return from add to ProcCall
24000+ case 1978LLU: // return from add to ProcCall
2397724001 {
2397824002 // copy mutable arguments back from call to add
2397924003 // copy back results provided by call to add
@@ -23980,9 +24004,9 @@
2398024004 stack[base + 17] = stack[base + 37LLU];
2398124005 printf("%s", "\n stack[base + ");
2398224006 // call printnr from ProcCall
23983- stack[base + 34LLU] = 1977LLU/*throw to this address*/;
24007+ stack[base + 34LLU] = 1979LLU/*throw to this address*/;
2398424008 stack[base + 35LLU] = base;
23985- stack[base + 36LLU] = 1978LLU;
24009+ stack[base + 36LLU] = 1980LLU;
2398624010 // arguments for call to printnr
2398724011 stack[base + 37LLU] = stack[base + 30]/*sum*/;
2398824012 // set stack-base & callee-address
@@ -23990,21 +24014,21 @@
2399024014 label = 18446744073709551590LLU; // printnr
2399124015 break;
2399224016 }
23993- case 1977LLU: // copy-back deleter (printnr to ProcCall)
24017+ case 1979LLU: // copy-back deleter (printnr to ProcCall)
2399424018 {
2399524019 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2399624020 // copy mutable arguments back from call to printnr
23997- label = 1939LLU; // continue to roll stack
24021+ label = 1941LLU; // continue to roll stack
2399824022 break;
2399924023 }
24000- case 1978LLU: // return from printnr to ProcCall
24024+ case 1980LLU: // return from printnr to ProcCall
2400124025 {
2400224026 // copy mutable arguments back from call to printnr
2400324027 printf("%s", "LLU] = ");
2400424028 // call printnr from ProcCall
24005- stack[base + 34LLU] = 1979LLU/*throw to this address*/;
24029+ stack[base + 34LLU] = 1981LLU/*throw to this address*/;
2400624030 stack[base + 35LLU] = base;
24007- stack[base + 36LLU] = 1980LLU;
24031+ stack[base + 36LLU] = 1982LLU;
2400824032 // arguments for call to printnr
2400924033 stack[base + 37LLU] = stack[base + 17]/*label*/;
2401024034 // set stack-base & callee-address
@@ -24012,14 +24036,14 @@
2401224036 label = 18446744073709551590LLU; // printnr
2401324037 break;
2401424038 }
24015- case 1979LLU: // copy-back deleter (printnr to ProcCall)
24039+ case 1981LLU: // copy-back deleter (printnr to ProcCall)
2401624040 {
2401724041 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2401824042 // copy mutable arguments back from call to printnr
24019- label = 1939LLU; // continue to roll stack
24043+ label = 1941LLU; // continue to roll stack
2402024044 break;
2402124045 }
24022- case 1980LLU: // return from printnr to ProcCall
24046+ case 1982LLU: // return from printnr to ProcCall
2402324047 {
2402424048 // copy mutable arguments back from call to printnr
2402524049 printf("%s", "LLU;");
@@ -24026,9 +24050,9 @@
2402624050 stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
2402724051 printf("%s", "\n // arguments for call to ");
2402824052 // call printid from ProcCall
24029- stack[base + 34LLU] = 1981LLU/*throw to this address*/;
24053+ stack[base + 34LLU] = 1983LLU/*throw to this address*/;
2403024054 stack[base + 35LLU] = base;
24031- stack[base + 36LLU] = 1982LLU;
24055+ stack[base + 36LLU] = 1984LLU;
2403224056 // arguments for call to printid
2403324057 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2403424058 // set stack-base & callee-address
@@ -24036,25 +24060,25 @@
2403624060 label = 18446744073709551587LLU; // printid
2403724061 break;
2403824062 }
24039- case 1981LLU: // copy-back deleter (printid to ProcCall)
24063+ case 1983LLU: // copy-back deleter (printid to ProcCall)
2404024064 {
2404124065 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2404224066 // copy mutable arguments back from call to printid
24043- label = 1939LLU; // continue to roll stack
24067+ label = 1941LLU; // continue to roll stack
2404424068 break;
2404524069 }
24046- case 1982LLU: // return from printid to ProcCall
24070+ case 1984LLU: // return from printid to ProcCall
2404724071 {
2404824072 // copy mutable arguments back from call to printid
2404924073 flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 34]);
24050- label = 1983LLU; // start to repeat
24074+ label = 1985LLU; // start to repeat
2405124075 break;
2405224076 }
24053- case 1983LLU: // repeat from here
24077+ case 1985LLU: // repeat from here
2405424078 {
2405524079 if(!stack[base + 34])
2405624080 {
24057- label = 1984LLU; // break loop
24081+ label = 1986LLU; // break loop
2405824082 break;
2405924083 }
2406024084
@@ -24063,9 +24087,9 @@
2406324087 stack[base + 36]/*previous*/ = stack[base + 34];
2406424088 stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
2406524089 // call sub from ProcCall
24066- stack[base + 37LLU] = 1986LLU/*throw to this address*/;
24090+ stack[base + 37LLU] = 1988LLU/*throw to this address*/;
2406724091 stack[base + 38LLU] = base;
24068- stack[base + 39LLU] = 1987LLU;
24092+ stack[base + 39LLU] = 1989LLU;
2406924093 // arguments for call to sub
2407024094 stack[base + 41LLU] = stack[base + 29]/*ceargcount*/;
2407124095 stack[base + 42LLU] = stack[base + 31]/*n*/;
@@ -24074,22 +24098,22 @@
2407424098 label = 18446744073709551604LLU; // sub
2407524099 break;
2407624100 }
24077- case 1986LLU: // copy-back deleter (sub to ProcCall)
24101+ case 1988LLU: // copy-back deleter (sub to ProcCall)
2407824102 {
2407924103 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2408024104 // copy mutable arguments back from call to sub
24081- label = 1985LLU; // continue to roll stack
24105+ label = 1987LLU; // continue to roll stack
2408224106 break;
2408324107 }
24084- case 1987LLU: // return from sub to ProcCall
24108+ case 1989LLU: // return from sub to ProcCall
2408524109 {
2408624110 // copy mutable arguments back from call to sub
2408724111 // copy back results provided by call to sub
2408824112 stack[base + 32] = stack[base + 40LLU];
2408924113 // call sub from ProcCall
24090- stack[base + 37LLU] = 1988LLU/*throw to this address*/;
24114+ stack[base + 37LLU] = 1990LLU/*throw to this address*/;
2409124115 stack[base + 38LLU] = base;
24092- stack[base + 39LLU] = 1989LLU;
24116+ stack[base + 39LLU] = 1991LLU;
2409324117 // arguments for call to sub
2409424118 stack[base + 41LLU] = stack[base + 31]/*n*/;
2409524119 stack[base + 42LLU] = 1LLU;
@@ -24098,14 +24122,14 @@
2409824122 label = 18446744073709551604LLU; // sub
2409924123 break;
2410024124 }
24101- case 1988LLU: // copy-back deleter (sub to ProcCall)
24125+ case 1990LLU: // copy-back deleter (sub to ProcCall)
2410224126 {
2410324127 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2410424128 // copy mutable arguments back from call to sub
24105- label = 1985LLU; // continue to roll stack
24129+ label = 1987LLU; // continue to roll stack
2410624130 break;
2410724131 }
24108- case 1989LLU: // return from sub to ProcCall
24132+ case 1991LLU: // return from sub to ProcCall
2410924133 {
2411024134 // copy mutable arguments back from call to sub
2411124135 // copy back results provided by call to sub
@@ -24112,15 +24136,15 @@
2411224136 stack[base + 31] = stack[base + 40LLU];
2411324137 if(!stack[base + 32]/*index*/)
2411424138 {
24115- label = 1990LLU; // jump to alternative
24139+ label = 1992LLU; // jump to alternative
2411624140 break;
2411724141 }
2411824142
2411924143 // consequent
2412024144 // call matchsym from ProcCall
24121- stack[base + 37LLU] = 1992LLU/*throw to this address*/;
24145+ stack[base + 37LLU] = 1994LLU/*throw to this address*/;
2412224146 stack[base + 38LLU] = base;
24123- stack[base + 39LLU] = 1993LLU;
24147+ stack[base + 39LLU] = 1995LLU;
2412424148 // arguments for call to matchsym
2412524149 stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2412624150 stack[base + 41LLU] = 44LLU;
@@ -24130,33 +24154,33 @@
2413024154 label = 212LLU; // matchsym
2413124155 break;
2413224156 }
24133- case 1992LLU: // copy-back deleter (matchsym to ProcCall)
24157+ case 1994LLU: // copy-back deleter (matchsym to ProcCall)
2413424158 {
2413524159 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
2413624160 // copy mutable arguments back from call to matchsym
2413724161 stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
24138- label = 1985LLU; // continue to roll stack
24162+ label = 1987LLU; // continue to roll stack
2413924163 break;
2414024164 }
24141- case 1993LLU: // return from matchsym to ProcCall
24165+ case 1995LLU: // return from matchsym to ProcCall
2414224166 {
2414324167 // copy mutable arguments back from call to matchsym
2414424168 stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
24145- label = 1991LLU; // consequent complete
24169+ label = 1993LLU; // consequent complete
2414624170 break;
2414724171 }
24148- case 1990LLU: // alternative
24172+ case 1992LLU: // alternative
2414924173 {
24150- label = 1991LLU; // alternative complete
24174+ label = 1993LLU; // alternative complete
2415124175 break;
2415224176 }
24153- case 1991LLU: // completed if-then-else
24177+ case 1993LLU: // completed if-then-else
2415424178 {
2415524179 stack[base + 30]/*sum*/ = 0;
2415624180 // call add from ProcCall
24157- stack[base + 37LLU] = 1994LLU/*throw to this address*/;
24181+ stack[base + 37LLU] = 1996LLU/*throw to this address*/;
2415824182 stack[base + 38LLU] = base;
24159- stack[base + 39LLU] = 1995LLU;
24183+ stack[base + 39LLU] = 1997LLU;
2416024184 // arguments for call to add
2416124185 stack[base + 41LLU] = stack[base + 4]/*offset*/;
2416224186 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24165,22 +24189,22 @@
2416524189 label = 18446744073709551605LLU; // add
2416624190 break;
2416724191 }
24168- case 1994LLU: // copy-back deleter (add to ProcCall)
24192+ case 1996LLU: // copy-back deleter (add to ProcCall)
2416924193 {
2417024194 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2417124195 // copy mutable arguments back from call to add
24172- label = 1985LLU; // continue to roll stack
24196+ label = 1987LLU; // continue to roll stack
2417324197 break;
2417424198 }
24175- case 1995LLU: // return from add to ProcCall
24199+ case 1997LLU: // return from add to ProcCall
2417624200 {
2417724201 // copy mutable arguments back from call to add
2417824202 // copy back results provided by call to add
2417924203 stack[base + 30] = stack[base + 40LLU];
2418024204 // call add from ProcCall
24181- stack[base + 37LLU] = 1996LLU/*throw to this address*/;
24205+ stack[base + 37LLU] = 1998LLU/*throw to this address*/;
2418224206 stack[base + 38LLU] = base;
24183- stack[base + 39LLU] = 1997LLU;
24207+ stack[base + 39LLU] = 1999LLU;
2418424208 // arguments for call to add
2418524209 stack[base + 41LLU] = 3LLU;
2418624210 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24189,22 +24213,22 @@
2418924213 label = 18446744073709551605LLU; // add
2419024214 break;
2419124215 }
24192- case 1996LLU: // copy-back deleter (add to ProcCall)
24216+ case 1998LLU: // copy-back deleter (add to ProcCall)
2419324217 {
2419424218 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2419524219 // copy mutable arguments back from call to add
24196- label = 1985LLU; // continue to roll stack
24220+ label = 1987LLU; // continue to roll stack
2419724221 break;
2419824222 }
24199- case 1997LLU: // return from add to ProcCall
24223+ case 1999LLU: // return from add to ProcCall
2420024224 {
2420124225 // copy mutable arguments back from call to add
2420224226 // copy back results provided by call to add
2420324227 stack[base + 30] = stack[base + 40LLU];
2420424228 // call add from ProcCall
24205- stack[base + 37LLU] = 1998LLU/*throw to this address*/;
24229+ stack[base + 37LLU] = 2000LLU/*throw to this address*/;
2420624230 stack[base + 38LLU] = base;
24207- stack[base + 39LLU] = 1999LLU;
24231+ stack[base + 39LLU] = 2001LLU;
2420824232 // arguments for call to add
2420924233 stack[base + 41LLU] = stack[base + 10]/*fnrescount*/;
2421024234 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24213,22 +24237,22 @@
2421324237 label = 18446744073709551605LLU; // add
2421424238 break;
2421524239 }
24216- case 1998LLU: // copy-back deleter (add to ProcCall)
24240+ case 2000LLU: // copy-back deleter (add to ProcCall)
2421724241 {
2421824242 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2421924243 // copy mutable arguments back from call to add
24220- label = 1985LLU; // continue to roll stack
24244+ label = 1987LLU; // continue to roll stack
2422124245 break;
2422224246 }
24223- case 1999LLU: // return from add to ProcCall
24247+ case 2001LLU: // return from add to ProcCall
2422424248 {
2422524249 // copy mutable arguments back from call to add
2422624250 // copy back results provided by call to add
2422724251 stack[base + 30] = stack[base + 40LLU];
2422824252 // call add from ProcCall
24229- stack[base + 37LLU] = 2000LLU/*throw to this address*/;
24253+ stack[base + 37LLU] = 2002LLU/*throw to this address*/;
2423024254 stack[base + 38LLU] = base;
24231- stack[base + 39LLU] = 2001LLU;
24255+ stack[base + 39LLU] = 2003LLU;
2423224256 // arguments for call to add
2423324257 stack[base + 41LLU] = stack[base + 11]/*fnargcount*/;
2423424258 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24237,22 +24261,22 @@
2423724261 label = 18446744073709551605LLU; // add
2423824262 break;
2423924263 }
24240- case 2000LLU: // copy-back deleter (add to ProcCall)
24264+ case 2002LLU: // copy-back deleter (add to ProcCall)
2424124265 {
2424224266 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2424324267 // copy mutable arguments back from call to add
24244- label = 1985LLU; // continue to roll stack
24268+ label = 1987LLU; // continue to roll stack
2424524269 break;
2424624270 }
24247- case 2001LLU: // return from add to ProcCall
24271+ case 2003LLU: // return from add to ProcCall
2424824272 {
2424924273 // copy mutable arguments back from call to add
2425024274 // copy back results provided by call to add
2425124275 stack[base + 30] = stack[base + 40LLU];
2425224276 // call add from ProcCall
24253- stack[base + 37LLU] = 2002LLU/*throw to this address*/;
24277+ stack[base + 37LLU] = 2004LLU/*throw to this address*/;
2425424278 stack[base + 38LLU] = base;
24255- stack[base + 39LLU] = 2003LLU;
24279+ stack[base + 39LLU] = 2005LLU;
2425624280 // arguments for call to add
2425724281 stack[base + 41LLU] = stack[base + 28]/*cerescount*/;
2425824282 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24261,22 +24285,22 @@
2426124285 label = 18446744073709551605LLU; // add
2426224286 break;
2426324287 }
24264- case 2002LLU: // copy-back deleter (add to ProcCall)
24288+ case 2004LLU: // copy-back deleter (add to ProcCall)
2426524289 {
2426624290 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2426724291 // copy mutable arguments back from call to add
24268- label = 1985LLU; // continue to roll stack
24292+ label = 1987LLU; // continue to roll stack
2426924293 break;
2427024294 }
24271- case 2003LLU: // return from add to ProcCall
24295+ case 2005LLU: // return from add to ProcCall
2427224296 {
2427324297 // copy mutable arguments back from call to add
2427424298 // copy back results provided by call to add
2427524299 stack[base + 30] = stack[base + 40LLU];
2427624300 // call add from ProcCall
24277- stack[base + 37LLU] = 2004LLU/*throw to this address*/;
24301+ stack[base + 37LLU] = 2006LLU/*throw to this address*/;
2427824302 stack[base + 38LLU] = base;
24279- stack[base + 39LLU] = 2005LLU;
24303+ stack[base + 39LLU] = 2007LLU;
2428024304 // arguments for call to add
2428124305 stack[base + 41LLU] = stack[base + 32]/*index*/;
2428224306 stack[base + 42LLU] = stack[base + 30]/*sum*/;
@@ -24285,22 +24309,22 @@
2428524309 label = 18446744073709551605LLU; // add
2428624310 break;
2428724311 }
24288- case 2004LLU: // copy-back deleter (add to ProcCall)
24312+ case 2006LLU: // copy-back deleter (add to ProcCall)
2428924313 {
2429024314 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2429124315 // copy mutable arguments back from call to add
24292- label = 1985LLU; // continue to roll stack
24316+ label = 1987LLU; // continue to roll stack
2429324317 break;
2429424318 }
24295- case 2005LLU: // return from add to ProcCall
24319+ case 2007LLU: // return from add to ProcCall
2429624320 {
2429724321 // copy mutable arguments back from call to add
2429824322 // copy back results provided by call to add
2429924323 stack[base + 30] = stack[base + 40LLU];
2430024324 // call ParseToken from ProcCall
24301- stack[base + 37LLU] = 2006LLU/*throw to this address*/;
24325+ stack[base + 37LLU] = 2008LLU/*throw to this address*/;
2430224326 stack[base + 38LLU] = base;
24303- stack[base + 39LLU] = 2007LLU;
24327+ stack[base + 39LLU] = 2009LLU;
2430424328 // arguments for call to ParseToken
2430524329 stack[base + 42LLU] = stack[base + 14]/*lookahead*/;
2430624330 // set stack-base & callee-address
@@ -24308,15 +24332,15 @@
2430824332 label = 3LLU; // ParseToken
2430924333 break;
2431024334 }
24311- case 2006LLU: // copy-back deleter (ParseToken to ProcCall)
24335+ case 2008LLU: // copy-back deleter (ParseToken to ProcCall)
2431224336 {
2431324337 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n");
2431424338 // copy mutable arguments back from call to ParseToken
2431524339 stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
24316- label = 1985LLU; // continue to roll stack
24340+ label = 1987LLU; // continue to roll stack
2431724341 break;
2431824342 }
24319- case 2007LLU: // return from ParseToken to ProcCall
24343+ case 2009LLU: // return from ParseToken to ProcCall
2432024344 {
2432124345 // copy mutable arguments back from call to ParseToken
2432224346 stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
@@ -24324,9 +24348,9 @@
2432424348 stack[base + 15] = stack[base + 40LLU];
2432524349 stack[base + 16] = stack[base + 41LLU];
2432624350 // call isncs from ProcCall
24327- stack[base + 37LLU] = 2008LLU/*throw to this address*/;
24351+ stack[base + 37LLU] = 2010LLU/*throw to this address*/;
2432824352 stack[base + 38LLU] = base;
24329- stack[base + 39LLU] = 2009LLU;
24353+ stack[base + 39LLU] = 2011LLU;
2433024354 // arguments for call to isncs
2433124355 stack[base + 41LLU] = stack[base + 15]/*variant*/;
2433224356 // set stack-base & callee-address
@@ -24334,14 +24358,14 @@
2433424358 label = 272LLU; // isncs
2433524359 break;
2433624360 }
24337- case 2008LLU: // copy-back deleter (isncs to ProcCall)
24361+ case 2010LLU: // copy-back deleter (isncs to ProcCall)
2433824362 {
2433924363 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n");
2434024364 // copy mutable arguments back from call to isncs
24341- label = 1985LLU; // continue to roll stack
24365+ label = 1987LLU; // continue to roll stack
2434224366 break;
2434324367 }
24344- case 2009LLU: // return from isncs to ProcCall
24368+ case 2011LLU: // return from isncs to ProcCall
2434524369 {
2434624370 // copy mutable arguments back from call to isncs
2434724371 // copy back results provided by call to isncs
@@ -24348,7 +24372,7 @@
2434824372 stack[base + 18] = stack[base + 40LLU];
2434924373 if(!stack[base + 18]/*isequal*/)
2435024374 {
24351- label = 2010LLU; // jump to alternative
24375+ label = 2012LLU; // jump to alternative
2435224376 break;
2435324377 }
2435424378
@@ -24355,7 +24379,7 @@
2435524379 // consequent
2435624380 if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
2435724381 {
24358- label = 2013LLU; // jump to alternative
24382+ label = 2015LLU; // jump to alternative
2435924383 break;
2436024384 }
2436124385
@@ -24365,7 +24389,7 @@
2436524389 // case
2436624390 if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
2436724391 {
24368- label = 2016LLU; // jump to alternative
24392+ label = 2018LLU; // jump to alternative
2436924393 break;
2437024394 }
2437124395
@@ -24374,9 +24398,9 @@
2437424398
2437524399 // case
2437624400 // call mktypename from ProcCall
24377- stack[base + 42LLU] = 2018LLU/*throw to this address*/;
24401+ stack[base + 42LLU] = 2020LLU/*throw to this address*/;
2437824402 stack[base + 43LLU] = base;
24379- stack[base + 44LLU] = 2019LLU;
24403+ stack[base + 44LLU] = 2021LLU;
2438024404 // arguments for call to mktypename
2438124405 stack[base + 46LLU] = 881834713755418624LLU;
2438224406 // set stack-base & callee-address
@@ -24384,14 +24408,14 @@
2438424408 label = 300LLU; // mktypename
2438524409 break;
2438624410 }
24387- case 2018LLU: // copy-back deleter (mktypename to ProcCall)
24411+ case 2020LLU: // copy-back deleter (mktypename to ProcCall)
2438824412 {
2438924413 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n");
2439024414 // copy mutable arguments back from call to mktypename
24391- label = 2017LLU; // continue to roll stack
24415+ label = 2019LLU; // continue to roll stack
2439224416 break;
2439324417 }
24394- case 2019LLU: // return from mktypename to ProcCall
24418+ case 2021LLU: // return from mktypename to ProcCall
2439524419 {
2439624420 // copy mutable arguments back from call to mktypename
2439724421 // copy back results provided by call to mktypename
@@ -24399,7 +24423,7 @@
2439924423 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2440024424 if(!newstack)
2440124425 {
24402- label = 2017LLU; // throw: begin to unroll stack
24426+ label = 2019LLU; // throw: begin to unroll stack
2440324427 break;
2440424428 }
2440524429
@@ -24406,9 +24430,9 @@
2440624430 newstack[15LLU] = 9876543210LLU; // overflow-marker
2440724431 // call equtype from ProcCall
2440824432 newstack[0] = (uint64_t)stack; // backup stack location
24409- newstack[1] = 2020LLU;
24433+ newstack[1] = 2022LLU;
2441024434 newstack[2] = base;
24411- newstack[3] = 2021LLU;
24435+ newstack[3] = 2023LLU;
2441224436 // arguments for call to equtype
2441324437 newstack[5LLU] = stack[base + 41]/*type*/;
2441424438 newstack[6LLU] = stack[base + 39]/*expected*/;
@@ -24418,7 +24442,7 @@
2441824442 label = 342LLU; // equtype
2441924443 break;
2442024444 }
24421- case 2020LLU: // copy-back deleter (equtype to ProcCall)
24445+ case 2022LLU: // copy-back deleter (equtype to ProcCall)
2442224446 {
2442324447 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2442424448 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24430,10 +24454,10 @@
2443024454 }
2443124455 Free(15LLU + 1, sizeof(uint64_t), stack);
2443224456 stack = oldstack;
24433- label = 2017LLU; // continue to unroll stack
24457+ label = 2019LLU; // continue to unroll stack
2443424458 break;
2443524459 }
24436- case 2021LLU: // return from equtype to ProcCall
24460+ case 2023LLU: // return from equtype to ProcCall
2443724461 {
2443824462 uint64_t *oldstack = (uint64_t *)stack[0];
2443924463 // copy mutable arguments back from call to equtype
@@ -24448,21 +24472,21 @@
2444824472 stack = oldstack;
2444924473 if(!stack[base + 18]/*isequal*/)
2445024474 {
24451- label = 2022LLU; // jump to alternative
24475+ label = 2024LLU; // jump to alternative
2445224476 break;
2445324477 }
2445424478
2445524479 // consequent
24456- label = 2023LLU; // consequent complete
24480+ label = 2025LLU; // consequent complete
2445724481 break;
2445824482 }
24459- case 2022LLU: // alternative
24483+ case 2024LLU: // alternative
2446024484 {
2446124485 fprintf(stderr, "%s", "in function ");
2446224486 // call reportid from ProcCall
24463- stack[base + 42LLU] = 2024LLU/*throw to this address*/;
24487+ stack[base + 42LLU] = 2026LLU/*throw to this address*/;
2446424488 stack[base + 43LLU] = base;
24465- stack[base + 44LLU] = 2025LLU;
24489+ stack[base + 44LLU] = 2027LLU;
2446624490 // arguments for call to reportid
2446724491 stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2446824492 // set stack-base & callee-address
@@ -24470,21 +24494,21 @@
2447024494 label = 18446744073709551586LLU; // reportid
2447124495 break;
2447224496 }
24473- case 2024LLU: // copy-back deleter (reportid to ProcCall)
24497+ case 2026LLU: // copy-back deleter (reportid to ProcCall)
2447424498 {
2447524499 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2447624500 // copy mutable arguments back from call to reportid
24477- label = 2017LLU; // continue to roll stack
24501+ label = 2019LLU; // continue to roll stack
2447824502 break;
2447924503 }
24480- case 2025LLU: // return from reportid to ProcCall
24504+ case 2027LLU: // return from reportid to ProcCall
2448124505 {
2448224506 // copy mutable arguments back from call to reportid
2448324507 fprintf(stderr, "%s", " call to ");
2448424508 // call reportid from ProcCall
24485- stack[base + 42LLU] = 2026LLU/*throw to this address*/;
24509+ stack[base + 42LLU] = 2028LLU/*throw to this address*/;
2448624510 stack[base + 43LLU] = base;
24487- stack[base + 44LLU] = 2027LLU;
24511+ stack[base + 44LLU] = 2029LLU;
2448824512 // arguments for call to reportid
2448924513 stack[base + 45LLU] = stack[base + 24]/*ceid*/;
2449024514 // set stack-base & callee-address
@@ -24492,21 +24516,21 @@
2449224516 label = 18446744073709551586LLU; // reportid
2449324517 break;
2449424518 }
24495- case 2026LLU: // copy-back deleter (reportid to ProcCall)
24519+ case 2028LLU: // copy-back deleter (reportid to ProcCall)
2449624520 {
2449724521 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2449824522 // copy mutable arguments back from call to reportid
24499- label = 2017LLU; // continue to roll stack
24523+ label = 2019LLU; // continue to roll stack
2450024524 break;
2450124525 }
24502- case 2027LLU: // return from reportid to ProcCall
24526+ case 2029LLU: // return from reportid to ProcCall
2450324527 {
2450424528 // copy mutable arguments back from call to reportid
2450524529 fprintf(stderr, "%s", " at position ");
2450624530 // call reportnr from ProcCall
24507- stack[base + 42LLU] = 2028LLU/*throw to this address*/;
24531+ stack[base + 42LLU] = 2030LLU/*throw to this address*/;
2450824532 stack[base + 43LLU] = base;
24509- stack[base + 44LLU] = 2029LLU;
24533+ stack[base + 44LLU] = 2031LLU;
2451024534 // arguments for call to reportnr
2451124535 stack[base + 45LLU] = stack[base + 32]/*index*/;
2451224536 // set stack-base & callee-address
@@ -24514,14 +24538,14 @@
2451424538 label = 18446744073709551589LLU; // reportnr
2451524539 break;
2451624540 }
24517- case 2028LLU: // copy-back deleter (reportnr to ProcCall)
24541+ case 2030LLU: // copy-back deleter (reportnr to ProcCall)
2451824542 {
2451924543 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2452024544 // copy mutable arguments back from call to reportnr
24521- label = 2017LLU; // continue to roll stack
24545+ label = 2019LLU; // continue to roll stack
2452224546 break;
2452324547 }
24524- case 2029LLU: // return from reportnr to ProcCall
24548+ case 2031LLU: // return from reportnr to ProcCall
2452524549 {
2452624550 // copy mutable arguments back from call to reportnr
2452724551 fprintf(stderr, "%s", " expected parameter of type ");
@@ -24528,7 +24552,7 @@
2452824552 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2452924553 if(!newstack)
2453024554 {
24531- label = 2017LLU; // throw: begin to unroll stack
24555+ label = 2019LLU; // throw: begin to unroll stack
2453224556 break;
2453324557 }
2453424558
@@ -24535,9 +24559,9 @@
2453524559 newstack[10LLU] = 9876543210LLU; // overflow-marker
2453624560 // call reporttype from ProcCall
2453724561 newstack[0] = (uint64_t)stack; // backup stack location
24538- newstack[1] = 2030LLU;
24562+ newstack[1] = 2032LLU;
2453924563 newstack[2] = base;
24540- newstack[3] = 2031LLU;
24564+ newstack[3] = 2033LLU;
2454124565 // arguments for call to reporttype
2454224566 newstack[4LLU] = stack[base + 39]/*expected*/;
2454324567 stack = newstack;
@@ -24546,7 +24570,7 @@
2454624570 label = 316LLU; // reporttype
2454724571 break;
2454824572 }
24549- case 2030LLU: // copy-back deleter (reporttype to ProcCall)
24573+ case 2032LLU: // copy-back deleter (reporttype to ProcCall)
2455024574 {
2455124575 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2455224576 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24558,10 +24582,10 @@
2455824582 }
2455924583 Free(10LLU + 1, sizeof(uint64_t), stack);
2456024584 stack = oldstack;
24561- label = 2017LLU; // continue to unroll stack
24585+ label = 2019LLU; // continue to unroll stack
2456224586 break;
2456324587 }
24564- case 2031LLU: // return from reporttype to ProcCall
24588+ case 2033LLU: // return from reporttype to ProcCall
2456524589 {
2456624590 uint64_t *oldstack = (uint64_t *)stack[0];
2456724591 // copy mutable arguments back from call to reporttype
@@ -24575,10 +24599,10 @@
2457524599 fprintf(stderr, "%s", " but found constant-argument of type u64");
2457624600 fprintf(stderr, "%s", "\n");
2457724601 exit(-1);
24578- label = 2023LLU; // alternative complete
24602+ label = 2025LLU; // alternative complete
2457924603 break;
2458024604 }
24581- case 2023LLU: // completed if-then-else
24605+ case 2025LLU: // completed if-then-else
2458224606 {
2458324607
2458424608 uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
@@ -24586,7 +24610,7 @@
2458624610 newstack[0] = (uint64_t)stack; // backup stack location
2458724611 newstack[1] = 1234567890;
2458824612 newstack[2] = base;
24589- newstack[3] = 2032LLU;
24613+ newstack[3] = 2034LLU;
2459024614 stack = newstack;
2459124615 // set stack-base & callee-address
2459224616 base = 4/*deloffset*/;
@@ -24593,7 +24617,7 @@
2459324617 label = 296LLU; // ~type
2459424618 break;
2459524619 }
24596- case 2032LLU: // return from ~type to ProcCall
24620+ case 2034LLU: // return from ~type to ProcCall
2459724621 {
2459824622 stack = (uint64_t *)stack[0];
2459924623 // releasing toplevel container
@@ -24601,26 +24625,26 @@
2460124625
2460224626 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2460324627 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
24604- label = 2015LLU; // case complete
24628+ label = 2017LLU; // case complete
2460524629 break;
2460624630 }
24607- case 2017LLU: // copy-back deleter (switch)
24631+ case 2019LLU: // copy-back deleter (switch)
2460824632 {
2460924633 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2461024634 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
24611- label = 2014LLU; // continue to unroll stack
24635+ label = 2016LLU; // continue to unroll stack
2461224636 break;
2461324637 }
24614- case 2016LLU: // try next case
24638+ case 2018LLU: // try next case
2461524639 {
2461624640 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2461724641 exit(-1);
2461824642 }
24619- case 2015LLU: // completed switch
24643+ case 2017LLU: // completed switch
2462024644 {
2462124645 if(!stack[base + 38]/*mutable*/)
2462224646 {
24623- label = 2033LLU; // jump to alternative
24647+ label = 2035LLU; // jump to alternative
2462424648 break;
2462524649 }
2462624650
@@ -24627,9 +24651,9 @@
2462724651 // consequent
2462824652 fprintf(stderr, "%s", "in function ");
2462924653 // call reportid from ProcCall
24630- stack[base + 39LLU] = 2035LLU/*throw to this address*/;
24654+ stack[base + 39LLU] = 2037LLU/*throw to this address*/;
2463124655 stack[base + 40LLU] = base;
24632- stack[base + 41LLU] = 2036LLU;
24656+ stack[base + 41LLU] = 2038LLU;
2463324657 // arguments for call to reportid
2463424658 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2463524659 // set stack-base & callee-address
@@ -24637,21 +24661,21 @@
2463724661 label = 18446744073709551586LLU; // reportid
2463824662 break;
2463924663 }
24640- case 2035LLU: // copy-back deleter (reportid to ProcCall)
24664+ case 2037LLU: // copy-back deleter (reportid to ProcCall)
2464124665 {
2464224666 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2464324667 // copy mutable arguments back from call to reportid
24644- label = 2014LLU; // continue to roll stack
24668+ label = 2016LLU; // continue to roll stack
2464524669 break;
2464624670 }
24647- case 2036LLU: // return from reportid to ProcCall
24671+ case 2038LLU: // return from reportid to ProcCall
2464824672 {
2464924673 // copy mutable arguments back from call to reportid
2465024674 fprintf(stderr, "%s", ", calling ");
2465124675 // call reportid from ProcCall
24652- stack[base + 39LLU] = 2037LLU/*throw to this address*/;
24676+ stack[base + 39LLU] = 2039LLU/*throw to this address*/;
2465324677 stack[base + 40LLU] = base;
24654- stack[base + 41LLU] = 2038LLU;
24678+ stack[base + 41LLU] = 2040LLU;
2465524679 // arguments for call to reportid
2465624680 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2465724681 // set stack-base & callee-address
@@ -24659,22 +24683,22 @@
2465924683 label = 18446744073709551586LLU; // reportid
2466024684 break;
2466124685 }
24662- case 2037LLU: // copy-back deleter (reportid to ProcCall)
24686+ case 2039LLU: // copy-back deleter (reportid to ProcCall)
2466324687 {
2466424688 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2466524689 // copy mutable arguments back from call to reportid
24666- label = 2014LLU; // continue to roll stack
24690+ label = 2016LLU; // continue to roll stack
2466724691 break;
2466824692 }
24669- case 2038LLU: // return from reportid to ProcCall
24693+ case 2040LLU: // return from reportid to ProcCall
2467024694 {
2467124695 // copy mutable arguments back from call to reportid
2467224696 fprintf(stderr, "%s", ": ");
2467324697 fprintf(stderr, "%s", "can't use constant argument ");
2467424698 // call printnr from ProcCall
24675- stack[base + 39LLU] = 2039LLU/*throw to this address*/;
24699+ stack[base + 39LLU] = 2041LLU/*throw to this address*/;
2467624700 stack[base + 40LLU] = base;
24677- stack[base + 41LLU] = 2040LLU;
24701+ stack[base + 41LLU] = 2042LLU;
2467824702 // arguments for call to printnr
2467924703 stack[base + 42LLU] = stack[base + 16]/*content*/;
2468024704 // set stack-base & callee-address
@@ -24682,21 +24706,21 @@
2468224706 label = 18446744073709551590LLU; // printnr
2468324707 break;
2468424708 }
24685- case 2039LLU: // copy-back deleter (printnr to ProcCall)
24709+ case 2041LLU: // copy-back deleter (printnr to ProcCall)
2468624710 {
2468724711 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2468824712 // copy mutable arguments back from call to printnr
24689- label = 2014LLU; // continue to roll stack
24713+ label = 2016LLU; // continue to roll stack
2469024714 break;
2469124715 }
24692- case 2040LLU: // return from printnr to ProcCall
24716+ case 2042LLU: // return from printnr to ProcCall
2469324717 {
2469424718 // copy mutable arguments back from call to printnr
2469524719 printf("%s", " for mutable parameter ");
2469624720 // call reportti from ProcCall
24697- stack[base + 39LLU] = 2041LLU/*throw to this address*/;
24721+ stack[base + 39LLU] = 2043LLU/*throw to this address*/;
2469824722 stack[base + 40LLU] = base;
24699- stack[base + 41LLU] = 2042LLU;
24723+ stack[base + 41LLU] = 2044LLU;
2470024724 // arguments for call to reportti
2470124725 stack[base + 42LLU] = stack[base + 37]/*typeid*/;
2470224726 // set stack-base & callee-address
@@ -24704,52 +24728,52 @@
2470424728 label = 370LLU; // reportti
2470524729 break;
2470624730 }
24707- case 2041LLU: // copy-back deleter (reportti to ProcCall)
24731+ case 2043LLU: // copy-back deleter (reportti to ProcCall)
2470824732 {
2470924733 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n");
2471024734 // copy mutable arguments back from call to reportti
24711- label = 2014LLU; // continue to roll stack
24735+ label = 2016LLU; // continue to roll stack
2471224736 break;
2471324737 }
24714- case 2042LLU: // return from reportti to ProcCall
24738+ case 2044LLU: // return from reportti to ProcCall
2471524739 {
2471624740 // copy mutable arguments back from call to reportti
2471724741 fprintf(stderr, "%s", "\n");
2471824742 exit(-1);
24719- label = 2034LLU; // consequent complete
24743+ label = 2036LLU; // consequent complete
2472024744 break;
2472124745 }
24722- case 2033LLU: // alternative
24746+ case 2035LLU: // alternative
2472324747 {
24724- label = 2034LLU; // alternative complete
24748+ label = 2036LLU; // alternative complete
2472524749 break;
2472624750 }
24727- case 2034LLU: // completed if-then-else
24751+ case 2036LLU: // completed if-then-else
2472824752 {
2472924753 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
2473024754 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24731- label = 2012LLU; // case complete
24755+ label = 2014LLU; // case complete
2473224756 break;
2473324757 }
24734- case 2014LLU: // copy-back deleter (switch)
24758+ case 2016LLU: // copy-back deleter (switch)
2473524759 {
2473624760 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
2473724761 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24738- label = 1985LLU; // continue to unroll stack
24762+ label = 1987LLU; // continue to unroll stack
2473924763 break;
2474024764 }
24741- case 2013LLU: // try next case
24765+ case 2015LLU: // try next case
2474224766 {
2474324767 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2474424768 exit(-1);
2474524769 }
24746- case 2012LLU: // completed switch
24770+ case 2014LLU: // completed switch
2474724771 {
2474824772 printf("%s", "\n stack[base + ");
2474924773 // call printnr from ProcCall
24750- stack[base + 37LLU] = 2043LLU/*throw to this address*/;
24774+ stack[base + 37LLU] = 2045LLU/*throw to this address*/;
2475124775 stack[base + 38LLU] = base;
24752- stack[base + 39LLU] = 2044LLU;
24776+ stack[base + 39LLU] = 2046LLU;
2475324777 // arguments for call to printnr
2475424778 stack[base + 40LLU] = stack[base + 30]/*sum*/;
2475524779 // set stack-base & callee-address
@@ -24757,21 +24781,21 @@
2475724781 label = 18446744073709551590LLU; // printnr
2475824782 break;
2475924783 }
24760- case 2043LLU: // copy-back deleter (printnr to ProcCall)
24784+ case 2045LLU: // copy-back deleter (printnr to ProcCall)
2476124785 {
2476224786 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2476324787 // copy mutable arguments back from call to printnr
24764- label = 1985LLU; // continue to roll stack
24788+ label = 1987LLU; // continue to roll stack
2476524789 break;
2476624790 }
24767- case 2044LLU: // return from printnr to ProcCall
24791+ case 2046LLU: // return from printnr to ProcCall
2476824792 {
2476924793 // copy mutable arguments back from call to printnr
2477024794 printf("%s", "LLU] = ");
2477124795 // call printnr from ProcCall
24772- stack[base + 37LLU] = 2045LLU/*throw to this address*/;
24796+ stack[base + 37LLU] = 2047LLU/*throw to this address*/;
2477324797 stack[base + 38LLU] = base;
24774- stack[base + 39LLU] = 2046LLU;
24798+ stack[base + 39LLU] = 2048LLU;
2477524799 // arguments for call to printnr
2477624800 stack[base + 40LLU] = stack[base + 16]/*content*/;
2477724801 // set stack-base & callee-address
@@ -24779,26 +24803,26 @@
2477924803 label = 18446744073709551590LLU; // printnr
2478024804 break;
2478124805 }
24782- case 2045LLU: // copy-back deleter (printnr to ProcCall)
24806+ case 2047LLU: // copy-back deleter (printnr to ProcCall)
2478324807 {
2478424808 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2478524809 // copy mutable arguments back from call to printnr
24786- label = 1985LLU; // continue to roll stack
24810+ label = 1987LLU; // continue to roll stack
2478724811 break;
2478824812 }
24789- case 2046LLU: // return from printnr to ProcCall
24813+ case 2048LLU: // return from printnr to ProcCall
2479024814 {
2479124815 // copy mutable arguments back from call to printnr
2479224816 printf("%s", "LLU;");
24793- label = 2011LLU; // consequent complete
24817+ label = 2013LLU; // consequent complete
2479424818 break;
2479524819 }
24796- case 2010LLU: // alternative
24820+ case 2012LLU: // alternative
2479724821 {
2479824822 // call equ from ProcCall
24799- stack[base + 37LLU] = 2047LLU/*throw to this address*/;
24823+ stack[base + 37LLU] = 2049LLU/*throw to this address*/;
2480024824 stack[base + 38LLU] = base;
24801- stack[base + 39LLU] = 2048LLU;
24825+ stack[base + 39LLU] = 2050LLU;
2480224826 // arguments for call to equ
2480324827 stack[base + 41LLU] = stack[base + 15]/*variant*/;
2480424828 stack[base + 42LLU] = 4LLU;
@@ -24807,14 +24831,14 @@
2480724831 label = 18446744073709551600LLU; // equ
2480824832 break;
2480924833 }
24810- case 2047LLU: // copy-back deleter (equ to ProcCall)
24834+ case 2049LLU: // copy-back deleter (equ to ProcCall)
2481124835 {
2481224836 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
2481324837 // copy mutable arguments back from call to equ
24814- label = 1985LLU; // continue to roll stack
24838+ label = 1987LLU; // continue to roll stack
2481524839 break;
2481624840 }
24817- case 2048LLU: // return from equ to ProcCall
24841+ case 2050LLU: // return from equ to ProcCall
2481824842 {
2481924843 // copy mutable arguments back from call to equ
2482024844 // copy back results provided by call to equ
@@ -24821,7 +24845,7 @@
2482124845 stack[base + 18] = stack[base + 40LLU];
2482224846 if(!stack[base + 18]/*isequal*/)
2482324847 {
24824- label = 2049LLU; // jump to alternative
24848+ label = 2051LLU; // jump to alternative
2482524849 break;
2482624850 }
2482724851
@@ -24828,7 +24852,7 @@
2482824852 // consequent
2482924853 if(/*param*/0 != ((uint64_t *)(stack[base + 35]/*param*/))[0])
2483024854 {
24831- label = 2052LLU; // jump to alternative
24855+ label = 2054LLU; // jump to alternative
2483224856 break;
2483324857 }
2483424858
@@ -24838,7 +24862,7 @@
2483824862 // case
2483924863 if(/*typeid*/0 != ((uint64_t *)(stack[base + 37]/*typeid*/))[0])
2484024864 {
24841- label = 2055LLU; // jump to alternative
24865+ label = 2057LLU; // jump to alternative
2484224866 break;
2484324867 }
2484424868
@@ -24847,9 +24871,9 @@
2484724871
2484824872 // case
2484924873 // call getlettype from ProcCall
24850- stack[base + 42LLU] = 2057LLU/*throw to this address*/;
24874+ stack[base + 42LLU] = 2059LLU/*throw to this address*/;
2485124875 stack[base + 43LLU] = base;
24852- stack[base + 44LLU] = 2058LLU;
24876+ stack[base + 44LLU] = 2060LLU;
2485324877 // arguments for call to getlettype
2485424878 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2485524879 stack[base + 47LLU] = stack[base + 16]/*content*/;
@@ -24860,22 +24884,22 @@
2486024884 label = 651LLU; // getlettype
2486124885 break;
2486224886 }
24863- case 2057LLU: // copy-back deleter (getlettype to ProcCall)
24887+ case 2059LLU: // copy-back deleter (getlettype to ProcCall)
2486424888 {
2486524889 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (getlettype to ProcCall)\n");
2486624890 // copy mutable arguments back from call to getlettype
24867- label = 2056LLU; // continue to roll stack
24891+ label = 2058LLU; // continue to roll stack
2486824892 break;
2486924893 }
24870- case 2058LLU: // return from getlettype to ProcCall
24894+ case 2060LLU: // return from getlettype to ProcCall
2487124895 {
2487224896 // copy mutable arguments back from call to getlettype
2487324897 // copy back results provided by call to getlettype
2487424898 stack[base + 41] = stack[base + 45LLU];
2487524899 // call findletmut from ProcCall
24876- stack[base + 43LLU] = 2059LLU/*throw to this address*/;
24900+ stack[base + 43LLU] = 2061LLU/*throw to this address*/;
2487724901 stack[base + 44LLU] = base;
24878- stack[base + 45LLU] = 2060LLU;
24902+ stack[base + 45LLU] = 2062LLU;
2487924903 // arguments for call to findletmut
2488024904 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2488124905 stack[base + 48LLU] = stack[base + 16]/*content*/;
@@ -24886,14 +24910,14 @@
2488624910 label = 671LLU; // findletmut
2488724911 break;
2488824912 }
24889- case 2059LLU: // copy-back deleter (findletmut to ProcCall)
24913+ case 2061LLU: // copy-back deleter (findletmut to ProcCall)
2489024914 {
2489124915 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (findletmut to ProcCall)\n");
2489224916 // copy mutable arguments back from call to findletmut
24893- label = 2056LLU; // continue to roll stack
24917+ label = 2058LLU; // continue to roll stack
2489424918 break;
2489524919 }
24896- case 2060LLU: // return from findletmut to ProcCall
24920+ case 2062LLU: // return from findletmut to ProcCall
2489724921 {
2489824922 // copy mutable arguments back from call to findletmut
2489924923 // copy back results provided by call to findletmut
@@ -24901,7 +24925,7 @@
2490124925 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2490224926 if(!newstack)
2490324927 {
24904- label = 2056LLU; // throw: begin to unroll stack
24928+ label = 2058LLU; // throw: begin to unroll stack
2490524929 break;
2490624930 }
2490724931
@@ -24908,9 +24932,9 @@
2490824932 newstack[15LLU] = 9876543210LLU; // overflow-marker
2490924933 // call equtype from ProcCall
2491024934 newstack[0] = (uint64_t)stack; // backup stack location
24911- newstack[1] = 2061LLU;
24935+ newstack[1] = 2063LLU;
2491224936 newstack[2] = base;
24913- newstack[3] = 2062LLU;
24937+ newstack[3] = 2064LLU;
2491424938 // arguments for call to equtype
2491524939 newstack[5LLU] = stack[base + 41]/*type*/;
2491624940 newstack[6LLU] = stack[base + 39]/*expected*/;
@@ -24920,7 +24944,7 @@
2492024944 label = 342LLU; // equtype
2492124945 break;
2492224946 }
24923- case 2061LLU: // copy-back deleter (equtype to ProcCall)
24947+ case 2063LLU: // copy-back deleter (equtype to ProcCall)
2492424948 {
2492524949 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2492624950 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -24932,10 +24956,10 @@
2493224956 }
2493324957 Free(15LLU + 1, sizeof(uint64_t), stack);
2493424958 stack = oldstack;
24935- label = 2056LLU; // continue to unroll stack
24959+ label = 2058LLU; // continue to unroll stack
2493624960 break;
2493724961 }
24938- case 2062LLU: // return from equtype to ProcCall
24962+ case 2064LLU: // return from equtype to ProcCall
2493924963 {
2494024964 uint64_t *oldstack = (uint64_t *)stack[0];
2494124965 // copy mutable arguments back from call to equtype
@@ -24950,21 +24974,21 @@
2495024974 stack = oldstack;
2495124975 if(!stack[base + 18]/*isequal*/)
2495224976 {
24953- label = 2063LLU; // jump to alternative
24977+ label = 2065LLU; // jump to alternative
2495424978 break;
2495524979 }
2495624980
2495724981 // consequent
24958- label = 2064LLU; // consequent complete
24982+ label = 2066LLU; // consequent complete
2495924983 break;
2496024984 }
24961- case 2063LLU: // alternative
24985+ case 2065LLU: // alternative
2496224986 {
2496324987 fprintf(stderr, "%s", "in function ");
2496424988 // call reportid from ProcCall
24965- stack[base + 43LLU] = 2065LLU/*throw to this address*/;
24989+ stack[base + 43LLU] = 2067LLU/*throw to this address*/;
2496624990 stack[base + 44LLU] = base;
24967- stack[base + 45LLU] = 2066LLU;
24991+ stack[base + 45LLU] = 2068LLU;
2496824992 // arguments for call to reportid
2496924993 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2497024994 // set stack-base & callee-address
@@ -24972,21 +24996,21 @@
2497224996 label = 18446744073709551586LLU; // reportid
2497324997 break;
2497424998 }
24975- case 2065LLU: // copy-back deleter (reportid to ProcCall)
24999+ case 2067LLU: // copy-back deleter (reportid to ProcCall)
2497625000 {
2497725001 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2497825002 // copy mutable arguments back from call to reportid
24979- label = 2056LLU; // continue to roll stack
25003+ label = 2058LLU; // continue to roll stack
2498025004 break;
2498125005 }
24982- case 2066LLU: // return from reportid to ProcCall
25006+ case 2068LLU: // return from reportid to ProcCall
2498325007 {
2498425008 // copy mutable arguments back from call to reportid
2498525009 fprintf(stderr, "%s", " call to ");
2498625010 // call reportid from ProcCall
24987- stack[base + 43LLU] = 2067LLU/*throw to this address*/;
25011+ stack[base + 43LLU] = 2069LLU/*throw to this address*/;
2498825012 stack[base + 44LLU] = base;
24989- stack[base + 45LLU] = 2068LLU;
25013+ stack[base + 45LLU] = 2070LLU;
2499025014 // arguments for call to reportid
2499125015 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2499225016 // set stack-base & callee-address
@@ -24994,21 +25018,21 @@
2499425018 label = 18446744073709551586LLU; // reportid
2499525019 break;
2499625020 }
24997- case 2067LLU: // copy-back deleter (reportid to ProcCall)
25021+ case 2069LLU: // copy-back deleter (reportid to ProcCall)
2499825022 {
2499925023 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2500025024 // copy mutable arguments back from call to reportid
25001- label = 2056LLU; // continue to roll stack
25025+ label = 2058LLU; // continue to roll stack
2500225026 break;
2500325027 }
25004- case 2068LLU: // return from reportid to ProcCall
25028+ case 2070LLU: // return from reportid to ProcCall
2500525029 {
2500625030 // copy mutable arguments back from call to reportid
2500725031 fprintf(stderr, "%s", " at position ");
2500825032 // call reportnr from ProcCall
25009- stack[base + 43LLU] = 2069LLU/*throw to this address*/;
25033+ stack[base + 43LLU] = 2071LLU/*throw to this address*/;
2501025034 stack[base + 44LLU] = base;
25011- stack[base + 45LLU] = 2070LLU;
25035+ stack[base + 45LLU] = 2072LLU;
2501225036 // arguments for call to reportnr
2501325037 stack[base + 46LLU] = stack[base + 32]/*index*/;
2501425038 // set stack-base & callee-address
@@ -25016,14 +25040,14 @@
2501625040 label = 18446744073709551589LLU; // reportnr
2501725041 break;
2501825042 }
25019- case 2069LLU: // copy-back deleter (reportnr to ProcCall)
25043+ case 2071LLU: // copy-back deleter (reportnr to ProcCall)
2502025044 {
2502125045 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2502225046 // copy mutable arguments back from call to reportnr
25023- label = 2056LLU; // continue to roll stack
25047+ label = 2058LLU; // continue to roll stack
2502425048 break;
2502525049 }
25026- case 2070LLU: // return from reportnr to ProcCall
25050+ case 2072LLU: // return from reportnr to ProcCall
2502725051 {
2502825052 // copy mutable arguments back from call to reportnr
2502925053 fprintf(stderr, "%s", " parameter type ");
@@ -25030,7 +25054,7 @@
2503025054 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2503125055 if(!newstack)
2503225056 {
25033- label = 2056LLU; // throw: begin to unroll stack
25057+ label = 2058LLU; // throw: begin to unroll stack
2503425058 break;
2503525059 }
2503625060
@@ -25037,9 +25061,9 @@
2503725061 newstack[10LLU] = 9876543210LLU; // overflow-marker
2503825062 // call reporttype from ProcCall
2503925063 newstack[0] = (uint64_t)stack; // backup stack location
25040- newstack[1] = 2071LLU;
25064+ newstack[1] = 2073LLU;
2504125065 newstack[2] = base;
25042- newstack[3] = 2072LLU;
25066+ newstack[3] = 2074LLU;
2504325067 // arguments for call to reporttype
2504425068 newstack[4LLU] = stack[base + 39]/*expected*/;
2504525069 stack = newstack;
@@ -25048,7 +25072,7 @@
2504825072 label = 316LLU; // reporttype
2504925073 break;
2505025074 }
25051- case 2071LLU: // copy-back deleter (reporttype to ProcCall)
25075+ case 2073LLU: // copy-back deleter (reporttype to ProcCall)
2505225076 {
2505325077 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2505425078 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -25060,10 +25084,10 @@
2506025084 }
2506125085 Free(10LLU + 1, sizeof(uint64_t), stack);
2506225086 stack = oldstack;
25063- label = 2056LLU; // continue to unroll stack
25087+ label = 2058LLU; // continue to unroll stack
2506425088 break;
2506525089 }
25066- case 2072LLU: // return from reporttype to ProcCall
25090+ case 2074LLU: // return from reporttype to ProcCall
2506725091 {
2506825092 uint64_t *oldstack = (uint64_t *)stack[0];
2506925093 // copy mutable arguments back from call to reporttype
@@ -25078,7 +25102,7 @@
2507825102 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2507925103 if(!newstack)
2508025104 {
25081- label = 2056LLU; // throw: begin to unroll stack
25105+ label = 2058LLU; // throw: begin to unroll stack
2508225106 break;
2508325107 }
2508425108
@@ -25085,9 +25109,9 @@
2508525109 newstack[10LLU] = 9876543210LLU; // overflow-marker
2508625110 // call reporttype from ProcCall
2508725111 newstack[0] = (uint64_t)stack; // backup stack location
25088- newstack[1] = 2073LLU;
25112+ newstack[1] = 2075LLU;
2508925113 newstack[2] = base;
25090- newstack[3] = 2074LLU;
25114+ newstack[3] = 2076LLU;
2509125115 // arguments for call to reporttype
2509225116 newstack[4LLU] = stack[base + 41]/*type*/;
2509325117 stack = newstack;
@@ -25096,7 +25120,7 @@
2509625120 label = 316LLU; // reporttype
2509725121 break;
2509825122 }
25099- case 2073LLU: // copy-back deleter (reporttype to ProcCall)
25123+ case 2075LLU: // copy-back deleter (reporttype to ProcCall)
2510025124 {
2510125125 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2510225126 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -25108,10 +25132,10 @@
2510825132 }
2510925133 Free(10LLU + 1, sizeof(uint64_t), stack);
2511025134 stack = oldstack;
25111- label = 2056LLU; // continue to unroll stack
25135+ label = 2058LLU; // continue to unroll stack
2511225136 break;
2511325137 }
25114- case 2074LLU: // return from reporttype to ProcCall
25138+ case 2076LLU: // return from reporttype to ProcCall
2511525139 {
2511625140 uint64_t *oldstack = (uint64_t *)stack[0];
2511725141 // copy mutable arguments back from call to reporttype
@@ -25124,14 +25148,14 @@
2512425148 stack = oldstack;
2512525149 fprintf(stderr, "%s", "\n");
2512625150 exit(-1);
25127- label = 2064LLU; // alternative complete
25151+ label = 2066LLU; // alternative complete
2512825152 break;
2512925153 }
25130- case 2064LLU: // completed if-then-else
25154+ case 2066LLU: // completed if-then-else
2513125155 {
2513225156 if(!stack[base + 38]/*mutable*/)
2513325157 {
25134- label = 2075LLU; // jump to alternative
25158+ label = 2077LLU; // jump to alternative
2513525159 break;
2513625160 }
2513725161
@@ -25138,15 +25162,15 @@
2513825162 // consequent
2513925163 if(!stack[base + 42]/*mutarg*/)
2514025164 {
25141- label = 2077LLU; // jump to alternative
25165+ label = 2079LLU; // jump to alternative
2514225166 break;
2514325167 }
2514425168
2514525169 // consequent
2514625170 // call lookidnr from ProcCall
25147- stack[base + 44LLU] = 2079LLU/*throw to this address*/;
25171+ stack[base + 44LLU] = 2081LLU/*throw to this address*/;
2514825172 stack[base + 45LLU] = base;
25149- stack[base + 46LLU] = 2080LLU;
25173+ stack[base + 46LLU] = 2082LLU;
2515025174 // arguments for call to lookidnr
2515125175 stack[base + 48LLU] = stack[base + 19]/*copyback*/;
2515225176 stack[base + 49LLU] = stack[base + 16]/*content*/;
@@ -25155,14 +25179,14 @@
2515525179 label = 800LLU; // lookidnr
2515625180 break;
2515725181 }
25158- case 2079LLU: // copy-back deleter (lookidnr to ProcCall)
25182+ case 2081LLU: // copy-back deleter (lookidnr to ProcCall)
2515925183 {
2516025184 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n");
2516125185 // copy mutable arguments back from call to lookidnr
25162- label = 2056LLU; // continue to roll stack
25186+ label = 2058LLU; // continue to roll stack
2516325187 break;
2516425188 }
25165- case 2080LLU: // return from lookidnr to ProcCall
25189+ case 2082LLU: // return from lookidnr to ProcCall
2516625190 {
2516725191 // copy mutable arguments back from call to lookidnr
2516825192 // copy back results provided by call to lookidnr
@@ -25169,7 +25193,7 @@
2516925193 stack[base + 43] = stack[base + 47LLU];
2517025194 if(!stack[base + 43]/*found*/)
2517125195 {
25172- label = 2081LLU; // jump to alternative
25196+ label = 2083LLU; // jump to alternative
2517325197 break;
2517425198 }
2517525199
@@ -25176,9 +25200,9 @@
2517625200 // consequent
2517725201 fprintf(stderr, "%s", "in function ");
2517825202 // call reportid from ProcCall
25179- stack[base + 44LLU] = 2083LLU/*throw to this address*/;
25203+ stack[base + 44LLU] = 2085LLU/*throw to this address*/;
2518025204 stack[base + 45LLU] = base;
25181- stack[base + 46LLU] = 2084LLU;
25205+ stack[base + 46LLU] = 2086LLU;
2518225206 // arguments for call to reportid
2518325207 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2518425208 // set stack-base & callee-address
@@ -25186,21 +25210,21 @@
2518625210 label = 18446744073709551586LLU; // reportid
2518725211 break;
2518825212 }
25189- case 2083LLU: // copy-back deleter (reportid to ProcCall)
25213+ case 2085LLU: // copy-back deleter (reportid to ProcCall)
2519025214 {
2519125215 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2519225216 // copy mutable arguments back from call to reportid
25193- label = 2056LLU; // continue to roll stack
25217+ label = 2058LLU; // continue to roll stack
2519425218 break;
2519525219 }
25196- case 2084LLU: // return from reportid to ProcCall
25220+ case 2086LLU: // return from reportid to ProcCall
2519725221 {
2519825222 // copy mutable arguments back from call to reportid
2519925223 fprintf(stderr, "%s", " call to ");
2520025224 // call reportid from ProcCall
25201- stack[base + 44LLU] = 2085LLU/*throw to this address*/;
25225+ stack[base + 44LLU] = 2087LLU/*throw to this address*/;
2520225226 stack[base + 45LLU] = base;
25203- stack[base + 46LLU] = 2086LLU;
25227+ stack[base + 46LLU] = 2088LLU;
2520425228 // arguments for call to reportid
2520525229 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2520625230 // set stack-base & callee-address
@@ -25208,21 +25232,21 @@
2520825232 label = 18446744073709551586LLU; // reportid
2520925233 break;
2521025234 }
25211- case 2085LLU: // copy-back deleter (reportid to ProcCall)
25235+ case 2087LLU: // copy-back deleter (reportid to ProcCall)
2521225236 {
2521325237 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2521425238 // copy mutable arguments back from call to reportid
25215- label = 2056LLU; // continue to roll stack
25239+ label = 2058LLU; // continue to roll stack
2521625240 break;
2521725241 }
25218- case 2086LLU: // return from reportid to ProcCall
25242+ case 2088LLU: // return from reportid to ProcCall
2521925243 {
2522025244 // copy mutable arguments back from call to reportid
2522125245 fprintf(stderr, "%s", " - duplicate mutable argument ");
2522225246 // call reportid from ProcCall
25223- stack[base + 44LLU] = 2087LLU/*throw to this address*/;
25247+ stack[base + 44LLU] = 2089LLU/*throw to this address*/;
2522425248 stack[base + 45LLU] = base;
25225- stack[base + 46LLU] = 2088LLU;
25249+ stack[base + 46LLU] = 2090LLU;
2522625250 // arguments for call to reportid
2522725251 stack[base + 47LLU] = stack[base + 16]/*content*/;
2522825252 // set stack-base & callee-address
@@ -25230,38 +25254,38 @@
2523025254 label = 18446744073709551586LLU; // reportid
2523125255 break;
2523225256 }
25233- case 2087LLU: // copy-back deleter (reportid to ProcCall)
25257+ case 2089LLU: // copy-back deleter (reportid to ProcCall)
2523425258 {
2523525259 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2523625260 // copy mutable arguments back from call to reportid
25237- label = 2056LLU; // continue to roll stack
25261+ label = 2058LLU; // continue to roll stack
2523825262 break;
2523925263 }
25240- case 2088LLU: // return from reportid to ProcCall
25264+ case 2090LLU: // return from reportid to ProcCall
2524125265 {
2524225266 // copy mutable arguments back from call to reportid
2524325267 fprintf(stderr, "%s", "\n");
2524425268 exit(-1);
25245- label = 2082LLU; // consequent complete
25269+ label = 2084LLU; // consequent complete
2524625270 break;
2524725271 }
25248- case 2081LLU: // alternative
25272+ case 2083LLU: // alternative
2524925273 {
25250- label = 2082LLU; // alternative complete
25274+ label = 2084LLU; // alternative complete
2525125275 break;
2525225276 }
25253- case 2082LLU: // completed if-then-else
25277+ case 2084LLU: // completed if-then-else
2525425278 {
25255- label = 2090LLU; // skip deleter
25279+ label = 2092LLU; // skip deleter
2525625280 break;
2525725281 }
25258- case 2089LLU: // deleter
25282+ case 2091LLU: // deleter
2525925283 {
2526025284 // throw from ProcCall
2526125285 if(!stack[base + 43])
2526225286 {
2526325287 fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
25264- label = 2056LLU; // skip, variable already deleted/unscoped
25288+ label = 2058LLU; // skip, variable already deleted/unscoped
2526525289 break;
2526625290 }
2526725291 fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");
@@ -25271,7 +25295,7 @@
2527125295 newstack[0] = (uint64_t)stack; // backup stack location
2527225296 newstack[1] = 1234567890;
2527325297 newstack[2] = base;
25274- newstack[3] = 2091LLU;
25298+ newstack[3] = 2093LLU;
2527525299 stack = newstack;
2527625300 // set stack-base & callee-address
2527725301 base = 4/*deloffset*/;
@@ -25278,21 +25302,21 @@
2527825302 label = 798LLU; // ~idnr
2527925303 break;
2528025304 }
25281- case 2091LLU: // return from ~idnr to ProcCall
25305+ case 2093LLU: // return from ~idnr to ProcCall
2528225306 {
2528325307 stack = (uint64_t *)stack[0];
2528425308 // releasing toplevel container
2528525309 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2528625310
25287- label = 2056LLU; // continue unrolling stack, delete next variable
25311+ label = 2058LLU; // continue unrolling stack, delete next variable
2528825312 break;
2528925313 }
25290- case 2090LLU: // skipped deleter
25314+ case 2092LLU: // skipped deleter
2529125315 {
2529225316 // construct idnr.idnr
2529325317 if(!(stack[base + 43] = construct(2)))
2529425318 {
25295- label = 2056LLU; // throw: begin to unroll stack
25319+ label = 2058LLU; // throw: begin to unroll stack
2529625320 break;
2529725321 }
2529825322
@@ -25311,16 +25335,16 @@
2531125335 stack[base + 19]/*copyback*/ = (uint64_t)list;
2531225336 MOVE(&list->data, &stack[base + 43]/*idnr*/);
2531325337 }
25314- label = 2078LLU; // consequent complete
25338+ label = 2080LLU; // consequent complete
2531525339 break;
2531625340 }
25317- case 2077LLU: // alternative
25341+ case 2079LLU: // alternative
2531825342 {
2531925343 fprintf(stderr, "%s", "in function ");
2532025344 // call reportid from ProcCall
25321- stack[base + 43LLU] = 2092LLU/*throw to this address*/;
25345+ stack[base + 43LLU] = 2094LLU/*throw to this address*/;
2532225346 stack[base + 44LLU] = base;
25323- stack[base + 45LLU] = 2093LLU;
25347+ stack[base + 45LLU] = 2095LLU;
2532425348 // arguments for call to reportid
2532525349 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2532625350 // set stack-base & callee-address
@@ -25328,21 +25352,21 @@
2532825352 label = 18446744073709551586LLU; // reportid
2532925353 break;
2533025354 }
25331- case 2092LLU: // copy-back deleter (reportid to ProcCall)
25355+ case 2094LLU: // copy-back deleter (reportid to ProcCall)
2533225356 {
2533325357 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2533425358 // copy mutable arguments back from call to reportid
25335- label = 2056LLU; // continue to roll stack
25359+ label = 2058LLU; // continue to roll stack
2533625360 break;
2533725361 }
25338- case 2093LLU: // return from reportid to ProcCall
25362+ case 2095LLU: // return from reportid to ProcCall
2533925363 {
2534025364 // copy mutable arguments back from call to reportid
2534125365 fprintf(stderr, "%s", ", call to ");
2534225366 // call reportid from ProcCall
25343- stack[base + 43LLU] = 2094LLU/*throw to this address*/;
25367+ stack[base + 43LLU] = 2096LLU/*throw to this address*/;
2534425368 stack[base + 44LLU] = base;
25345- stack[base + 45LLU] = 2095LLU;
25369+ stack[base + 45LLU] = 2097LLU;
2534625370 // arguments for call to reportid
2534725371 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2534825372 // set stack-base & callee-address
@@ -25350,14 +25374,14 @@
2535025374 label = 18446744073709551586LLU; // reportid
2535125375 break;
2535225376 }
25353- case 2094LLU: // copy-back deleter (reportid to ProcCall)
25377+ case 2096LLU: // copy-back deleter (reportid to ProcCall)
2535425378 {
2535525379 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2535625380 // copy mutable arguments back from call to reportid
25357- label = 2056LLU; // continue to roll stack
25381+ label = 2058LLU; // continue to roll stack
2535825382 break;
2535925383 }
25360- case 2095LLU: // return from reportid to ProcCall
25384+ case 2097LLU: // return from reportid to ProcCall
2536125385 {
2536225386 // copy mutable arguments back from call to reportid
2536325387 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -25364,7 +25388,7 @@
2536425388 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2536525389 if(!newstack)
2536625390 {
25367- label = 2056LLU; // throw: begin to unroll stack
25391+ label = 2058LLU; // throw: begin to unroll stack
2536825392 break;
2536925393 }
2537025394
@@ -25371,9 +25395,9 @@
2537125395 newstack[10LLU] = 9876543210LLU; // overflow-marker
2537225396 // call reporttype from ProcCall
2537325397 newstack[0] = (uint64_t)stack; // backup stack location
25374- newstack[1] = 2096LLU;
25398+ newstack[1] = 2098LLU;
2537525399 newstack[2] = base;
25376- newstack[3] = 2097LLU;
25400+ newstack[3] = 2099LLU;
2537725401 // arguments for call to reporttype
2537825402 newstack[4LLU] = stack[base + 41]/*type*/;
2537925403 stack = newstack;
@@ -25382,7 +25406,7 @@
2538225406 label = 316LLU; // reporttype
2538325407 break;
2538425408 }
25385- case 2096LLU: // copy-back deleter (reporttype to ProcCall)
25409+ case 2098LLU: // copy-back deleter (reporttype to ProcCall)
2538625410 {
2538725411 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2538825412 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -25394,10 +25418,10 @@
2539425418 }
2539525419 Free(10LLU + 1, sizeof(uint64_t), stack);
2539625420 stack = oldstack;
25397- label = 2056LLU; // continue to unroll stack
25421+ label = 2058LLU; // continue to unroll stack
2539825422 break;
2539925423 }
25400- case 2097LLU: // return from reporttype to ProcCall
25424+ case 2099LLU: // return from reporttype to ProcCall
2540125425 {
2540225426 uint64_t *oldstack = (uint64_t *)stack[0];
2540325427 // copy mutable arguments back from call to reporttype
@@ -25410,9 +25434,9 @@
2541025434 stack = oldstack;
2541125435 fprintf(stderr, "%s", " ");
2541225436 // call reportid from ProcCall
25413- stack[base + 43LLU] = 2098LLU/*throw to this address*/;
25437+ stack[base + 43LLU] = 2100LLU/*throw to this address*/;
2541425438 stack[base + 44LLU] = base;
25415- stack[base + 45LLU] = 2099LLU;
25439+ stack[base + 45LLU] = 2101LLU;
2541625440 // arguments for call to reportid
2541725441 stack[base + 46LLU] = stack[base + 16]/*content*/;
2541825442 // set stack-base & callee-address
@@ -25420,14 +25444,14 @@
2542025444 label = 18446744073709551586LLU; // reportid
2542125445 break;
2542225446 }
25423- case 2098LLU: // copy-back deleter (reportid to ProcCall)
25447+ case 2100LLU: // copy-back deleter (reportid to ProcCall)
2542425448 {
2542525449 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2542625450 // copy mutable arguments back from call to reportid
25427- label = 2056LLU; // continue to roll stack
25451+ label = 2058LLU; // continue to roll stack
2542825452 break;
2542925453 }
25430- case 2099LLU: // return from reportid to ProcCall
25454+ case 2101LLU: // return from reportid to ProcCall
2543125455 {
2543225456 // copy mutable arguments back from call to reportid
2543325457 fprintf(stderr, "%s", " into mutable parameter ");
@@ -25434,7 +25458,7 @@
2543425458 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2543525459 if(!newstack)
2543625460 {
25437- label = 2056LLU; // throw: begin to unroll stack
25461+ label = 2058LLU; // throw: begin to unroll stack
2543825462 break;
2543925463 }
2544025464
@@ -25441,9 +25465,9 @@
2544125465 newstack[10LLU] = 9876543210LLU; // overflow-marker
2544225466 // call reporttype from ProcCall
2544325467 newstack[0] = (uint64_t)stack; // backup stack location
25444- newstack[1] = 2100LLU;
25468+ newstack[1] = 2102LLU;
2544525469 newstack[2] = base;
25446- newstack[3] = 2101LLU;
25470+ newstack[3] = 2103LLU;
2544725471 // arguments for call to reporttype
2544825472 newstack[4LLU] = stack[base + 39]/*expected*/;
2544925473 stack = newstack;
@@ -25452,7 +25476,7 @@
2545225476 label = 316LLU; // reporttype
2545325477 break;
2545425478 }
25455- case 2100LLU: // copy-back deleter (reporttype to ProcCall)
25479+ case 2102LLU: // copy-back deleter (reporttype to ProcCall)
2545625480 {
2545725481 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2545825482 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -25464,10 +25488,10 @@
2546425488 }
2546525489 Free(10LLU + 1, sizeof(uint64_t), stack);
2546625490 stack = oldstack;
25467- label = 2056LLU; // continue to unroll stack
25491+ label = 2058LLU; // continue to unroll stack
2546825492 break;
2546925493 }
25470- case 2101LLU: // return from reporttype to ProcCall
25494+ case 2103LLU: // return from reporttype to ProcCall
2547125495 {
2547225496 uint64_t *oldstack = (uint64_t *)stack[0];
2547325497 // copy mutable arguments back from call to reporttype
@@ -25479,9 +25503,9 @@
2547925503 Free(10LLU + 1, sizeof(uint64_t), stack);
2548025504 stack = oldstack;
2548125505 // call reportid from ProcCall
25482- stack[base + 43LLU] = 2102LLU/*throw to this address*/;
25506+ stack[base + 43LLU] = 2104LLU/*throw to this address*/;
2548325507 stack[base + 44LLU] = base;
25484- stack[base + 45LLU] = 2103LLU;
25508+ stack[base + 45LLU] = 2105LLU;
2548525509 // arguments for call to reportid
2548625510 stack[base + 46LLU] = stack[base + 40]/*paramname*/;
2548725511 // set stack-base & callee-address
@@ -25489,32 +25513,32 @@
2548925513 label = 18446744073709551586LLU; // reportid
2549025514 break;
2549125515 }
25492- case 2102LLU: // copy-back deleter (reportid to ProcCall)
25516+ case 2104LLU: // copy-back deleter (reportid to ProcCall)
2549325517 {
2549425518 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2549525519 // copy mutable arguments back from call to reportid
25496- label = 2056LLU; // continue to roll stack
25520+ label = 2058LLU; // continue to roll stack
2549725521 break;
2549825522 }
25499- case 2103LLU: // return from reportid to ProcCall
25523+ case 2105LLU: // return from reportid to ProcCall
2550025524 {
2550125525 // copy mutable arguments back from call to reportid
2550225526 fprintf(stderr, "%s", "\n");
2550325527 exit(-1);
25504- label = 2078LLU; // alternative complete
25528+ label = 2080LLU; // alternative complete
2550525529 break;
2550625530 }
25507- case 2078LLU: // completed if-then-else
25531+ case 2080LLU: // completed if-then-else
2550825532 {
25509- label = 2076LLU; // consequent complete
25533+ label = 2078LLU; // consequent complete
2551025534 break;
2551125535 }
25512- case 2075LLU: // alternative
25536+ case 2077LLU: // alternative
2551325537 {
25514- label = 2076LLU; // alternative complete
25538+ label = 2078LLU; // alternative complete
2551525539 break;
2551625540 }
25517- case 2076LLU: // completed if-then-else
25541+ case 2078LLU: // completed if-then-else
2551825542 {
2551925543
2552025544 uint64_t *newstack = (uint64_t *)(stack[base + 41] - sizeof(uint64_t) * 4);
@@ -25522,7 +25546,7 @@
2552225546 newstack[0] = (uint64_t)stack; // backup stack location
2552325547 newstack[1] = 1234567890;
2552425548 newstack[2] = base;
25525- newstack[3] = 2104LLU;
25549+ newstack[3] = 2106LLU;
2552625550 stack = newstack;
2552725551 // set stack-base & callee-address
2552825552 base = 4/*deloffset*/;
@@ -25529,7 +25553,7 @@
2552925553 label = 296LLU; // ~type
2553025554 break;
2553125555 }
25532- case 2104LLU: // return from ~type to ProcCall
25556+ case 2106LLU: // return from ~type to ProcCall
2553325557 {
2553425558 stack = (uint64_t *)stack[0];
2553525559 // releasing toplevel container
@@ -25537,28 +25561,28 @@
2553725561
2553825562 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2553925563 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
25540- label = 2054LLU; // case complete
25564+ label = 2056LLU; // case complete
2554125565 break;
2554225566 }
25543- case 2056LLU: // copy-back deleter (switch)
25567+ case 2058LLU: // copy-back deleter (switch)
2554425568 {
2554525569 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2554625570 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
25547- label = 2053LLU; // continue to unroll stack
25571+ label = 2055LLU; // continue to unroll stack
2554825572 break;
2554925573 }
25550- case 2055LLU: // try next case
25574+ case 2057LLU: // try next case
2555125575 {
2555225576 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2555325577 exit(-1);
2555425578 }
25555- case 2054LLU: // completed switch
25579+ case 2056LLU: // completed switch
2555625580 {
2555725581 printf("%s", "\n stack[base + ");
2555825582 // call printnr from ProcCall
25559- stack[base + 39LLU] = 2105LLU/*throw to this address*/;
25583+ stack[base + 39LLU] = 2107LLU/*throw to this address*/;
2556025584 stack[base + 40LLU] = base;
25561- stack[base + 41LLU] = 2106LLU;
25585+ stack[base + 41LLU] = 2108LLU;
2556225586 // arguments for call to printnr
2556325587 stack[base + 42LLU] = stack[base + 30]/*sum*/;
2556425588 // set stack-base & callee-address
@@ -25566,21 +25590,21 @@
2556625590 label = 18446744073709551590LLU; // printnr
2556725591 break;
2556825592 }
25569- case 2105LLU: // copy-back deleter (printnr to ProcCall)
25593+ case 2107LLU: // copy-back deleter (printnr to ProcCall)
2557025594 {
2557125595 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2557225596 // copy mutable arguments back from call to printnr
25573- label = 2053LLU; // continue to roll stack
25597+ label = 2055LLU; // continue to roll stack
2557425598 break;
2557525599 }
25576- case 2106LLU: // return from printnr to ProcCall
25600+ case 2108LLU: // return from printnr to ProcCall
2557725601 {
2557825602 // copy mutable arguments back from call to printnr
2557925603 printf("%s", "LLU] = ");
2558025604 // call emitvar from ProcCall
25581- stack[base + 39LLU] = 2107LLU/*throw to this address*/;
25605+ stack[base + 39LLU] = 2109LLU/*throw to this address*/;
2558225606 stack[base + 40LLU] = base;
25583- stack[base + 41LLU] = 2108LLU;
25607+ stack[base + 41LLU] = 2110LLU;
2558425608 // arguments for call to emitvar
2558525609 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2558625610 stack[base + 43LLU] = stack[base + 16]/*content*/;
@@ -25591,46 +25615,46 @@
2559125615 label = 695LLU; // emitvar
2559225616 break;
2559325617 }
25594- case 2107LLU: // copy-back deleter (emitvar to ProcCall)
25618+ case 2109LLU: // copy-back deleter (emitvar to ProcCall)
2559525619 {
2559625620 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2559725621 // copy mutable arguments back from call to emitvar
25598- label = 2053LLU; // continue to roll stack
25622+ label = 2055LLU; // continue to roll stack
2559925623 break;
2560025624 }
25601- case 2108LLU: // return from emitvar to ProcCall
25625+ case 2110LLU: // return from emitvar to ProcCall
2560225626 {
2560325627 // copy mutable arguments back from call to emitvar
2560425628 printf("%s", ";");
2560525629 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
2560625630 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
25607- label = 2051LLU; // case complete
25631+ label = 2053LLU; // case complete
2560825632 break;
2560925633 }
25610- case 2053LLU: // copy-back deleter (switch)
25634+ case 2055LLU: // copy-back deleter (switch)
2561125635 {
2561225636 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
2561325637 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
25614- label = 1985LLU; // continue to unroll stack
25638+ label = 1987LLU; // continue to unroll stack
2561525639 break;
2561625640 }
25617- case 2052LLU: // try next case
25641+ case 2054LLU: // try next case
2561825642 {
2561925643 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2562025644 exit(-1);
2562125645 }
25622- case 2051LLU: // completed switch
25646+ case 2053LLU: // completed switch
2562325647 {
25624- label = 2050LLU; // consequent complete
25648+ label = 2052LLU; // consequent complete
2562525649 break;
2562625650 }
25627- case 2049LLU: // alternative
25651+ case 2051LLU: // alternative
2562825652 {
2562925653 fprintf(stderr, "%s", "expected identifier or constant argument but found ");
2563025654 // call printtoken from ProcCall
25631- stack[base + 37LLU] = 2109LLU/*throw to this address*/;
25655+ stack[base + 37LLU] = 2111LLU/*throw to this address*/;
2563225656 stack[base + 38LLU] = base;
25633- stack[base + 39LLU] = 2110LLU;
25657+ stack[base + 39LLU] = 2112LLU;
2563425658 // arguments for call to printtoken
2563525659 stack[base + 40LLU] = stack[base + 15]/*variant*/;
2563625660 stack[base + 41LLU] = stack[base + 16]/*content*/;
@@ -25639,46 +25663,46 @@
2563925663 label = 18446744073709551583LLU; // printtoken
2564025664 break;
2564125665 }
25642- case 2109LLU: // copy-back deleter (printtoken to ProcCall)
25666+ case 2111LLU: // copy-back deleter (printtoken to ProcCall)
2564325667 {
2564425668 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n");
2564525669 // copy mutable arguments back from call to printtoken
25646- label = 1985LLU; // continue to roll stack
25670+ label = 1987LLU; // continue to roll stack
2564725671 break;
2564825672 }
25649- case 2110LLU: // return from printtoken to ProcCall
25673+ case 2112LLU: // return from printtoken to ProcCall
2565025674 {
2565125675 // copy mutable arguments back from call to printtoken
2565225676 fprintf(stderr, "%s", "\n");
2565325677 exit(-1);
25654- label = 2050LLU; // alternative complete
25678+ label = 2052LLU; // alternative complete
2565525679 break;
2565625680 }
25657- case 2050LLU: // completed if-then-else
25681+ case 2052LLU: // completed if-then-else
2565825682 {
25659- label = 2011LLU; // alternative complete
25683+ label = 2013LLU; // alternative complete
2566025684 break;
2566125685 }
25662- case 2011LLU: // completed if-then-else
25686+ case 2013LLU: // completed if-then-else
2566325687 {
2566425688 ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
25665- label = 1983LLU; // repeat
25689+ label = 1985LLU; // repeat
2566625690 break;
2566725691 }
25668- case 1985LLU: // copy-back deleter for while next
25692+ case 1987LLU: // copy-back deleter for while next
2566925693 {
2567025694 ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
25671- label = 1939LLU; // continue to unroll stack
25695+ label = 1941LLU; // continue to unroll stack
2567225696 break;
2567325697 }
25674- case 1984LLU: // loop finished
25698+ case 1986LLU: // loop finished
2567525699 {
2567625700 printf("%s", "\n // set stack-base & callee-address");
2567725701 stack[base + 30]/*sum*/ = 0;
2567825702 // call add from ProcCall
25679- stack[base + 34LLU] = 2111LLU/*throw to this address*/;
25703+ stack[base + 34LLU] = 2113LLU/*throw to this address*/;
2568025704 stack[base + 35LLU] = base;
25681- stack[base + 36LLU] = 2112LLU;
25705+ stack[base + 36LLU] = 2114LLU;
2568225706 // arguments for call to add
2568325707 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2568425708 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -25687,22 +25711,22 @@
2568725711 label = 18446744073709551605LLU; // add
2568825712 break;
2568925713 }
25690- case 2111LLU: // copy-back deleter (add to ProcCall)
25714+ case 2113LLU: // copy-back deleter (add to ProcCall)
2569125715 {
2569225716 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2569325717 // copy mutable arguments back from call to add
25694- label = 1939LLU; // continue to roll stack
25718+ label = 1941LLU; // continue to roll stack
2569525719 break;
2569625720 }
25697- case 2112LLU: // return from add to ProcCall
25721+ case 2114LLU: // return from add to ProcCall
2569825722 {
2569925723 // copy mutable arguments back from call to add
2570025724 // copy back results provided by call to add
2570125725 stack[base + 30] = stack[base + 37LLU];
2570225726 // call add from ProcCall
25703- stack[base + 34LLU] = 2113LLU/*throw to this address*/;
25727+ stack[base + 34LLU] = 2115LLU/*throw to this address*/;
2570425728 stack[base + 35LLU] = base;
25705- stack[base + 36LLU] = 2114LLU;
25729+ stack[base + 36LLU] = 2116LLU;
2570625730 // arguments for call to add
2570725731 stack[base + 38LLU] = 3LLU;
2570825732 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -25711,22 +25735,22 @@
2571125735 label = 18446744073709551605LLU; // add
2571225736 break;
2571325737 }
25714- case 2113LLU: // copy-back deleter (add to ProcCall)
25738+ case 2115LLU: // copy-back deleter (add to ProcCall)
2571525739 {
2571625740 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2571725741 // copy mutable arguments back from call to add
25718- label = 1939LLU; // continue to roll stack
25742+ label = 1941LLU; // continue to roll stack
2571925743 break;
2572025744 }
25721- case 2114LLU: // return from add to ProcCall
25745+ case 2116LLU: // return from add to ProcCall
2572225746 {
2572325747 // copy mutable arguments back from call to add
2572425748 // copy back results provided by call to add
2572525749 stack[base + 30] = stack[base + 37LLU];
2572625750 // call add from ProcCall
25727- stack[base + 34LLU] = 2115LLU/*throw to this address*/;
25751+ stack[base + 34LLU] = 2117LLU/*throw to this address*/;
2572825752 stack[base + 35LLU] = base;
25729- stack[base + 36LLU] = 2116LLU;
25753+ stack[base + 36LLU] = 2118LLU;
2573025754 // arguments for call to add
2573125755 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
2573225756 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -25735,22 +25759,22 @@
2573525759 label = 18446744073709551605LLU; // add
2573625760 break;
2573725761 }
25738- case 2115LLU: // copy-back deleter (add to ProcCall)
25762+ case 2117LLU: // copy-back deleter (add to ProcCall)
2573925763 {
2574025764 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2574125765 // copy mutable arguments back from call to add
25742- label = 1939LLU; // continue to roll stack
25766+ label = 1941LLU; // continue to roll stack
2574325767 break;
2574425768 }
25745- case 2116LLU: // return from add to ProcCall
25769+ case 2118LLU: // return from add to ProcCall
2574625770 {
2574725771 // copy mutable arguments back from call to add
2574825772 // copy back results provided by call to add
2574925773 stack[base + 30] = stack[base + 37LLU];
2575025774 // call add from ProcCall
25751- stack[base + 34LLU] = 2117LLU/*throw to this address*/;
25775+ stack[base + 34LLU] = 2119LLU/*throw to this address*/;
2575225776 stack[base + 35LLU] = base;
25753- stack[base + 36LLU] = 2118LLU;
25777+ stack[base + 36LLU] = 2120LLU;
2575425778 // arguments for call to add
2575525779 stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
2575625780 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -25759,14 +25783,14 @@
2575925783 label = 18446744073709551605LLU; // add
2576025784 break;
2576125785 }
25762- case 2117LLU: // copy-back deleter (add to ProcCall)
25786+ case 2119LLU: // copy-back deleter (add to ProcCall)
2576325787 {
2576425788 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2576525789 // copy mutable arguments back from call to add
25766- label = 1939LLU; // continue to roll stack
25790+ label = 1941LLU; // continue to roll stack
2576725791 break;
2576825792 }
25769- case 2118LLU: // return from add to ProcCall
25793+ case 2120LLU: // return from add to ProcCall
2577025794 {
2577125795 // copy mutable arguments back from call to add
2577225796 // copy back results provided by call to add
@@ -25773,9 +25797,9 @@
2577325797 stack[base + 30] = stack[base + 37LLU];
2577425798 printf("%s", "\n base += ");
2577525799 // call printnr from ProcCall
25776- stack[base + 34LLU] = 2119LLU/*throw to this address*/;
25800+ stack[base + 34LLU] = 2121LLU/*throw to this address*/;
2577725801 stack[base + 35LLU] = base;
25778- stack[base + 36LLU] = 2120LLU;
25802+ stack[base + 36LLU] = 2122LLU;
2577925803 // arguments for call to printnr
2578025804 stack[base + 37LLU] = stack[base + 30]/*sum*/;
2578125805 // set stack-base & callee-address
@@ -25783,22 +25807,22 @@
2578325807 label = 18446744073709551590LLU; // printnr
2578425808 break;
2578525809 }
25786- case 2119LLU: // copy-back deleter (printnr to ProcCall)
25810+ case 2121LLU: // copy-back deleter (printnr to ProcCall)
2578725811 {
2578825812 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2578925813 // copy mutable arguments back from call to printnr
25790- label = 1939LLU; // continue to roll stack
25814+ label = 1941LLU; // continue to roll stack
2579125815 break;
2579225816 }
25793- case 2120LLU: // return from printnr to ProcCall
25817+ case 2122LLU: // return from printnr to ProcCall
2579425818 {
2579525819 // copy mutable arguments back from call to printnr
2579625820 printf("%s", "LLU;");
2579725821 printf("%s", "\n label = ");
2579825822 // call printnr from ProcCall
25799- stack[base + 34LLU] = 2121LLU/*throw to this address*/;
25823+ stack[base + 34LLU] = 2123LLU/*throw to this address*/;
2580025824 stack[base + 35LLU] = base;
25801- stack[base + 36LLU] = 2122LLU;
25825+ stack[base + 36LLU] = 2124LLU;
2580225826 // arguments for call to printnr
2580325827 stack[base + 37LLU] = stack[base + 20]/*celabel*/;
2580425828 // set stack-base & callee-address
@@ -25806,21 +25830,21 @@
2580625830 label = 18446744073709551590LLU; // printnr
2580725831 break;
2580825832 }
25809- case 2121LLU: // copy-back deleter (printnr to ProcCall)
25833+ case 2123LLU: // copy-back deleter (printnr to ProcCall)
2581025834 {
2581125835 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2581225836 // copy mutable arguments back from call to printnr
25813- label = 1939LLU; // continue to roll stack
25837+ label = 1941LLU; // continue to roll stack
2581425838 break;
2581525839 }
25816- case 2122LLU: // return from printnr to ProcCall
25840+ case 2124LLU: // return from printnr to ProcCall
2581725841 {
2581825842 // copy mutable arguments back from call to printnr
2581925843 printf("%s", "LLU; // ");
2582025844 // call printid from ProcCall
25821- stack[base + 34LLU] = 2123LLU/*throw to this address*/;
25845+ stack[base + 34LLU] = 2125LLU/*throw to this address*/;
2582225846 stack[base + 35LLU] = base;
25823- stack[base + 36LLU] = 2124LLU;
25847+ stack[base + 36LLU] = 2126LLU;
2582425848 // arguments for call to printid
2582525849 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2582625850 // set stack-base & callee-address
@@ -25828,14 +25852,14 @@
2582825852 label = 18446744073709551587LLU; // printid
2582925853 break;
2583025854 }
25831- case 2123LLU: // copy-back deleter (printid to ProcCall)
25855+ case 2125LLU: // copy-back deleter (printid to ProcCall)
2583225856 {
2583325857 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2583425858 // copy mutable arguments back from call to printid
25835- label = 1939LLU; // continue to roll stack
25859+ label = 1941LLU; // continue to roll stack
2583625860 break;
2583725861 }
25838- case 2124LLU: // return from printid to ProcCall
25862+ case 2126LLU: // return from printid to ProcCall
2583925863 {
2584025864 // copy mutable arguments back from call to printid
2584125865 printf("%s", "\n break;");
@@ -25842,7 +25866,7 @@
2584225866 printf("%s", "\n }");
2584325867 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2584425868 {
25845- label = 2126LLU; // jump to alternative
25869+ label = 2128LLU; // jump to alternative
2584625870 break;
2584725871 }
2584825872
@@ -25852,9 +25876,9 @@
2585225876 // case
2585325877 printf("%s", "\n case ");
2585425878 // call printnr from ProcCall
25855- stack[base + 36LLU] = 2128LLU/*throw to this address*/;
25879+ stack[base + 36LLU] = 2130LLU/*throw to this address*/;
2585625880 stack[base + 37LLU] = base;
25857- stack[base + 38LLU] = 2129LLU;
25881+ stack[base + 38LLU] = 2131LLU;
2585825882 // arguments for call to printnr
2585925883 stack[base + 39LLU] = stack[base + 33]/*labelfail*/;
2586025884 // set stack-base & callee-address
@@ -25862,21 +25886,21 @@
2586225886 label = 18446744073709551590LLU; // printnr
2586325887 break;
2586425888 }
25865- case 2128LLU: // copy-back deleter (printnr to ProcCall)
25889+ case 2130LLU: // copy-back deleter (printnr to ProcCall)
2586625890 {
2586725891 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2586825892 // copy mutable arguments back from call to printnr
25869- label = 2127LLU; // continue to roll stack
25893+ label = 2129LLU; // continue to roll stack
2587025894 break;
2587125895 }
25872- case 2129LLU: // return from printnr to ProcCall
25896+ case 2131LLU: // return from printnr to ProcCall
2587325897 {
2587425898 // copy mutable arguments back from call to printnr
2587525899 printf("%s", "LLU: // copy-back deleter (");
2587625900 // call printid from ProcCall
25877- stack[base + 36LLU] = 2130LLU/*throw to this address*/;
25901+ stack[base + 36LLU] = 2132LLU/*throw to this address*/;
2587825902 stack[base + 37LLU] = base;
25879- stack[base + 38LLU] = 2131LLU;
25903+ stack[base + 38LLU] = 2133LLU;
2588025904 // arguments for call to printid
2588125905 stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2588225906 // set stack-base & callee-address
@@ -25884,21 +25908,21 @@
2588425908 label = 18446744073709551587LLU; // printid
2588525909 break;
2588625910 }
25887- case 2130LLU: // copy-back deleter (printid to ProcCall)
25911+ case 2132LLU: // copy-back deleter (printid to ProcCall)
2588825912 {
2588925913 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2589025914 // copy mutable arguments back from call to printid
25891- label = 2127LLU; // continue to roll stack
25915+ label = 2129LLU; // continue to roll stack
2589225916 break;
2589325917 }
25894- case 2131LLU: // return from printid to ProcCall
25918+ case 2133LLU: // return from printid to ProcCall
2589525919 {
2589625920 // copy mutable arguments back from call to printid
2589725921 printf("%s", " to ");
2589825922 // call printid from ProcCall
25899- stack[base + 36LLU] = 2132LLU/*throw to this address*/;
25923+ stack[base + 36LLU] = 2134LLU/*throw to this address*/;
2590025924 stack[base + 37LLU] = base;
25901- stack[base + 38LLU] = 2133LLU;
25925+ stack[base + 38LLU] = 2135LLU;
2590225926 // arguments for call to printid
2590325927 stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2590425928 // set stack-base & callee-address
@@ -25906,14 +25930,14 @@
2590625930 label = 18446744073709551587LLU; // printid
2590725931 break;
2590825932 }
25909- case 2132LLU: // copy-back deleter (printid to ProcCall)
25933+ case 2134LLU: // copy-back deleter (printid to ProcCall)
2591025934 {
2591125935 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2591225936 // copy mutable arguments back from call to printid
25913- label = 2127LLU; // continue to roll stack
25937+ label = 2129LLU; // continue to roll stack
2591425938 break;
2591525939 }
25916- case 2133LLU: // return from printid to ProcCall
25940+ case 2135LLU: // return from printid to ProcCall
2591725941 {
2591825942 // copy mutable arguments back from call to printid
2591925943 printf("%s", ")");
@@ -25920,9 +25944,9 @@
2592025944 printf("%s", "\n {");
2592125945 printf("%s", "\n fprintf(stderr, \"in function ");
2592225946 // call printid from ProcCall
25923- stack[base + 36LLU] = 2134LLU/*throw to this address*/;
25947+ stack[base + 36LLU] = 2136LLU/*throw to this address*/;
2592425948 stack[base + 37LLU] = base;
25925- stack[base + 38LLU] = 2135LLU;
25949+ stack[base + 38LLU] = 2137LLU;
2592625950 // arguments for call to printid
2592725951 stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2592825952 // set stack-base & callee-address
@@ -25930,21 +25954,21 @@
2593025954 label = 18446744073709551587LLU; // printid
2593125955 break;
2593225956 }
25933- case 2134LLU: // copy-back deleter (printid to ProcCall)
25957+ case 2136LLU: // copy-back deleter (printid to ProcCall)
2593425958 {
2593525959 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2593625960 // copy mutable arguments back from call to printid
25937- label = 2127LLU; // continue to roll stack
25961+ label = 2129LLU; // continue to roll stack
2593825962 break;
2593925963 }
25940- case 2135LLU: // return from printid to ProcCall
25964+ case 2137LLU: // return from printid to ProcCall
2594125965 {
2594225966 // copy mutable arguments back from call to printid
2594325967 printf("%s", ": unrolling stack, copy-back (");
2594425968 // call printid from ProcCall
25945- stack[base + 36LLU] = 2136LLU/*throw to this address*/;
25969+ stack[base + 36LLU] = 2138LLU/*throw to this address*/;
2594625970 stack[base + 37LLU] = base;
25947- stack[base + 38LLU] = 2137LLU;
25971+ stack[base + 38LLU] = 2139LLU;
2594825972 // arguments for call to printid
2594925973 stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2595025974 // set stack-base & callee-address
@@ -25952,21 +25976,21 @@
2595225976 label = 18446744073709551587LLU; // printid
2595325977 break;
2595425978 }
25955- case 2136LLU: // copy-back deleter (printid to ProcCall)
25979+ case 2138LLU: // copy-back deleter (printid to ProcCall)
2595625980 {
2595725981 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2595825982 // copy mutable arguments back from call to printid
25959- label = 2127LLU; // continue to roll stack
25983+ label = 2129LLU; // continue to roll stack
2596025984 break;
2596125985 }
25962- case 2137LLU: // return from printid to ProcCall
25986+ case 2139LLU: // return from printid to ProcCall
2596325987 {
2596425988 // copy mutable arguments back from call to printid
2596525989 printf("%s", " to ");
2596625990 // call printid from ProcCall
25967- stack[base + 36LLU] = 2138LLU/*throw to this address*/;
25991+ stack[base + 36LLU] = 2140LLU/*throw to this address*/;
2596825992 stack[base + 37LLU] = base;
25969- stack[base + 38LLU] = 2139LLU;
25993+ stack[base + 38LLU] = 2141LLU;
2597025994 // arguments for call to printid
2597125995 stack[base + 39LLU] = stack[base + 8]/*fnid*/;
2597225996 // set stack-base & callee-address
@@ -25974,14 +25998,14 @@
2597425998 label = 18446744073709551587LLU; // printid
2597525999 break;
2597626000 }
25977- case 2138LLU: // copy-back deleter (printid to ProcCall)
26001+ case 2140LLU: // copy-back deleter (printid to ProcCall)
2597826002 {
2597926003 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2598026004 // copy mutable arguments back from call to printid
25981- label = 2127LLU; // continue to roll stack
26005+ label = 2129LLU; // continue to roll stack
2598226006 break;
2598326007 }
25984- case 2139LLU: // return from printid to ProcCall
26008+ case 2141LLU: // return from printid to ProcCall
2598526009 {
2598626010 // copy mutable arguments back from call to printid
2598726011 printf("%s", ")");
@@ -25988,9 +26012,9 @@
2598826012 printf("%s", "\\n\");");
2598926013 printf("%s", "\n // copy mutable arguments back from call to ");
2599026014 // call printid from ProcCall
25991- stack[base + 36LLU] = 2140LLU/*throw to this address*/;
26015+ stack[base + 36LLU] = 2142LLU/*throw to this address*/;
2599226016 stack[base + 37LLU] = base;
25993- stack[base + 38LLU] = 2141LLU;
26017+ stack[base + 38LLU] = 2143LLU;
2599426018 // arguments for call to printid
2599526019 stack[base + 39LLU] = stack[base + 24]/*ceid*/;
2599626020 // set stack-base & callee-address
@@ -25998,25 +26022,25 @@
2599826022 label = 18446744073709551587LLU; // printid
2599926023 break;
2600026024 }
26001- case 2140LLU: // copy-back deleter (printid to ProcCall)
26025+ case 2142LLU: // copy-back deleter (printid to ProcCall)
2600226026 {
2600326027 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2600426028 // copy mutable arguments back from call to printid
26005- label = 2127LLU; // continue to roll stack
26029+ label = 2129LLU; // continue to roll stack
2600626030 break;
2600726031 }
26008- case 2141LLU: // return from printid to ProcCall
26032+ case 2143LLU: // return from printid to ProcCall
2600926033 {
2601026034 // copy mutable arguments back from call to printid
2601126035 flippedassign(stack[base + 19]/*copyback*/, &stack[base + 36]);
26012- label = 2142LLU; // start to repeat
26036+ label = 2144LLU; // start to repeat
2601326037 break;
2601426038 }
26015- case 2142LLU: // repeat from here
26039+ case 2144LLU: // repeat from here
2601626040 {
2601726041 if(!stack[base + 36])
2601826042 {
26019- label = 2143LLU; // break loop
26043+ label = 2145LLU; // break loop
2602026044 break;
2602126045 }
2602226046
@@ -26026,7 +26050,7 @@
2602626050 stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
2602726051 if(/*idnr*/0 != ((uint64_t *)(stack[base + 37]/*idnr*/))[0])
2602826052 {
26029- label = 2146LLU; // jump to alternative
26053+ label = 2148LLU; // jump to alternative
2603026054 break;
2603126055 }
2603226056
@@ -26036,9 +26060,9 @@
2603626060 // case
2603726061 printf("%s", "\n ");
2603826062 // call emitvar from ProcCall
26039- stack[base + 41LLU] = 2148LLU/*throw to this address*/;
26063+ stack[base + 41LLU] = 2150LLU/*throw to this address*/;
2604026064 stack[base + 42LLU] = base;
26041- stack[base + 43LLU] = 2149LLU;
26065+ stack[base + 43LLU] = 2151LLU;
2604226066 // arguments for call to emitvar
2604326067 stack[base + 44LLU] = stack[base + 8]/*fnid*/;
2604426068 stack[base + 45LLU] = stack[base + 39]/*content*/;
@@ -26049,21 +26073,21 @@
2604926073 label = 695LLU; // emitvar
2605026074 break;
2605126075 }
26052- case 2148LLU: // copy-back deleter (emitvar to ProcCall)
26076+ case 2150LLU: // copy-back deleter (emitvar to ProcCall)
2605326077 {
2605426078 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2605526079 // copy mutable arguments back from call to emitvar
26056- label = 2147LLU; // continue to roll stack
26080+ label = 2149LLU; // continue to roll stack
2605726081 break;
2605826082 }
26059- case 2149LLU: // return from emitvar to ProcCall
26083+ case 2151LLU: // return from emitvar to ProcCall
2606026084 {
2606126085 // copy mutable arguments back from call to emitvar
2606226086 printf("%s", " = stack[base + ");
2606326087 // call printnr from ProcCall
26064- stack[base + 41LLU] = 2150LLU/*throw to this address*/;
26088+ stack[base + 41LLU] = 2152LLU/*throw to this address*/;
2606526089 stack[base + 42LLU] = base;
26066- stack[base + 43LLU] = 2151LLU;
26090+ stack[base + 43LLU] = 2153LLU;
2606726091 // arguments for call to printnr
2606826092 stack[base + 44LLU] = stack[base + 40]/*sum*/;
2606926093 // set stack-base & callee-address
@@ -26071,53 +26095,53 @@
2607126095 label = 18446744073709551590LLU; // printnr
2607226096 break;
2607326097 }
26074- case 2150LLU: // copy-back deleter (printnr to ProcCall)
26098+ case 2152LLU: // copy-back deleter (printnr to ProcCall)
2607526099 {
2607626100 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2607726101 // copy mutable arguments back from call to printnr
26078- label = 2147LLU; // continue to roll stack
26102+ label = 2149LLU; // continue to roll stack
2607926103 break;
2608026104 }
26081- case 2151LLU: // return from printnr to ProcCall
26105+ case 2153LLU: // return from printnr to ProcCall
2608226106 {
2608326107 // copy mutable arguments back from call to printnr
2608426108 printf("%s", "LLU];");
2608526109 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2608626110 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
26087- label = 2145LLU; // case complete
26111+ label = 2147LLU; // case complete
2608826112 break;
2608926113 }
26090- case 2147LLU: // copy-back deleter (switch)
26114+ case 2149LLU: // copy-back deleter (switch)
2609126115 {
2609226116 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2609326117 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
26094- label = 2144LLU; // continue to unroll stack
26118+ label = 2146LLU; // continue to unroll stack
2609526119 break;
2609626120 }
26097- case 2146LLU: // try next case
26121+ case 2148LLU: // try next case
2609826122 {
2609926123 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2610026124 exit(-1);
2610126125 }
26102- case 2145LLU: // completed switch
26126+ case 2147LLU: // completed switch
2610326127 {
2610426128 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
26105- label = 2142LLU; // repeat
26129+ label = 2144LLU; // repeat
2610626130 break;
2610726131 }
26108- case 2144LLU: // copy-back deleter for while next
26132+ case 2146LLU: // copy-back deleter for while next
2610926133 {
2611026134 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
26111- label = 2127LLU; // continue to unroll stack
26135+ label = 2129LLU; // continue to unroll stack
2611226136 break;
2611326137 }
26114- case 2143LLU: // loop finished
26138+ case 2145LLU: // loop finished
2611526139 {
2611626140 printf("%s", "\n label = ");
2611726141 // call printnr from ProcCall
26118- stack[base + 39LLU] = 2152LLU/*throw to this address*/;
26142+ stack[base + 39LLU] = 2154LLU/*throw to this address*/;
2611926143 stack[base + 40LLU] = base;
26120- stack[base + 41LLU] = 2153LLU;
26144+ stack[base + 41LLU] = 2155LLU;
2612126145 // arguments for call to printnr
2612226146 stack[base + 42LLU] = stack[base + 34]/*labelthrow*/;
2612326147 // set stack-base & callee-address
@@ -26125,14 +26149,14 @@
2612526149 label = 18446744073709551590LLU; // printnr
2612626150 break;
2612726151 }
26128- case 2152LLU: // copy-back deleter (printnr to ProcCall)
26152+ case 2154LLU: // copy-back deleter (printnr to ProcCall)
2612926153 {
2613026154 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2613126155 // copy mutable arguments back from call to printnr
26132- label = 2127LLU; // continue to roll stack
26156+ label = 2129LLU; // continue to roll stack
2613326157 break;
2613426158 }
26135- case 2153LLU: // return from printnr to ProcCall
26159+ case 2155LLU: // return from printnr to ProcCall
2613626160 {
2613726161 // copy mutable arguments back from call to printnr
2613826162 printf("%s", "LLU; // continue to roll stack");
@@ -26140,28 +26164,28 @@
2614026164 printf("%s", "\n }");
2614126165 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 35];
2614226166 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 34];
26143- label = 2125LLU; // case complete
26167+ label = 2127LLU; // case complete
2614426168 break;
2614526169 }
26146- case 2127LLU: // copy-back deleter (switch)
26170+ case 2129LLU: // copy-back deleter (switch)
2614726171 {
2614826172 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 35];
2614926173 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 34];
26150- label = 1939LLU; // continue to unroll stack
26174+ label = 1941LLU; // continue to unroll stack
2615126175 break;
2615226176 }
26153- case 2126LLU: // try next case
26177+ case 2128LLU: // try next case
2615426178 {
2615526179 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2615626180 exit(-1);
2615726181 }
26158- case 2125LLU: // completed switch
26182+ case 2127LLU: // completed switch
2615926183 {
2616026184 printf("%s", "\n case ");
2616126185 // call printnr from ProcCall
26162- stack[base + 34LLU] = 2154LLU/*throw to this address*/;
26186+ stack[base + 34LLU] = 2156LLU/*throw to this address*/;
2616326187 stack[base + 35LLU] = base;
26164- stack[base + 36LLU] = 2155LLU;
26188+ stack[base + 36LLU] = 2157LLU;
2616526189 // arguments for call to printnr
2616626190 stack[base + 37LLU] = stack[base + 17]/*label*/;
2616726191 // set stack-base & callee-address
@@ -26169,21 +26193,21 @@
2616926193 label = 18446744073709551590LLU; // printnr
2617026194 break;
2617126195 }
26172- case 2154LLU: // copy-back deleter (printnr to ProcCall)
26196+ case 2156LLU: // copy-back deleter (printnr to ProcCall)
2617326197 {
2617426198 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2617526199 // copy mutable arguments back from call to printnr
26176- label = 1939LLU; // continue to roll stack
26200+ label = 1941LLU; // continue to roll stack
2617726201 break;
2617826202 }
26179- case 2155LLU: // return from printnr to ProcCall
26203+ case 2157LLU: // return from printnr to ProcCall
2618026204 {
2618126205 // copy mutable arguments back from call to printnr
2618226206 printf("%s", "LLU: // return from ");
2618326207 // call printid from ProcCall
26184- stack[base + 34LLU] = 2156LLU/*throw to this address*/;
26208+ stack[base + 34LLU] = 2158LLU/*throw to this address*/;
2618526209 stack[base + 35LLU] = base;
26186- stack[base + 36LLU] = 2157LLU;
26210+ stack[base + 36LLU] = 2159LLU;
2618726211 // arguments for call to printid
2618826212 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2618926213 // set stack-base & callee-address
@@ -26191,21 +26215,21 @@
2619126215 label = 18446744073709551587LLU; // printid
2619226216 break;
2619326217 }
26194- case 2156LLU: // copy-back deleter (printid to ProcCall)
26218+ case 2158LLU: // copy-back deleter (printid to ProcCall)
2619526219 {
2619626220 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2619726221 // copy mutable arguments back from call to printid
26198- label = 1939LLU; // continue to roll stack
26222+ label = 1941LLU; // continue to roll stack
2619926223 break;
2620026224 }
26201- case 2157LLU: // return from printid to ProcCall
26225+ case 2159LLU: // return from printid to ProcCall
2620226226 {
2620326227 // copy mutable arguments back from call to printid
2620426228 printf("%s", " to ");
2620526229 // call printid from ProcCall
26206- stack[base + 34LLU] = 2158LLU/*throw to this address*/;
26230+ stack[base + 34LLU] = 2160LLU/*throw to this address*/;
2620726231 stack[base + 35LLU] = base;
26208- stack[base + 36LLU] = 2159LLU;
26232+ stack[base + 36LLU] = 2161LLU;
2620926233 // arguments for call to printid
2621026234 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2621126235 // set stack-base & callee-address
@@ -26213,22 +26237,22 @@
2621326237 label = 18446744073709551587LLU; // printid
2621426238 break;
2621526239 }
26216- case 2158LLU: // copy-back deleter (printid to ProcCall)
26240+ case 2160LLU: // copy-back deleter (printid to ProcCall)
2621726241 {
2621826242 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2621926243 // copy mutable arguments back from call to printid
26220- label = 1939LLU; // continue to roll stack
26244+ label = 1941LLU; // continue to roll stack
2622126245 break;
2622226246 }
26223- case 2159LLU: // return from printid to ProcCall
26247+ case 2161LLU: // return from printid to ProcCall
2622426248 {
2622526249 // copy mutable arguments back from call to printid
2622626250 printf("%s", "\n {");
2622726251 printf("%s", "\n // copy mutable arguments back from call to ");
2622826252 // call printid from ProcCall
26229- stack[base + 34LLU] = 2160LLU/*throw to this address*/;
26253+ stack[base + 34LLU] = 2162LLU/*throw to this address*/;
2623026254 stack[base + 35LLU] = base;
26231- stack[base + 36LLU] = 2161LLU;
26255+ stack[base + 36LLU] = 2163LLU;
2623226256 // arguments for call to printid
2623326257 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2623426258 // set stack-base & callee-address
@@ -26236,24 +26260,24 @@
2623626260 label = 18446744073709551587LLU; // printid
2623726261 break;
2623826262 }
26239- case 2160LLU: // copy-back deleter (printid to ProcCall)
26263+ case 2162LLU: // copy-back deleter (printid to ProcCall)
2624026264 {
2624126265 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2624226266 // copy mutable arguments back from call to printid
26243- label = 1939LLU; // continue to roll stack
26267+ label = 1941LLU; // continue to roll stack
2624426268 break;
2624526269 }
26246- case 2161LLU: // return from printid to ProcCall
26270+ case 2163LLU: // return from printid to ProcCall
2624726271 {
2624826272 // copy mutable arguments back from call to printid
26249- label = 2162LLU; // start to repeat
26273+ label = 2164LLU; // start to repeat
2625026274 break;
2625126275 }
26252- case 2162LLU: // repeat from here
26276+ case 2164LLU: // repeat from here
2625326277 {
2625426278 if(!stack[base + 19])
2625526279 {
26256- label = 2163LLU; // break loop
26280+ label = 2165LLU; // break loop
2625726281 break;
2625826282 }
2625926283
@@ -26266,7 +26290,7 @@
2626626290 }
2626726291 if(/*idnr*/0 != ((uint64_t *)(stack[base + 34]/*idnr*/))[0])
2626826292 {
26269- label = 2165LLU; // jump to alternative
26293+ label = 2167LLU; // jump to alternative
2627026294 break;
2627126295 }
2627226296
@@ -26276,9 +26300,9 @@
2627626300 // case
2627726301 printf("%s", "\n ");
2627826302 // call emitvar from ProcCall
26279- stack[base + 37LLU] = 2167LLU/*throw to this address*/;
26303+ stack[base + 37LLU] = 2169LLU/*throw to this address*/;
2628026304 stack[base + 38LLU] = base;
26281- stack[base + 39LLU] = 2168LLU;
26305+ stack[base + 39LLU] = 2170LLU;
2628226306 // arguments for call to emitvar
2628326307 stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2628426308 stack[base + 41LLU] = stack[base + 35]/*content*/;
@@ -26289,21 +26313,21 @@
2628926313 label = 695LLU; // emitvar
2629026314 break;
2629126315 }
26292- case 2167LLU: // copy-back deleter (emitvar to ProcCall)
26316+ case 2169LLU: // copy-back deleter (emitvar to ProcCall)
2629326317 {
2629426318 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
2629526319 // copy mutable arguments back from call to emitvar
26296- label = 2166LLU; // continue to roll stack
26320+ label = 2168LLU; // continue to roll stack
2629726321 break;
2629826322 }
26299- case 2168LLU: // return from emitvar to ProcCall
26323+ case 2170LLU: // return from emitvar to ProcCall
2630026324 {
2630126325 // copy mutable arguments back from call to emitvar
2630226326 printf("%s", " = stack[base + ");
2630326327 // call printnr from ProcCall
26304- stack[base + 37LLU] = 2169LLU/*throw to this address*/;
26328+ stack[base + 37LLU] = 2171LLU/*throw to this address*/;
2630526329 stack[base + 38LLU] = base;
26306- stack[base + 39LLU] = 2170LLU;
26330+ stack[base + 39LLU] = 2172LLU;
2630726331 // arguments for call to printnr
2630826332 stack[base + 40LLU] = stack[base + 36]/*sum*/;
2630926333 // set stack-base & callee-address
@@ -26311,35 +26335,35 @@
2631126335 label = 18446744073709551590LLU; // printnr
2631226336 break;
2631326337 }
26314- case 2169LLU: // copy-back deleter (printnr to ProcCall)
26338+ case 2171LLU: // copy-back deleter (printnr to ProcCall)
2631526339 {
2631626340 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2631726341 // copy mutable arguments back from call to printnr
26318- label = 2166LLU; // continue to roll stack
26342+ label = 2168LLU; // continue to roll stack
2631926343 break;
2632026344 }
26321- case 2170LLU: // return from printnr to ProcCall
26345+ case 2172LLU: // return from printnr to ProcCall
2632226346 {
2632326347 // copy mutable arguments back from call to printnr
2632426348 printf("%s", "LLU];");
2632526349 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
2632626350 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
26327- label = 2164LLU; // case complete
26351+ label = 2166LLU; // case complete
2632826352 break;
2632926353 }
26330- case 2166LLU: // copy-back deleter (switch)
26354+ case 2168LLU: // copy-back deleter (switch)
2633126355 {
2633226356 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
2633326357 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
26334- label = 1939LLU; // continue to unroll stack
26358+ label = 1941LLU; // continue to unroll stack
2633526359 break;
2633626360 }
26337- case 2165LLU: // try next case
26361+ case 2167LLU: // try next case
2633826362 {
2633926363 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2634026364 exit(-1);
2634126365 }
26342- case 2164LLU: // completed switch
26366+ case 2166LLU: // completed switch
2634326367 {
2634426368
2634526369 uint64_t *newstack = (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 4);
@@ -26347,7 +26371,7 @@
2634726371 newstack[0] = (uint64_t)stack; // backup stack location
2634826372 newstack[1] = 1234567890;
2634926373 newstack[2] = base;
26350- newstack[3] = 2171LLU;
26374+ newstack[3] = 2173LLU;
2635126375 stack = newstack;
2635226376 // set stack-base & callee-address
2635326377 base = 4/*deloffset*/;
@@ -26354,20 +26378,20 @@
2635426378 label = 798LLU; // ~idnr
2635526379 break;
2635626380 }
26357- case 2171LLU: // return from ~idnr to ProcCall
26381+ case 2173LLU: // return from ~idnr to ProcCall
2635826382 {
2635926383 stack = (uint64_t *)stack[0];
2636026384 // releasing toplevel container
2636126385 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 4));
2636226386
26363- label = 2162LLU; // repeat
26387+ label = 2164LLU; // repeat
2636426388 break;
2636526389 }
26366- case 2163LLU: // loop finished
26390+ case 2165LLU: // loop finished
2636726391 {
2636826392 if(!stack[base + 28]/*cerescount*/)
2636926393 {
26370- label = 2172LLU; // jump to alternative
26394+ label = 2174LLU; // jump to alternative
2637126395 break;
2637226396 }
2637326397
@@ -26374,9 +26398,9 @@
2637426398 // consequent
2637526399 printf("%s", "\n // copy back results provided by call to ");
2637626400 // call printid from ProcCall
26377- stack[base + 34LLU] = 2174LLU/*throw to this address*/;
26401+ stack[base + 34LLU] = 2176LLU/*throw to this address*/;
2637826402 stack[base + 35LLU] = base;
26379- stack[base + 36LLU] = 2175LLU;
26403+ stack[base + 36LLU] = 2177LLU;
2638026404 // arguments for call to printid
2638126405 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2638226406 // set stack-base & callee-address
@@ -26384,26 +26408,26 @@
2638426408 label = 18446744073709551587LLU; // printid
2638526409 break;
2638626410 }
26387- case 2174LLU: // copy-back deleter (printid to ProcCall)
26411+ case 2176LLU: // copy-back deleter (printid to ProcCall)
2638826412 {
2638926413 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
2639026414 // copy mutable arguments back from call to printid
26391- label = 1939LLU; // continue to roll stack
26415+ label = 1941LLU; // continue to roll stack
2639226416 break;
2639326417 }
26394- case 2175LLU: // return from printid to ProcCall
26418+ case 2177LLU: // return from printid to ProcCall
2639526419 {
2639626420 // copy mutable arguments back from call to printid
2639726421 stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/;
2639826422 flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 34]);
26399- label = 2176LLU; // start to repeat
26423+ label = 2178LLU; // start to repeat
2640026424 break;
2640126425 }
26402- case 2176LLU: // repeat from here
26426+ case 2178LLU: // repeat from here
2640326427 {
2640426428 if(!stack[base + 34])
2640526429 {
26406- label = 2177LLU; // break loop
26430+ label = 2179LLU; // break loop
2640726431 break;
2640826432 }
2640926433
@@ -26412,9 +26436,9 @@
2641226436 stack[base + 36]/*previous*/ = stack[base + 34];
2641326437 stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
2641426438 // call sub from ProcCall
26415- stack[base + 37LLU] = 2179LLU/*throw to this address*/;
26439+ stack[base + 37LLU] = 2181LLU/*throw to this address*/;
2641626440 stack[base + 38LLU] = base;
26417- stack[base + 39LLU] = 2180LLU;
26441+ stack[base + 39LLU] = 2182LLU;
2641826442 // arguments for call to sub
2641926443 stack[base + 41LLU] = stack[base + 28]/*cerescount*/;
2642026444 stack[base + 42LLU] = stack[base + 31]/*n*/;
@@ -26423,22 +26447,22 @@
2642326447 label = 18446744073709551604LLU; // sub
2642426448 break;
2642526449 }
26426- case 2179LLU: // copy-back deleter (sub to ProcCall)
26450+ case 2181LLU: // copy-back deleter (sub to ProcCall)
2642726451 {
2642826452 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2642926453 // copy mutable arguments back from call to sub
26430- label = 2178LLU; // continue to roll stack
26454+ label = 2180LLU; // continue to roll stack
2643126455 break;
2643226456 }
26433- case 2180LLU: // return from sub to ProcCall
26457+ case 2182LLU: // return from sub to ProcCall
2643426458 {
2643526459 // copy mutable arguments back from call to sub
2643626460 // copy back results provided by call to sub
2643726461 stack[base + 32] = stack[base + 40LLU];
2643826462 // call sub from ProcCall
26439- stack[base + 37LLU] = 2181LLU/*throw to this address*/;
26463+ stack[base + 37LLU] = 2183LLU/*throw to this address*/;
2644026464 stack[base + 38LLU] = base;
26441- stack[base + 39LLU] = 2182LLU;
26465+ stack[base + 39LLU] = 2184LLU;
2644226466 // arguments for call to sub
2644326467 stack[base + 41LLU] = stack[base + 31]/*n*/;
2644426468 stack[base + 42LLU] = 1LLU;
@@ -26447,14 +26471,14 @@
2644726471 label = 18446744073709551604LLU; // sub
2644826472 break;
2644926473 }
26450- case 2181LLU: // copy-back deleter (sub to ProcCall)
26474+ case 2183LLU: // copy-back deleter (sub to ProcCall)
2645126475 {
2645226476 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
2645326477 // copy mutable arguments back from call to sub
26454- label = 2178LLU; // continue to roll stack
26478+ label = 2180LLU; // continue to roll stack
2645526479 break;
2645626480 }
26457- case 2182LLU: // return from sub to ProcCall
26481+ case 2184LLU: // return from sub to ProcCall
2645826482 {
2645926483 // copy mutable arguments back from call to sub
2646026484 // copy back results provided by call to sub
@@ -26463,7 +26487,7 @@
2646326487 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
2646426488 if(!list)
2646526489 {
26466- label = 2183LLU; // jump to alternative
26490+ label = 2185LLU; // jump to alternative
2646726491 break;
2646826492 }
2646926493
@@ -26475,7 +26499,7 @@
2647526499 }
2647626500 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 37]/*typeidx*/))[0])
2647726501 {
26478- label = 2186LLU; // jump to alternative
26502+ label = 2189LLU; // jump to alternative
2647926503 break;
2648026504 }
2648126505
@@ -26485,7 +26509,7 @@
2648526509 // case
2648626510 if(/*result*/0 != ((uint64_t *)(stack[base + 35]/*result*/))[0])
2648726511 {
26488- label = 2189LLU; // jump to alternative
26512+ label = 2192LLU; // jump to alternative
2648926513 break;
2649026514 }
2649126515
@@ -26496,7 +26520,7 @@
2649626520 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2649726521 if(!newstack)
2649826522 {
26499- label = 2190LLU; // throw: begin to unroll stack
26523+ label = 2193LLU; // throw: begin to unroll stack
2650026524 break;
2650126525 }
2650226526
@@ -26503,9 +26527,9 @@
2650326527 newstack[15LLU] = 9876543210LLU; // overflow-marker
2650426528 // call equtype from ProcCall
2650526529 newstack[0] = (uint64_t)stack; // backup stack location
26506- newstack[1] = 2191LLU;
26530+ newstack[1] = 2194LLU;
2650726531 newstack[2] = base;
26508- newstack[3] = 2192LLU;
26532+ newstack[3] = 2195LLU;
2650926533 // arguments for call to equtype
2651026534 newstack[5LLU] = stack[base + 38]/*dsttype*/;
2651126535 newstack[6LLU] = stack[base + 40]/*srctype*/;
@@ -26515,7 +26539,7 @@
2651526539 label = 342LLU; // equtype
2651626540 break;
2651726541 }
26518- case 2191LLU: // copy-back deleter (equtype to ProcCall)
26542+ case 2194LLU: // copy-back deleter (equtype to ProcCall)
2651926543 {
2652026544 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
2652126545 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -26527,10 +26551,10 @@
2652726551 }
2652826552 Free(15LLU + 1, sizeof(uint64_t), stack);
2652926553 stack = oldstack;
26530- label = 2190LLU; // continue to unroll stack
26554+ label = 2193LLU; // continue to unroll stack
2653126555 break;
2653226556 }
26533- case 2192LLU: // return from equtype to ProcCall
26557+ case 2195LLU: // return from equtype to ProcCall
2653426558 {
2653526559 uint64_t *oldstack = (uint64_t *)stack[0];
2653626560 // copy mutable arguments back from call to equtype
@@ -26545,21 +26569,21 @@
2654526569 stack = oldstack;
2654626570 if(!stack[base + 18]/*isequal*/)
2654726571 {
26548- label = 2193LLU; // jump to alternative
26572+ label = 2196LLU; // jump to alternative
2654926573 break;
2655026574 }
2655126575
2655226576 // consequent
26553- label = 2194LLU; // consequent complete
26577+ label = 2197LLU; // consequent complete
2655426578 break;
2655526579 }
26556- case 2193LLU: // alternative
26580+ case 2196LLU: // alternative
2655726581 {
2655826582 fprintf(stderr, "%s", "in function ");
2655926583 // call reportid from ProcCall
26560- stack[base + 42LLU] = 2195LLU/*throw to this address*/;
26584+ stack[base + 42LLU] = 2198LLU/*throw to this address*/;
2656126585 stack[base + 43LLU] = base;
26562- stack[base + 44LLU] = 2196LLU;
26586+ stack[base + 44LLU] = 2199LLU;
2656326587 // arguments for call to reportid
2656426588 stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2656526589 // set stack-base & callee-address
@@ -26567,21 +26591,21 @@
2656726591 label = 18446744073709551586LLU; // reportid
2656826592 break;
2656926593 }
26570- case 2195LLU: // copy-back deleter (reportid to ProcCall)
26594+ case 2198LLU: // copy-back deleter (reportid to ProcCall)
2657126595 {
2657226596 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2657326597 // copy mutable arguments back from call to reportid
26574- label = 2190LLU; // continue to roll stack
26598+ label = 2193LLU; // continue to roll stack
2657526599 break;
2657626600 }
26577- case 2196LLU: // return from reportid to ProcCall
26601+ case 2199LLU: // return from reportid to ProcCall
2657826602 {
2657926603 // copy mutable arguments back from call to reportid
2658026604 fprintf(stderr, "%s", " call to ");
2658126605 // call reportid from ProcCall
26582- stack[base + 42LLU] = 2197LLU/*throw to this address*/;
26606+ stack[base + 42LLU] = 2200LLU/*throw to this address*/;
2658326607 stack[base + 43LLU] = base;
26584- stack[base + 44LLU] = 2198LLU;
26608+ stack[base + 44LLU] = 2201LLU;
2658526609 // arguments for call to reportid
2658626610 stack[base + 45LLU] = stack[base + 24]/*ceid*/;
2658726611 // set stack-base & callee-address
@@ -26589,21 +26613,21 @@
2658926613 label = 18446744073709551586LLU; // reportid
2659026614 break;
2659126615 }
26592- case 2197LLU: // copy-back deleter (reportid to ProcCall)
26616+ case 2200LLU: // copy-back deleter (reportid to ProcCall)
2659326617 {
2659426618 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2659526619 // copy mutable arguments back from call to reportid
26596- label = 2190LLU; // continue to roll stack
26620+ label = 2193LLU; // continue to roll stack
2659726621 break;
2659826622 }
26599- case 2198LLU: // return from reportid to ProcCall
26623+ case 2201LLU: // return from reportid to ProcCall
2660026624 {
2660126625 // copy mutable arguments back from call to reportid
2660226626 fprintf(stderr, "%s", " at position ");
2660326627 // call reportnr from ProcCall
26604- stack[base + 42LLU] = 2199LLU/*throw to this address*/;
26628+ stack[base + 42LLU] = 2202LLU/*throw to this address*/;
2660526629 stack[base + 43LLU] = base;
26606- stack[base + 44LLU] = 2200LLU;
26630+ stack[base + 44LLU] = 2203LLU;
2660726631 // arguments for call to reportnr
2660826632 stack[base + 45LLU] = stack[base + 32]/*index*/;
2660926633 // set stack-base & callee-address
@@ -26611,14 +26635,14 @@
2661126635 label = 18446744073709551589LLU; // reportnr
2661226636 break;
2661326637 }
26614- case 2199LLU: // copy-back deleter (reportnr to ProcCall)
26638+ case 2202LLU: // copy-back deleter (reportnr to ProcCall)
2661526639 {
2661626640 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2661726641 // copy mutable arguments back from call to reportnr
26618- label = 2190LLU; // continue to roll stack
26642+ label = 2193LLU; // continue to roll stack
2661926643 break;
2662026644 }
26621- case 2200LLU: // return from reportnr to ProcCall
26645+ case 2203LLU: // return from reportnr to ProcCall
2662226646 {
2662326647 // copy mutable arguments back from call to reportnr
2662426648 fprintf(stderr, "%s", " cannot return source of type ");
@@ -26625,7 +26649,7 @@
2662526649 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2662626650 if(!newstack)
2662726651 {
26628- label = 2190LLU; // throw: begin to unroll stack
26652+ label = 2193LLU; // throw: begin to unroll stack
2662926653 break;
2663026654 }
2663126655
@@ -26632,9 +26656,9 @@
2663226656 newstack[10LLU] = 9876543210LLU; // overflow-marker
2663326657 // call reporttype from ProcCall
2663426658 newstack[0] = (uint64_t)stack; // backup stack location
26635- newstack[1] = 2201LLU;
26659+ newstack[1] = 2204LLU;
2663626660 newstack[2] = base;
26637- newstack[3] = 2202LLU;
26661+ newstack[3] = 2205LLU;
2663826662 // arguments for call to reporttype
2663926663 newstack[4LLU] = stack[base + 40]/*srctype*/;
2664026664 stack = newstack;
@@ -26643,7 +26667,7 @@
2664326667 label = 316LLU; // reporttype
2664426668 break;
2664526669 }
26646- case 2201LLU: // copy-back deleter (reporttype to ProcCall)
26670+ case 2204LLU: // copy-back deleter (reporttype to ProcCall)
2664726671 {
2664826672 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2664926673 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -26655,10 +26679,10 @@
2665526679 }
2665626680 Free(10LLU + 1, sizeof(uint64_t), stack);
2665726681 stack = oldstack;
26658- label = 2190LLU; // continue to unroll stack
26682+ label = 2193LLU; // continue to unroll stack
2665926683 break;
2666026684 }
26661- case 2202LLU: // return from reporttype to ProcCall
26685+ case 2205LLU: // return from reporttype to ProcCall
2666226686 {
2666326687 uint64_t *oldstack = (uint64_t *)stack[0];
2666426688 // copy mutable arguments back from call to reporttype
@@ -26673,7 +26697,7 @@
2667326697 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2667426698 if(!newstack)
2667526699 {
26676- label = 2190LLU; // throw: begin to unroll stack
26700+ label = 2193LLU; // throw: begin to unroll stack
2667726701 break;
2667826702 }
2667926703
@@ -26680,9 +26704,9 @@
2668026704 newstack[10LLU] = 9876543210LLU; // overflow-marker
2668126705 // call reporttype from ProcCall
2668226706 newstack[0] = (uint64_t)stack; // backup stack location
26683- newstack[1] = 2203LLU;
26707+ newstack[1] = 2206LLU;
2668426708 newstack[2] = base;
26685- newstack[3] = 2204LLU;
26709+ newstack[3] = 2207LLU;
2668626710 // arguments for call to reporttype
2668726711 newstack[4LLU] = stack[base + 38]/*dsttype*/;
2668826712 stack = newstack;
@@ -26691,7 +26715,7 @@
2669126715 label = 316LLU; // reporttype
2669226716 break;
2669326717 }
26694- case 2203LLU: // copy-back deleter (reporttype to ProcCall)
26718+ case 2206LLU: // copy-back deleter (reporttype to ProcCall)
2669526719 {
2669626720 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
2669726721 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -26703,10 +26727,10 @@
2670326727 }
2670426728 Free(10LLU + 1, sizeof(uint64_t), stack);
2670526729 stack = oldstack;
26706- label = 2190LLU; // continue to unroll stack
26730+ label = 2193LLU; // continue to unroll stack
2670726731 break;
2670826732 }
26709- case 2204LLU: // return from reporttype to ProcCall
26733+ case 2207LLU: // return from reporttype to ProcCall
2671026734 {
2671126735 uint64_t *oldstack = (uint64_t *)stack[0];
2671226736 // copy mutable arguments back from call to reporttype
@@ -26719,16 +26743,16 @@
2671926743 stack = oldstack;
2672026744 fprintf(stderr, "%s", "\n");
2672126745 exit(-1);
26722- label = 2194LLU; // alternative complete
26746+ label = 2197LLU; // alternative complete
2672326747 break;
2672426748 }
26725- case 2194LLU: // completed if-then-else
26749+ case 2197LLU: // completed if-then-else
2672626750 {
2672726751 stack[base + 30]/*sum*/ = 0;
2672826752 // call add from ProcCall
26729- stack[base + 42LLU] = 2205LLU/*throw to this address*/;
26753+ stack[base + 42LLU] = 2208LLU/*throw to this address*/;
2673026754 stack[base + 43LLU] = base;
26731- stack[base + 44LLU] = 2206LLU;
26755+ stack[base + 44LLU] = 2209LLU;
2673226756 // arguments for call to add
2673326757 stack[base + 46LLU] = stack[base + 10]/*fnrescount*/;
2673426758 stack[base + 47LLU] = stack[base + 30]/*sum*/;
@@ -26737,22 +26761,22 @@
2673726761 label = 18446744073709551605LLU; // add
2673826762 break;
2673926763 }
26740- case 2205LLU: // copy-back deleter (add to ProcCall)
26764+ case 2208LLU: // copy-back deleter (add to ProcCall)
2674126765 {
2674226766 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2674326767 // copy mutable arguments back from call to add
26744- label = 2190LLU; // continue to roll stack
26768+ label = 2193LLU; // continue to roll stack
2674526769 break;
2674626770 }
26747- case 2206LLU: // return from add to ProcCall
26771+ case 2209LLU: // return from add to ProcCall
2674826772 {
2674926773 // copy mutable arguments back from call to add
2675026774 // copy back results provided by call to add
2675126775 stack[base + 30] = stack[base + 45LLU];
2675226776 // call add from ProcCall
26753- stack[base + 42LLU] = 2207LLU/*throw to this address*/;
26777+ stack[base + 42LLU] = 2210LLU/*throw to this address*/;
2675426778 stack[base + 43LLU] = base;
26755- stack[base + 44LLU] = 2208LLU;
26779+ stack[base + 44LLU] = 2211LLU;
2675626780 // arguments for call to add
2675726781 stack[base + 46LLU] = stack[base + 11]/*fnargcount*/;
2675826782 stack[base + 47LLU] = stack[base + 30]/*sum*/;
@@ -26761,22 +26785,22 @@
2676126785 label = 18446744073709551605LLU; // add
2676226786 break;
2676326787 }
26764- case 2207LLU: // copy-back deleter (add to ProcCall)
26788+ case 2210LLU: // copy-back deleter (add to ProcCall)
2676526789 {
2676626790 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2676726791 // copy mutable arguments back from call to add
26768- label = 2190LLU; // continue to roll stack
26792+ label = 2193LLU; // continue to roll stack
2676926793 break;
2677026794 }
26771- case 2208LLU: // return from add to ProcCall
26795+ case 2211LLU: // return from add to ProcCall
2677226796 {
2677326797 // copy mutable arguments back from call to add
2677426798 // copy back results provided by call to add
2677526799 stack[base + 30] = stack[base + 45LLU];
2677626800 // call add from ProcCall
26777- stack[base + 42LLU] = 2209LLU/*throw to this address*/;
26801+ stack[base + 42LLU] = 2212LLU/*throw to this address*/;
2677826802 stack[base + 43LLU] = base;
26779- stack[base + 44LLU] = 2210LLU;
26803+ stack[base + 44LLU] = 2213LLU;
2678026804 // arguments for call to add
2678126805 stack[base + 46LLU] = stack[base + 4]/*offset*/;
2678226806 stack[base + 47LLU] = stack[base + 30]/*sum*/;
@@ -26785,22 +26809,22 @@
2678526809 label = 18446744073709551605LLU; // add
2678626810 break;
2678726811 }
26788- case 2209LLU: // copy-back deleter (add to ProcCall)
26812+ case 2212LLU: // copy-back deleter (add to ProcCall)
2678926813 {
2679026814 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2679126815 // copy mutable arguments back from call to add
26792- label = 2190LLU; // continue to roll stack
26816+ label = 2193LLU; // continue to roll stack
2679326817 break;
2679426818 }
26795- case 2210LLU: // return from add to ProcCall
26819+ case 2213LLU: // return from add to ProcCall
2679626820 {
2679726821 // copy mutable arguments back from call to add
2679826822 // copy back results provided by call to add
2679926823 stack[base + 30] = stack[base + 45LLU];
2680026824 // call add from ProcCall
26801- stack[base + 42LLU] = 2211LLU/*throw to this address*/;
26825+ stack[base + 42LLU] = 2214LLU/*throw to this address*/;
2680226826 stack[base + 43LLU] = base;
26803- stack[base + 44LLU] = 2212LLU;
26827+ stack[base + 44LLU] = 2215LLU;
2680426828 // arguments for call to add
2680526829 stack[base + 46LLU] = 3LLU;
2680626830 stack[base + 47LLU] = stack[base + 30]/*sum*/;
@@ -26809,22 +26833,22 @@
2680926833 label = 18446744073709551605LLU; // add
2681026834 break;
2681126835 }
26812- case 2211LLU: // copy-back deleter (add to ProcCall)
26836+ case 2214LLU: // copy-back deleter (add to ProcCall)
2681326837 {
2681426838 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2681526839 // copy mutable arguments back from call to add
26816- label = 2190LLU; // continue to roll stack
26840+ label = 2193LLU; // continue to roll stack
2681726841 break;
2681826842 }
26819- case 2212LLU: // return from add to ProcCall
26843+ case 2215LLU: // return from add to ProcCall
2682026844 {
2682126845 // copy mutable arguments back from call to add
2682226846 // copy back results provided by call to add
2682326847 stack[base + 30] = stack[base + 45LLU];
2682426848 // call add from ProcCall
26825- stack[base + 42LLU] = 2213LLU/*throw to this address*/;
26849+ stack[base + 42LLU] = 2216LLU/*throw to this address*/;
2682626850 stack[base + 43LLU] = base;
26827- stack[base + 44LLU] = 2214LLU;
26851+ stack[base + 44LLU] = 2217LLU;
2682826852 // arguments for call to add
2682926853 stack[base + 46LLU] = stack[base + 32]/*index*/;
2683026854 stack[base + 47LLU] = stack[base + 30]/*sum*/;
@@ -26833,14 +26857,14 @@
2683326857 label = 18446744073709551605LLU; // add
2683426858 break;
2683526859 }
26836- case 2213LLU: // copy-back deleter (add to ProcCall)
26860+ case 2216LLU: // copy-back deleter (add to ProcCall)
2683726861 {
2683826862 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2683926863 // copy mutable arguments back from call to add
26840- label = 2190LLU; // continue to roll stack
26864+ label = 2193LLU; // continue to roll stack
2684126865 break;
2684226866 }
26843- case 2214LLU: // return from add to ProcCall
26867+ case 2217LLU: // return from add to ProcCall
2684426868 {
2684526869 // copy mutable arguments back from call to add
2684626870 // copy back results provided by call to add
@@ -26847,9 +26871,9 @@
2684726871 stack[base + 30] = stack[base + 45LLU];
2684826872 printf("%s", "\n ");
2684926873 // call emitvaridx from ProcCall
26850- stack[base + 42LLU] = 2215LLU/*throw to this address*/;
26874+ stack[base + 42LLU] = 2218LLU/*throw to this address*/;
2685126875 stack[base + 43LLU] = base;
26852- stack[base + 44LLU] = 2216LLU;
26876+ stack[base + 44LLU] = 2219LLU;
2685326877 // arguments for call to emitvaridx
2685426878 stack[base + 45LLU] = stack[base + 39]/*INDEX*/;
2685526879 // set stack-base & callee-address
@@ -26857,21 +26881,21 @@
2685726881 label = 691LLU; // emitvaridx
2685826882 break;
2685926883 }
26860- case 2215LLU: // copy-back deleter (emitvaridx to ProcCall)
26884+ case 2218LLU: // copy-back deleter (emitvaridx to ProcCall)
2686126885 {
2686226886 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n");
2686326887 // copy mutable arguments back from call to emitvaridx
26864- label = 2190LLU; // continue to roll stack
26888+ label = 2193LLU; // continue to roll stack
2686526889 break;
2686626890 }
26867- case 2216LLU: // return from emitvaridx to ProcCall
26891+ case 2219LLU: // return from emitvaridx to ProcCall
2686826892 {
2686926893 // copy mutable arguments back from call to emitvaridx
2687026894 printf("%s", " = stack[base + ");
2687126895 // call printnr from ProcCall
26872- stack[base + 42LLU] = 2217LLU/*throw to this address*/;
26896+ stack[base + 42LLU] = 2220LLU/*throw to this address*/;
2687326897 stack[base + 43LLU] = base;
26874- stack[base + 44LLU] = 2218LLU;
26898+ stack[base + 44LLU] = 2221LLU;
2687526899 // arguments for call to printnr
2687626900 stack[base + 45LLU] = stack[base + 30]/*sum*/;
2687726901 // set stack-base & callee-address
@@ -26879,54 +26903,54 @@
2687926903 label = 18446744073709551590LLU; // printnr
2688026904 break;
2688126905 }
26882- case 2217LLU: // copy-back deleter (printnr to ProcCall)
26906+ case 2220LLU: // copy-back deleter (printnr to ProcCall)
2688326907 {
2688426908 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
2688526909 // copy mutable arguments back from call to printnr
26886- label = 2190LLU; // continue to roll stack
26910+ label = 2193LLU; // continue to roll stack
2688726911 break;
2688826912 }
26889- case 2218LLU: // return from printnr to ProcCall
26913+ case 2221LLU: // return from printnr to ProcCall
2689026914 {
2689126915 // copy mutable arguments back from call to printnr
2689226916 printf("%s", "LLU];");
2689326917 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 41];
2689426918 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 40];
26895- label = 2188LLU; // case complete
26919+ label = 2191LLU; // case complete
2689626920 break;
2689726921 }
26898- case 2190LLU: // copy-back deleter (switch)
26922+ case 2193LLU: // copy-back deleter (switch)
2689926923 {
2690026924 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 41];
2690126925 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 40];
26902- label = 2187LLU; // continue to unroll stack
26926+ label = 2190LLU; // continue to unroll stack
2690326927 break;
2690426928 }
26905- case 2189LLU: // try next case
26929+ case 2192LLU: // try next case
2690626930 {
2690726931 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2690826932 exit(-1);
2690926933 }
26910- case 2188LLU: // completed switch
26934+ case 2191LLU: // completed switch
2691126935 {
2691226936 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 39];
2691326937 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 38];
26914- label = 2185LLU; // case complete
26938+ label = 2188LLU; // case complete
2691526939 break;
2691626940 }
26917- case 2187LLU: // copy-back deleter (switch)
26941+ case 2190LLU: // copy-back deleter (switch)
2691826942 {
2691926943 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 39];
2692026944 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 38];
26921- label = 2178LLU; // continue to unroll stack
26945+ label = 2187LLU; // continue to unroll stack
2692226946 break;
2692326947 }
26924- case 2186LLU: // try next case
26948+ case 2189LLU: // try next case
2692526949 {
2692626950 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2692726951 exit(-1);
2692826952 }
26929- case 2185LLU: // completed switch
26953+ case 2188LLU: // completed switch
2693026954 {
2693126955
2693226956 uint64_t *newstack = (uint64_t *)(stack[base + 37] - sizeof(uint64_t) * 4);
@@ -26934,7 +26958,7 @@
2693426958 newstack[0] = (uint64_t)stack; // backup stack location
2693526959 newstack[1] = 1234567890;
2693626960 newstack[2] = base;
26937- newstack[3] = 2219LLU;
26961+ newstack[3] = 2222LLU;
2693826962 stack = newstack;
2693926963 // set stack-base & callee-address
2694026964 base = 4/*deloffset*/;
@@ -26941,22 +26965,46 @@
2694126965 label = 379LLU; // ~typeidx
2694226966 break;
2694326967 }
26944- case 2219LLU: // return from ~typeidx to ProcCall
26968+ case 2222LLU: // return from ~typeidx to ProcCall
2694526969 {
2694626970 stack = (uint64_t *)stack[0];
2694726971 // releasing toplevel container
2694826972 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 37] - sizeof(uint64_t) * 4));
2694926973
26950- label = 2184LLU; // consequent complete
26974+ label = 2186LLU; // consequent complete
2695126975 break;
2695226976 }
26953- case 2183LLU: // alternative
26977+ case 2187LLU: // copy-back deleter (if pop)
2695426978 {
26979+
26980+ uint64_t *newstack = (uint64_t *)(stack[base + 37] - sizeof(uint64_t) * 4);
26981+ // call ~typeidx from ProcCall
26982+ newstack[0] = (uint64_t)stack; // backup stack location
26983+ newstack[1] = 1234567890;
26984+ newstack[2] = base;
26985+ newstack[3] = 2223LLU;
26986+ stack = newstack;
26987+ // set stack-base & callee-address
26988+ base = 4/*deloffset*/;
26989+ label = 379LLU; // ~typeidx
26990+ break;
26991+ }
26992+ case 2223LLU: // return from ~typeidx to ProcCall
26993+ {
26994+ stack = (uint64_t *)stack[0];
26995+ // releasing toplevel container
26996+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 37] - sizeof(uint64_t) * 4));
26997+
26998+ label = 2180LLU; // consequent complete
26999+ break;
27000+ }
27001+ case 2185LLU: // alternative
27002+ {
2695527003 fprintf(stderr, "%s", "in function ");
2695627004 // call reportid from ProcCall
26957- stack[base + 38LLU] = 2220LLU/*throw to this address*/;
27005+ stack[base + 38LLU] = 2224LLU/*throw to this address*/;
2695827006 stack[base + 39LLU] = base;
26959- stack[base + 40LLU] = 2221LLU;
27007+ stack[base + 40LLU] = 2225LLU;
2696027008 // arguments for call to reportid
2696127009 stack[base + 41LLU] = stack[base + 8]/*fnid*/;
2696227010 // set stack-base & callee-address
@@ -26964,21 +27012,21 @@
2696427012 label = 18446744073709551586LLU; // reportid
2696527013 break;
2696627014 }
26967- case 2220LLU: // copy-back deleter (reportid to ProcCall)
27015+ case 2224LLU: // copy-back deleter (reportid to ProcCall)
2696827016 {
2696927017 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2697027018 // copy mutable arguments back from call to reportid
26971- label = 2178LLU; // continue to roll stack
27019+ label = 2180LLU; // continue to roll stack
2697227020 break;
2697327021 }
26974- case 2221LLU: // return from reportid to ProcCall
27022+ case 2225LLU: // return from reportid to ProcCall
2697527023 {
2697627024 // copy mutable arguments back from call to reportid
2697727025 fprintf(stderr, "%s", " call to ");
2697827026 // call reportid from ProcCall
26979- stack[base + 38LLU] = 2222LLU/*throw to this address*/;
27027+ stack[base + 38LLU] = 2226LLU/*throw to this address*/;
2698027028 stack[base + 39LLU] = base;
26981- stack[base + 40LLU] = 2223LLU;
27029+ stack[base + 40LLU] = 2227LLU;
2698227030 // arguments for call to reportid
2698327031 stack[base + 41LLU] = stack[base + 24]/*ceid*/;
2698427032 // set stack-base & callee-address
@@ -26986,21 +27034,21 @@
2698627034 label = 18446744073709551586LLU; // reportid
2698727035 break;
2698827036 }
26989- case 2222LLU: // copy-back deleter (reportid to ProcCall)
27037+ case 2226LLU: // copy-back deleter (reportid to ProcCall)
2699027038 {
2699127039 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2699227040 // copy mutable arguments back from call to reportid
26993- label = 2178LLU; // continue to roll stack
27041+ label = 2180LLU; // continue to roll stack
2699427042 break;
2699527043 }
26996- case 2223LLU: // return from reportid to ProcCall
27044+ case 2227LLU: // return from reportid to ProcCall
2699727045 {
2699827046 // copy mutable arguments back from call to reportid
2699927047 fprintf(stderr, "%s", " at position ");
2700027048 // call reportnr from ProcCall
27001- stack[base + 38LLU] = 2224LLU/*throw to this address*/;
27049+ stack[base + 38LLU] = 2228LLU/*throw to this address*/;
2700227050 stack[base + 39LLU] = base;
27003- stack[base + 40LLU] = 2225LLU;
27051+ stack[base + 40LLU] = 2229LLU;
2700427052 // arguments for call to reportnr
2700527053 stack[base + 41LLU] = stack[base + 32]/*index*/;
2700627054 // set stack-base & callee-address
@@ -27008,51 +27056,51 @@
2700827056 label = 18446744073709551589LLU; // reportnr
2700927057 break;
2701027058 }
27011- case 2224LLU: // copy-back deleter (reportnr to ProcCall)
27059+ case 2228LLU: // copy-back deleter (reportnr to ProcCall)
2701227060 {
2701327061 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
2701427062 // copy mutable arguments back from call to reportnr
27015- label = 2178LLU; // continue to roll stack
27063+ label = 2180LLU; // continue to roll stack
2701627064 break;
2701727065 }
27018- case 2225LLU: // return from reportnr to ProcCall
27066+ case 2229LLU: // return from reportnr to ProcCall
2701927067 {
2702027068 // copy mutable arguments back from call to reportnr
2702127069 fprintf(stderr, "%s", " not enough destination-variables for results");
2702227070 fprintf(stderr, "%s", "\n");
2702327071 exit(-1);
27024- label = 2184LLU; // alternative complete
27072+ label = 2186LLU; // alternative complete
2702527073 break;
2702627074 }
27027- case 2184LLU: // completed if-then-else
27075+ case 2186LLU: // completed if-then-else
2702827076 {
2702927077 ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
27030- label = 2176LLU; // repeat
27078+ label = 2178LLU; // repeat
2703127079 break;
2703227080 }
27033- case 2178LLU: // copy-back deleter for while next
27081+ case 2180LLU: // copy-back deleter for while next
2703427082 {
2703527083 ((struct listnode *)(stack[base + 36]/*previous*/))->data = stack[base + 35];
27036- label = 1939LLU; // continue to unroll stack
27084+ label = 1941LLU; // continue to unroll stack
2703727085 break;
2703827086 }
27039- case 2177LLU: // loop finished
27087+ case 2179LLU: // loop finished
2704027088 {
27041- label = 2173LLU; // consequent complete
27089+ label = 2175LLU; // consequent complete
2704227090 break;
2704327091 }
27044- case 2172LLU: // alternative
27092+ case 2174LLU: // alternative
2704527093 {
27046- label = 2173LLU; // alternative complete
27094+ label = 2175LLU; // alternative complete
2704727095 break;
2704827096 }
27049- case 2173LLU: // completed if-then-else
27097+ case 2175LLU: // completed if-then-else
2705027098 {
2705127099 stack[base + 30]/*sum*/ = 0;
2705227100 // call add from ProcCall
27053- stack[base + 34LLU] = 2226LLU/*throw to this address*/;
27101+ stack[base + 34LLU] = 2230LLU/*throw to this address*/;
2705427102 stack[base + 35LLU] = base;
27055- stack[base + 36LLU] = 2227LLU;
27103+ stack[base + 36LLU] = 2231LLU;
2705627104 // arguments for call to add
2705727105 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2705827106 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -27061,22 +27109,22 @@
2706127109 label = 18446744073709551605LLU; // add
2706227110 break;
2706327111 }
27064- case 2226LLU: // copy-back deleter (add to ProcCall)
27112+ case 2230LLU: // copy-back deleter (add to ProcCall)
2706527113 {
2706627114 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2706727115 // copy mutable arguments back from call to add
27068- label = 1939LLU; // continue to roll stack
27116+ label = 1941LLU; // continue to roll stack
2706927117 break;
2707027118 }
27071- case 2227LLU: // return from add to ProcCall
27119+ case 2231LLU: // return from add to ProcCall
2707227120 {
2707327121 // copy mutable arguments back from call to add
2707427122 // copy back results provided by call to add
2707527123 stack[base + 30] = stack[base + 37LLU];
2707627124 // call add from ProcCall
27077- stack[base + 34LLU] = 2228LLU/*throw to this address*/;
27125+ stack[base + 34LLU] = 2232LLU/*throw to this address*/;
2707827126 stack[base + 35LLU] = base;
27079- stack[base + 36LLU] = 2229LLU;
27127+ stack[base + 36LLU] = 2233LLU;
2708027128 // arguments for call to add
2708127129 stack[base + 38LLU] = 3LLU;
2708227130 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -27085,22 +27133,22 @@
2708527133 label = 18446744073709551605LLU; // add
2708627134 break;
2708727135 }
27088- case 2228LLU: // copy-back deleter (add to ProcCall)
27136+ case 2232LLU: // copy-back deleter (add to ProcCall)
2708927137 {
2709027138 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2709127139 // copy mutable arguments back from call to add
27092- label = 1939LLU; // continue to roll stack
27140+ label = 1941LLU; // continue to roll stack
2709327141 break;
2709427142 }
27095- case 2229LLU: // return from add to ProcCall
27143+ case 2233LLU: // return from add to ProcCall
2709627144 {
2709727145 // copy mutable arguments back from call to add
2709827146 // copy back results provided by call to add
2709927147 stack[base + 30] = stack[base + 37LLU];
2710027148 // call add from ProcCall
27101- stack[base + 34LLU] = 2230LLU/*throw to this address*/;
27149+ stack[base + 34LLU] = 2234LLU/*throw to this address*/;
2710227150 stack[base + 35LLU] = base;
27103- stack[base + 36LLU] = 2231LLU;
27151+ stack[base + 36LLU] = 2235LLU;
2710427152 // arguments for call to add
2710527153 stack[base + 38LLU] = stack[base + 28]/*cerescount*/;
2710627154 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -27109,22 +27157,22 @@
2710927157 label = 18446744073709551605LLU; // add
2711027158 break;
2711127159 }
27112- case 2230LLU: // copy-back deleter (add to ProcCall)
27160+ case 2234LLU: // copy-back deleter (add to ProcCall)
2711327161 {
2711427162 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2711527163 // copy mutable arguments back from call to add
27116- label = 1939LLU; // continue to roll stack
27164+ label = 1941LLU; // continue to roll stack
2711727165 break;
2711827166 }
27119- case 2231LLU: // return from add to ProcCall
27167+ case 2235LLU: // return from add to ProcCall
2712027168 {
2712127169 // copy mutable arguments back from call to add
2712227170 // copy back results provided by call to add
2712327171 stack[base + 30] = stack[base + 37LLU];
2712427172 // call add from ProcCall
27125- stack[base + 34LLU] = 2232LLU/*throw to this address*/;
27173+ stack[base + 34LLU] = 2236LLU/*throw to this address*/;
2712627174 stack[base + 35LLU] = base;
27127- stack[base + 36LLU] = 2233LLU;
27175+ stack[base + 36LLU] = 2237LLU;
2712827176 // arguments for call to add
2712927177 stack[base + 38LLU] = stack[base + 29]/*ceargcount*/;
2713027178 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -27133,22 +27181,22 @@
2713327181 label = 18446744073709551605LLU; // add
2713427182 break;
2713527183 }
27136- case 2232LLU: // copy-back deleter (add to ProcCall)
27184+ case 2236LLU: // copy-back deleter (add to ProcCall)
2713727185 {
2713827186 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2713927187 // copy mutable arguments back from call to add
27140- label = 1939LLU; // continue to roll stack
27188+ label = 1941LLU; // continue to roll stack
2714127189 break;
2714227190 }
27143- case 2233LLU: // return from add to ProcCall
27191+ case 2237LLU: // return from add to ProcCall
2714427192 {
2714527193 // copy mutable arguments back from call to add
2714627194 // copy back results provided by call to add
2714727195 stack[base + 30] = stack[base + 37LLU];
2714827196 // call add from ProcCall
27149- stack[base + 34LLU] = 2234LLU/*throw to this address*/;
27197+ stack[base + 34LLU] = 2238LLU/*throw to this address*/;
2715027198 stack[base + 35LLU] = base;
27151- stack[base + 36LLU] = 2235LLU;
27199+ stack[base + 36LLU] = 2239LLU;
2715227200 // arguments for call to add
2715327201 stack[base + 38LLU] = stack[base + 23]/*cemaxcount*/;
2715427202 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -27157,22 +27205,22 @@
2715727205 label = 18446744073709551605LLU; // add
2715827206 break;
2715927207 }
27160- case 2234LLU: // copy-back deleter (add to ProcCall)
27208+ case 2238LLU: // copy-back deleter (add to ProcCall)
2716127209 {
2716227210 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
2716327211 // copy mutable arguments back from call to add
27164- label = 1939LLU; // continue to roll stack
27212+ label = 1941LLU; // continue to roll stack
2716527213 break;
2716627214 }
27167- case 2235LLU: // return from add to ProcCall
27215+ case 2239LLU: // return from add to ProcCall
2716827216 {
2716927217 // copy mutable arguments back from call to add
2717027218 // copy back results provided by call to add
2717127219 stack[base + 30] = stack[base + 37LLU];
2717227220 // call max from ProcCall
27173- stack[base + 34LLU] = 2236LLU/*throw to this address*/;
27221+ stack[base + 34LLU] = 2240LLU/*throw to this address*/;
2717427222 stack[base + 35LLU] = base;
27175- stack[base + 36LLU] = 2237LLU;
27223+ stack[base + 36LLU] = 2241LLU;
2717627224 // arguments for call to max
2717727225 stack[base + 38LLU] = stack[base + 30]/*sum*/;
2717827226 stack[base + 39LLU] = stack[base + 12]/*fnmaxcount*/;
@@ -27181,14 +27229,14 @@
2718127229 label = 18446744073709551606LLU; // max
2718227230 break;
2718327231 }
27184- case 2236LLU: // copy-back deleter (max to ProcCall)
27232+ case 2240LLU: // copy-back deleter (max to ProcCall)
2718527233 {
2718627234 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (max to ProcCall)\n");
2718727235 // copy mutable arguments back from call to max
27188- label = 1939LLU; // continue to roll stack
27236+ label = 1941LLU; // continue to roll stack
2718927237 break;
2719027238 }
27191- case 2237LLU: // return from max to ProcCall
27239+ case 2241LLU: // return from max to ProcCall
2719227240 {
2719327241 // copy mutable arguments back from call to max
2719427242 // copy back results provided by call to max
@@ -27200,7 +27248,7 @@
2720027248 {
2720127249 if(!stack[base + 0]/*dsttypeids*/)
2720227250 {
27203- label = 2238LLU; // jump to alternative
27251+ label = 2242LLU; // jump to alternative
2720427252 break;
2720527253 }
2720627254
@@ -27207,9 +27255,9 @@
2720727255 // consequent
2720827256 fprintf(stderr, "%s", "in function ");
2720927257 // call reportid from ProcCall
27210- stack[base + 30LLU] = 2240LLU/*throw to this address*/;
27258+ stack[base + 30LLU] = 2244LLU/*throw to this address*/;
2721127259 stack[base + 31LLU] = base;
27212- stack[base + 32LLU] = 2241LLU;
27260+ stack[base + 32LLU] = 2245LLU;
2721327261 // arguments for call to reportid
2721427262 stack[base + 33LLU] = stack[base + 8]/*fnid*/;
2721527263 // set stack-base & callee-address
@@ -27217,7 +27265,7 @@
2721727265 label = 18446744073709551586LLU; // reportid
2721827266 break;
2721927267 }
27220- case 2240LLU: // copy-back deleter (reportid to ProcCall)
27268+ case 2244LLU: // copy-back deleter (reportid to ProcCall)
2722127269 {
2722227270 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2722327271 // copy mutable arguments back from call to reportid
@@ -27224,14 +27272,14 @@
2722427272 label = 1596LLU; // continue to roll stack
2722527273 break;
2722627274 }
27227- case 2241LLU: // return from reportid to ProcCall
27275+ case 2245LLU: // return from reportid to ProcCall
2722827276 {
2722927277 // copy mutable arguments back from call to reportid
2723027278 fprintf(stderr, "%s", " call to ");
2723127279 // call reportid from ProcCall
27232- stack[base + 30LLU] = 2242LLU/*throw to this address*/;
27280+ stack[base + 30LLU] = 2246LLU/*throw to this address*/;
2723327281 stack[base + 31LLU] = base;
27234- stack[base + 32LLU] = 2243LLU;
27282+ stack[base + 32LLU] = 2247LLU;
2723527283 // arguments for call to reportid
2723627284 stack[base + 33LLU] = stack[base + 24]/*ceid*/;
2723727285 // set stack-base & callee-address
@@ -27239,7 +27287,7 @@
2723927287 label = 18446744073709551586LLU; // reportid
2724027288 break;
2724127289 }
27242- case 2242LLU: // copy-back deleter (reportid to ProcCall)
27290+ case 2246LLU: // copy-back deleter (reportid to ProcCall)
2724327291 {
2724427292 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
2724527293 // copy mutable arguments back from call to reportid
@@ -27246,21 +27294,21 @@
2724627294 label = 1596LLU; // continue to roll stack
2724727295 break;
2724827296 }
27249- case 2243LLU: // return from reportid to ProcCall
27297+ case 2247LLU: // return from reportid to ProcCall
2725027298 {
2725127299 // copy mutable arguments back from call to reportid
2725227300 fprintf(stderr, "%s", " not enough results to fill all destination-variables");
2725327301 fprintf(stderr, "%s", "\n");
2725427302 exit(-1);
27255- label = 2239LLU; // consequent complete
27303+ label = 2243LLU; // consequent complete
2725627304 break;
2725727305 }
27258- case 2238LLU: // alternative
27306+ case 2242LLU: // alternative
2725927307 {
27260- label = 2239LLU; // alternative complete
27308+ label = 2243LLU; // alternative complete
2726127309 break;
2726227310 }
27263- case 2239LLU: // completed if-then-else
27311+ case 2243LLU: // completed if-then-else
2726427312 {
2726527313 ((uint64_t **)(stack[base + 13]))[1][7] = stack[base + 27];
2726627314 ((uint64_t **)(stack[base + 13]))[1][6] = stack[base + 26];
@@ -27294,14 +27342,14 @@
2729427342 case 1575LLU: // completed switch
2729527343 {
2729627344 // delete list
27297- label = 2244LLU; // start to repeat
27345+ label = 2248LLU; // start to repeat
2729827346 break;
2729927347 }
27300- case 2244LLU: // repeat from here
27348+ case 2248LLU: // repeat from here
2730127349 {
2730227350 if(!stack[base + 19])
2730327351 {
27304- label = 2245LLU; // break loop
27352+ label = 2249LLU; // break loop
2730527353 break;
2730627354 }
2730727355
@@ -27312,7 +27360,7 @@
2731227360 newstack[0] = (uint64_t)stack; // backup stack location
2731327361 newstack[1] = 1234567890;
2731427362 newstack[2] = base;
27315- newstack[3] = 2246LLU;
27363+ newstack[3] = 2250LLU;
2731627364 stack = newstack;
2731727365 // set stack-base & callee-address
2731827366 base = 4/*deloffset*/;
@@ -27319,7 +27367,7 @@
2731927367 label = 798LLU; // ~idnr
2732027368 break;
2732127369 }
27322- case 2246LLU: // return from ~idnr to ProcCall
27370+ case 2250LLU: // return from ~idnr to ProcCall
2732327371 {
2732427372 stack = (uint64_t *)stack[0];
2732527373 // releasing toplevel container
@@ -27330,15 +27378,15 @@
2733027378 stack[base + 19] = (uint64_t)list->next;
2733127379 Free(1, sizeof(struct listnode), list);
2733227380 }
27333- label = 2244LLU; // repeat
27381+ label = 2248LLU; // repeat
2733427382 break;
2733527383 }
27336- case 2245LLU: // loop finished
27384+ case 2249LLU: // loop finished
2733727385 {
2733827386 // call MATCHPEEK from ProcCall
27339- stack[base + 19LLU] = 2247LLU/*throw to this address*/;
27387+ stack[base + 19LLU] = 2251LLU/*throw to this address*/;
2734027388 stack[base + 20LLU] = base;
27341- stack[base + 21LLU] = 2248LLU;
27389+ stack[base + 21LLU] = 2252LLU;
2734227390 // arguments for call to MATCHPEEK
2734327391 stack[base + 22LLU] = stack[base + 8]/*fnid*/;
2734427392 stack[base + 23LLU] = 41LLU;
@@ -27348,7 +27396,7 @@
2734827396 label = 198LLU; // MATCHPEEK
2734927397 break;
2735027398 }
27351- case 2247LLU: // copy-back deleter (MATCHPEEK to ProcCall)
27399+ case 2251LLU: // copy-back deleter (MATCHPEEK to ProcCall)
2735227400 {
2735327401 fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (MATCHPEEK to ProcCall)\n");
2735427402 // copy mutable arguments back from call to MATCHPEEK
@@ -27356,7 +27404,7 @@
2735627404 label = 1568LLU; // continue to roll stack
2735727405 break;
2735827406 }
27359- case 2248LLU: // return from MATCHPEEK to ProcCall
27407+ case 2252LLU: // return from MATCHPEEK to ProcCall
2736027408 {
2736127409 // copy mutable arguments back from call to MATCHPEEK
2736227410 stack[base + 14]/*lookahead*/ = stack[base + 24LLU];
@@ -27365,7 +27413,7 @@
2736527413 base = stack[base - 2];
2736627414 break;
2736727415 }
27368- case 2250LLU: // function initfrom failed
27416+ case 2254LLU: // function initfrom failed
2736927417 {
2737027418 fprintf(stderr, "function initfrom failed\n");
2737127419 label = stack[base - 3];
@@ -27372,7 +27420,7 @@
2737227420 base = stack[base - 2];
2737327421 break;
2737427422 }
27375- case 2249LLU: // initfrom
27423+ case 2253LLU: // initfrom
2737627424 {
2737727425 //#define arg0 0
2737827426 //#define arg1 1
@@ -27383,67 +27431,67 @@
2738327431 //#define arg6 6
2738427432 //#define arg7 7
2738527433 //#define arg8 8
27386- label = 2252LLU; // skip deleter
27434+ label = 2256LLU; // skip deleter
2738727435 break;
2738827436 }
27389- case 2251LLU: // deleter
27437+ case 2255LLU: // deleter
2739027438 {
2739127439 // throw from initfrom
2739227440 if(!stack[base + 9])
2739327441 {
2739427442 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27395- label = 2250LLU; // skip, variable already deleted/unscoped
27443+ label = 2254LLU; // skip, variable already deleted/unscoped
2739627444 break;
2739727445 }
2739827446 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27399- label = 2250LLU; // continue unrolling stack, delete next variable
27447+ label = 2254LLU; // continue unrolling stack, delete next variable
2740027448 break;
2740127449 }
27402- case 2252LLU: // skipped deleter
27450+ case 2256LLU: // skipped deleter
2740327451 {
2740427452 stack[base + 9] = 0;
27405- label = 2254LLU; // skip deleter
27453+ label = 2258LLU; // skip deleter
2740627454 break;
2740727455 }
27408- case 2253LLU: // deleter
27456+ case 2257LLU: // deleter
2740927457 {
2741027458 // throw from initfrom
2741127459 if(!stack[base + 10])
2741227460 {
2741327461 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27414- label = 2251LLU; // skip, variable already deleted/unscoped
27462+ label = 2255LLU; // skip, variable already deleted/unscoped
2741527463 break;
2741627464 }
2741727465 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27418- label = 2251LLU; // continue unrolling stack, delete next variable
27466+ label = 2255LLU; // continue unrolling stack, delete next variable
2741927467 break;
2742027468 }
27421- case 2254LLU: // skipped deleter
27469+ case 2258LLU: // skipped deleter
2742227470 {
2742327471 stack[base + 10] = 0;
27424- label = 2256LLU; // skip deleter
27472+ label = 2260LLU; // skip deleter
2742527473 break;
2742627474 }
27427- case 2255LLU: // deleter
27475+ case 2259LLU: // deleter
2742827476 {
2742927477 // throw from initfrom
2743027478 if(!stack[base + 11])
2743127479 {
2743227480 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27433- label = 2253LLU; // skip, variable already deleted/unscoped
27481+ label = 2257LLU; // skip, variable already deleted/unscoped
2743427482 break;
2743527483 }
2743627484 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27437- label = 2253LLU; // continue unrolling stack, delete next variable
27485+ label = 2257LLU; // continue unrolling stack, delete next variable
2743827486 break;
2743927487 }
27440- case 2256LLU: // skipped deleter
27488+ case 2260LLU: // skipped deleter
2744127489 {
2744227490 stack[base + 11] = 0;
2744327491 // call add from initfrom
27444- stack[base + 12LLU] = 2257LLU/*throw to this address*/;
27492+ stack[base + 12LLU] = 2261LLU/*throw to this address*/;
2744527493 stack[base + 13LLU] = base;
27446- stack[base + 14LLU] = 2258LLU;
27494+ stack[base + 14LLU] = 2262LLU;
2744727495 // arguments for call to add
2744827496 stack[base + 16LLU] = 1LLU;
2744927497 stack[base + 17LLU] = stack[base + 7]/*label*/;
@@ -27452,40 +27500,40 @@
2745227500 label = 18446744073709551605LLU; // add
2745327501 break;
2745427502 }
27455- case 2257LLU: // copy-back deleter (add to initfrom)
27503+ case 2261LLU: // copy-back deleter (add to initfrom)
2745627504 {
2745727505 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2745827506 // copy mutable arguments back from call to add
27459- label = 2255LLU; // continue to roll stack
27507+ label = 2259LLU; // continue to roll stack
2746027508 break;
2746127509 }
27462- case 2258LLU: // return from add to initfrom
27510+ case 2262LLU: // return from add to initfrom
2746327511 {
2746427512 // copy mutable arguments back from call to add
2746527513 // copy back results provided by call to add
2746627514 stack[base + 7] = stack[base + 15LLU];
27467- label = 2260LLU; // skip deleter
27515+ label = 2264LLU; // skip deleter
2746827516 break;
2746927517 }
27470- case 2259LLU: // deleter
27518+ case 2263LLU: // deleter
2747127519 {
2747227520 // throw from initfrom
2747327521 if(!stack[base + 12])
2747427522 {
2747527523 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27476- label = 2255LLU; // skip, variable already deleted/unscoped
27524+ label = 2259LLU; // skip, variable already deleted/unscoped
2747727525 break;
2747827526 }
2747927527 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27480- label = 2255LLU; // continue unrolling stack, delete next variable
27528+ label = 2259LLU; // continue unrolling stack, delete next variable
2748127529 break;
2748227530 }
27483- case 2260LLU: // skipped deleter
27531+ case 2264LLU: // skipped deleter
2748427532 {
2748527533 stack[base + 12] = stack[base + 7]/*label*/;
2748627534 if(/*scope*/0 != ((uint64_t *)(stack[base + 5]/*scope*/))[0])
2748727535 {
27488- label = 2262LLU; // jump to alternative
27536+ label = 2266LLU; // jump to alternative
2748927537 break;
2749027538 }
2749127539
@@ -27494,9 +27542,9 @@
2749427542
2749527543 // case
2749627544 // call add from initfrom
27497- stack[base + 15LLU] = 2264LLU/*throw to this address*/;
27545+ stack[base + 15LLU] = 2268LLU/*throw to this address*/;
2749827546 stack[base + 16LLU] = base;
27499- stack[base + 17LLU] = 2265LLU;
27547+ stack[base + 17LLU] = 2269LLU;
2750027548 // arguments for call to add
2750127549 stack[base + 19LLU] = 1LLU;
2750227550 stack[base + 20LLU] = stack[base + 7]/*label*/;
@@ -27505,42 +27553,42 @@
2750527553 label = 18446744073709551605LLU; // add
2750627554 break;
2750727555 }
27508- case 2264LLU: // copy-back deleter (add to initfrom)
27556+ case 2268LLU: // copy-back deleter (add to initfrom)
2750927557 {
2751027558 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2751127559 // copy mutable arguments back from call to add
27512- label = 2263LLU; // continue to roll stack
27560+ label = 2267LLU; // continue to roll stack
2751327561 break;
2751427562 }
27515- case 2265LLU: // return from add to initfrom
27563+ case 2269LLU: // return from add to initfrom
2751627564 {
2751727565 // copy mutable arguments back from call to add
2751827566 // copy back results provided by call to add
2751927567 stack[base + 7] = stack[base + 18LLU];
27520- label = 2267LLU; // skip deleter
27568+ label = 2271LLU; // skip deleter
2752127569 break;
2752227570 }
27523- case 2266LLU: // deleter
27571+ case 2270LLU: // deleter
2752427572 {
2752527573 // throw from initfrom
2752627574 if(!stack[base + 15])
2752727575 {
2752827576 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27529- label = 2263LLU; // skip, variable already deleted/unscoped
27577+ label = 2267LLU; // skip, variable already deleted/unscoped
2753027578 break;
2753127579 }
2753227580 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27533- label = 2263LLU; // continue unrolling stack, delete next variable
27581+ label = 2267LLU; // continue unrolling stack, delete next variable
2753427582 break;
2753527583 }
27536- case 2267LLU: // skipped deleter
27584+ case 2271LLU: // skipped deleter
2753727585 {
2753827586 stack[base + 15] = stack[base + 7]/*label*/;
2753927587 printf("%s", "\n label = ");
2754027588 // call printnr from initfrom
27541- stack[base + 16LLU] = 2268LLU/*throw to this address*/;
27589+ stack[base + 16LLU] = 2272LLU/*throw to this address*/;
2754227590 stack[base + 17LLU] = base;
27543- stack[base + 18LLU] = 2269LLU;
27591+ stack[base + 18LLU] = 2273LLU;
2754427592 // arguments for call to printnr
2754527593 stack[base + 19LLU] = stack[base + 15]/*labelskip*/;
2754627594 // set stack-base & callee-address
@@ -27548,14 +27596,14 @@
2754827596 label = 18446744073709551590LLU; // printnr
2754927597 break;
2755027598 }
27551- case 2268LLU: // copy-back deleter (printnr to initfrom)
27599+ case 2272LLU: // copy-back deleter (printnr to initfrom)
2755227600 {
2755327601 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2755427602 // copy mutable arguments back from call to printnr
27555- label = 2266LLU; // continue to roll stack
27603+ label = 2270LLU; // continue to roll stack
2755627604 break;
2755727605 }
27558- case 2269LLU: // return from printnr to initfrom
27606+ case 2273LLU: // return from printnr to initfrom
2755927607 {
2756027608 // copy mutable arguments back from call to printnr
2756127609 printf("%s", "LLU; // skip deleter");
@@ -27563,9 +27611,9 @@
2756327611 printf("%s", "\n }");
2756427612 printf("%s", "\n case ");
2756527613 // call printnr from initfrom
27566- stack[base + 16LLU] = 2270LLU/*throw to this address*/;
27614+ stack[base + 16LLU] = 2274LLU/*throw to this address*/;
2756727615 stack[base + 17LLU] = base;
27568- stack[base + 18LLU] = 2271LLU;
27616+ stack[base + 18LLU] = 2275LLU;
2756927617 // arguments for call to printnr
2757027618 stack[base + 19LLU] = stack[base + 12]/*labelfail*/;
2757127619 // set stack-base & callee-address
@@ -27573,14 +27621,14 @@
2757327621 label = 18446744073709551590LLU; // printnr
2757427622 break;
2757527623 }
27576- case 2270LLU: // copy-back deleter (printnr to initfrom)
27624+ case 2274LLU: // copy-back deleter (printnr to initfrom)
2757727625 {
2757827626 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2757927627 // copy mutable arguments back from call to printnr
27580- label = 2266LLU; // continue to roll stack
27628+ label = 2270LLU; // continue to roll stack
2758127629 break;
2758227630 }
27583- case 2271LLU: // return from printnr to initfrom
27631+ case 2275LLU: // return from printnr to initfrom
2758427632 {
2758527633 // copy mutable arguments back from call to printnr
2758627634 printf("%s", "LLU: // deleter");
@@ -27587,9 +27635,9 @@
2758727635 printf("%s", "\n {");
2758827636 printf("%s", "\n // throw from ");
2758927637 // call printid from initfrom
27590- stack[base + 16LLU] = 2272LLU/*throw to this address*/;
27638+ stack[base + 16LLU] = 2276LLU/*throw to this address*/;
2759127639 stack[base + 17LLU] = base;
27592- stack[base + 18LLU] = 2273LLU;
27640+ stack[base + 18LLU] = 2277LLU;
2759327641 // arguments for call to printid
2759427642 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
2759527643 // set stack-base & callee-address
@@ -27597,21 +27645,21 @@
2759727645 label = 18446744073709551587LLU; // printid
2759827646 break;
2759927647 }
27600- case 2272LLU: // copy-back deleter (printid to initfrom)
27648+ case 2276LLU: // copy-back deleter (printid to initfrom)
2760127649 {
2760227650 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2760327651 // copy mutable arguments back from call to printid
27604- label = 2266LLU; // continue to roll stack
27652+ label = 2270LLU; // continue to roll stack
2760527653 break;
2760627654 }
27607- case 2273LLU: // return from printid to initfrom
27655+ case 2277LLU: // return from printid to initfrom
2760827656 {
2760927657 // copy mutable arguments back from call to printid
2761027658 printf("%s", "\n if(!");
2761127659 // call emitvaridx from initfrom
27612- stack[base + 16LLU] = 2274LLU/*throw to this address*/;
27660+ stack[base + 16LLU] = 2278LLU/*throw to this address*/;
2761327661 stack[base + 17LLU] = base;
27614- stack[base + 18LLU] = 2275LLU;
27662+ stack[base + 18LLU] = 2279LLU;
2761527663 // arguments for call to emitvaridx
2761627664 stack[base + 19LLU] = stack[base + 2]/*dstindex*/;
2761727665 // set stack-base & callee-address
@@ -27619,14 +27667,14 @@
2761927667 label = 691LLU; // emitvaridx
2762027668 break;
2762127669 }
27622- case 2274LLU: // copy-back deleter (emitvaridx to initfrom)
27670+ case 2278LLU: // copy-back deleter (emitvaridx to initfrom)
2762327671 {
2762427672 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2762527673 // copy mutable arguments back from call to emitvaridx
27626- label = 2266LLU; // continue to roll stack
27674+ label = 2270LLU; // continue to roll stack
2762727675 break;
2762827676 }
27629- case 2275LLU: // return from emitvaridx to initfrom
27677+ case 2279LLU: // return from emitvaridx to initfrom
2763027678 {
2763127679 // copy mutable arguments back from call to emitvaridx
2763227680 printf("%s", ")");
@@ -27633,9 +27681,9 @@
2763327681 printf("%s", "\n {");
2763427682 printf("%s", "\n fprintf(stderr, \"in function ");
2763527683 // call printid from initfrom
27636- stack[base + 16LLU] = 2276LLU/*throw to this address*/;
27684+ stack[base + 16LLU] = 2280LLU/*throw to this address*/;
2763727685 stack[base + 17LLU] = base;
27638- stack[base + 18LLU] = 2277LLU;
27686+ stack[base + 18LLU] = 2281LLU;
2763927687 // arguments for call to printid
2764027688 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
2764127689 // set stack-base & callee-address
@@ -27643,14 +27691,14 @@
2764327691 label = 18446744073709551587LLU; // printid
2764427692 break;
2764527693 }
27646- case 2276LLU: // copy-back deleter (printid to initfrom)
27694+ case 2280LLU: // copy-back deleter (printid to initfrom)
2764727695 {
2764827696 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2764927697 // copy mutable arguments back from call to printid
27650- label = 2266LLU; // continue to roll stack
27698+ label = 2270LLU; // continue to roll stack
2765127699 break;
2765227700 }
27653- case 2277LLU: // return from printid to initfrom
27701+ case 2281LLU: // return from printid to initfrom
2765427702 {
2765527703 // copy mutable arguments back from call to printid
2765627704 printf("%s", ": unrolling stack, skipping already deleted/unscoped variable ");
@@ -27657,7 +27705,7 @@
2765727705 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2765827706 if(!newstack)
2765927707 {
27660- label = 2266LLU; // throw: begin to unroll stack
27708+ label = 2270LLU; // throw: begin to unroll stack
2766127709 break;
2766227710 }
2766327711
@@ -27664,9 +27712,9 @@
2766427712 newstack[10LLU] = 9876543210LLU; // overflow-marker
2766527713 // call printtype from initfrom
2766627714 newstack[0] = (uint64_t)stack; // backup stack location
27667- newstack[1] = 2278LLU;
27715+ newstack[1] = 2282LLU;
2766827716 newstack[2] = base;
27669- newstack[3] = 2279LLU;
27717+ newstack[3] = 2283LLU;
2767027718 // arguments for call to printtype
2767127719 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2767227720 stack = newstack;
@@ -27675,7 +27723,7 @@
2767527723 label = 305LLU; // printtype
2767627724 break;
2767727725 }
27678- case 2278LLU: // copy-back deleter (printtype to initfrom)
27726+ case 2282LLU: // copy-back deleter (printtype to initfrom)
2767927727 {
2768027728 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
2768127729 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -27687,10 +27735,10 @@
2768727735 }
2768827736 Free(10LLU + 1, sizeof(uint64_t), stack);
2768927737 stack = oldstack;
27690- label = 2266LLU; // continue to unroll stack
27738+ label = 2270LLU; // continue to unroll stack
2769127739 break;
2769227740 }
27693- case 2279LLU: // return from printtype to initfrom
27741+ case 2283LLU: // return from printtype to initfrom
2769427742 {
2769527743 uint64_t *oldstack = (uint64_t *)stack[0];
2769627744 // copy mutable arguments back from call to printtype
@@ -27703,9 +27751,9 @@
2770327751 stack = oldstack;
2770427752 printf("%s", " ");
2770527753 // call printid from initfrom
27706- stack[base + 16LLU] = 2280LLU/*throw to this address*/;
27754+ stack[base + 16LLU] = 2284LLU/*throw to this address*/;
2770727755 stack[base + 17LLU] = base;
27708- stack[base + 18LLU] = 2281LLU;
27756+ stack[base + 18LLU] = 2285LLU;
2770927757 // arguments for call to printid
2771027758 stack[base + 19LLU] = stack[base + 11]/*content*/;
2771127759 // set stack-base & callee-address
@@ -27713,22 +27761,22 @@
2771327761 label = 18446744073709551587LLU; // printid
2771427762 break;
2771527763 }
27716- case 2280LLU: // copy-back deleter (printid to initfrom)
27764+ case 2284LLU: // copy-back deleter (printid to initfrom)
2771727765 {
2771827766 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2771927767 // copy mutable arguments back from call to printid
27720- label = 2266LLU; // continue to roll stack
27768+ label = 2270LLU; // continue to roll stack
2772127769 break;
2772227770 }
27723- case 2281LLU: // return from printid to initfrom
27771+ case 2285LLU: // return from printid to initfrom
2772427772 {
2772527773 // copy mutable arguments back from call to printid
2772627774 printf("%s", "\\n\");");
2772727775 printf("%s", "\n label = ");
2772827776 // call printnr from initfrom
27729- stack[base + 16LLU] = 2282LLU/*throw to this address*/;
27777+ stack[base + 16LLU] = 2286LLU/*throw to this address*/;
2773027778 stack[base + 17LLU] = base;
27731- stack[base + 18LLU] = 2283LLU;
27779+ stack[base + 18LLU] = 2287LLU;
2773227780 // arguments for call to printnr
2773327781 stack[base + 19LLU] = stack[base + 13]/*labelthrow*/;
2773427782 // set stack-base & callee-address
@@ -27736,14 +27784,14 @@
2773627784 label = 18446744073709551590LLU; // printnr
2773727785 break;
2773827786 }
27739- case 2282LLU: // copy-back deleter (printnr to initfrom)
27787+ case 2286LLU: // copy-back deleter (printnr to initfrom)
2774027788 {
2774127789 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2774227790 // copy mutable arguments back from call to printnr
27743- label = 2266LLU; // continue to roll stack
27791+ label = 2270LLU; // continue to roll stack
2774427792 break;
2774527793 }
27746- case 2283LLU: // return from printnr to initfrom
27794+ case 2287LLU: // return from printnr to initfrom
2774727795 {
2774827796 // copy mutable arguments back from call to printnr
2774927797 printf("%s", "LLU; // skip, variable already deleted/unscoped");
@@ -27751,9 +27799,9 @@
2775127799 printf("%s", "\n }");
2775227800 printf("%s", "\n fprintf(stderr, \"in function ");
2775327801 // call printid from initfrom
27754- stack[base + 16LLU] = 2284LLU/*throw to this address*/;
27802+ stack[base + 16LLU] = 2288LLU/*throw to this address*/;
2775527803 stack[base + 17LLU] = base;
27756- stack[base + 18LLU] = 2285LLU;
27804+ stack[base + 18LLU] = 2289LLU;
2775727805 // arguments for call to printid
2775827806 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
2775927807 // set stack-base & callee-address
@@ -27761,14 +27809,14 @@
2776127809 label = 18446744073709551587LLU; // printid
2776227810 break;
2776327811 }
27764- case 2284LLU: // copy-back deleter (printid to initfrom)
27812+ case 2288LLU: // copy-back deleter (printid to initfrom)
2776527813 {
2776627814 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2776727815 // copy mutable arguments back from call to printid
27768- label = 2266LLU; // continue to roll stack
27816+ label = 2270LLU; // continue to roll stack
2776927817 break;
2777027818 }
27771- case 2285LLU: // return from printid to initfrom
27819+ case 2289LLU: // return from printid to initfrom
2777227820 {
2777327821 // copy mutable arguments back from call to printid
2777427822 printf("%s", ": unrolling stack, variable ");
@@ -27775,7 +27823,7 @@
2777527823 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2777627824 if(!newstack)
2777727825 {
27778- label = 2266LLU; // throw: begin to unroll stack
27826+ label = 2270LLU; // throw: begin to unroll stack
2777927827 break;
2778027828 }
2778127829
@@ -27782,9 +27830,9 @@
2778227830 newstack[10LLU] = 9876543210LLU; // overflow-marker
2778327831 // call printtype from initfrom
2778427832 newstack[0] = (uint64_t)stack; // backup stack location
27785- newstack[1] = 2286LLU;
27833+ newstack[1] = 2290LLU;
2778627834 newstack[2] = base;
27787- newstack[3] = 2287LLU;
27835+ newstack[3] = 2291LLU;
2778827836 // arguments for call to printtype
2778927837 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2779027838 stack = newstack;
@@ -27793,7 +27841,7 @@
2779327841 label = 305LLU; // printtype
2779427842 break;
2779527843 }
27796- case 2286LLU: // copy-back deleter (printtype to initfrom)
27844+ case 2290LLU: // copy-back deleter (printtype to initfrom)
2779727845 {
2779827846 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
2779927847 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -27805,10 +27853,10 @@
2780527853 }
2780627854 Free(10LLU + 1, sizeof(uint64_t), stack);
2780727855 stack = oldstack;
27808- label = 2266LLU; // continue to unroll stack
27856+ label = 2270LLU; // continue to unroll stack
2780927857 break;
2781027858 }
27811- case 2287LLU: // return from printtype to initfrom
27859+ case 2291LLU: // return from printtype to initfrom
2781227860 {
2781327861 uint64_t *oldstack = (uint64_t *)stack[0];
2781427862 // copy mutable arguments back from call to printtype
@@ -27821,9 +27869,9 @@
2782127869 stack = oldstack;
2782227870 printf("%s", " ");
2782327871 // call printid from initfrom
27824- stack[base + 16LLU] = 2288LLU/*throw to this address*/;
27872+ stack[base + 16LLU] = 2292LLU/*throw to this address*/;
2782527873 stack[base + 17LLU] = base;
27826- stack[base + 18LLU] = 2289LLU;
27874+ stack[base + 18LLU] = 2293LLU;
2782727875 // arguments for call to printid
2782827876 stack[base + 19LLU] = stack[base + 11]/*content*/;
2782927877 // set stack-base & callee-address
@@ -27831,14 +27879,14 @@
2783127879 label = 18446744073709551587LLU; // printid
2783227880 break;
2783327881 }
27834- case 2288LLU: // copy-back deleter (printid to initfrom)
27882+ case 2292LLU: // copy-back deleter (printid to initfrom)
2783527883 {
2783627884 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2783727885 // copy mutable arguments back from call to printid
27838- label = 2266LLU; // continue to roll stack
27886+ label = 2270LLU; // continue to roll stack
2783927887 break;
2784027888 }
27841- case 2289LLU: // return from printid to initfrom
27889+ case 2293LLU: // return from printid to initfrom
2784227890 {
2784327891 // copy mutable arguments back from call to printid
2784427892 printf("%s", "\\n\");");
@@ -27845,7 +27893,7 @@
2784527893 uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t));
2784627894 if(!newstack)
2784727895 {
27848- label = 2266LLU; // throw: begin to unroll stack
27896+ label = 2270LLU; // throw: begin to unroll stack
2784927897 break;
2785027898 }
2785127899
@@ -27852,9 +27900,9 @@
2785227900 newstack[75LLU] = 9876543210LLU; // overflow-marker
2785327901 // call calldestr from initfrom
2785427902 newstack[0] = (uint64_t)stack; // backup stack location
27855- newstack[1] = 2290LLU;
27903+ newstack[1] = 2294LLU;
2785627904 newstack[2] = base;
27857- newstack[3] = 2291LLU;
27905+ newstack[3] = 2295LLU;
2785827906 // arguments for call to calldestr
2785927907 newstack[4LLU] = stack[base + 0]/*fnid*/;
2786027908 newstack[5LLU] = stack[base + 3]/*typedefs*/;
@@ -27868,7 +27916,7 @@
2786827916 label = 1084LLU; // calldestr
2786927917 break;
2787027918 }
27871- case 2290LLU: // copy-back deleter (calldestr to initfrom)
27919+ case 2294LLU: // copy-back deleter (calldestr to initfrom)
2787227920 {
2787327921 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (calldestr to initfrom)\n");
2787427922 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -27881,10 +27929,10 @@
2788127929 }
2788227930 Free(75LLU + 1, sizeof(uint64_t), stack);
2788327931 stack = oldstack;
27884- label = 2266LLU; // continue to unroll stack
27932+ label = 2270LLU; // continue to unroll stack
2788527933 break;
2788627934 }
27887- case 2291LLU: // return from calldestr to initfrom
27935+ case 2295LLU: // return from calldestr to initfrom
2788827936 {
2788927937 uint64_t *oldstack = (uint64_t *)stack[0];
2789027938 // copy mutable arguments back from call to calldestr
@@ -27898,9 +27946,9 @@
2789827946 stack = oldstack;
2789927947 printf("%s", "\n label = ");
2790027948 // call printnr from initfrom
27901- stack[base + 16LLU] = 2292LLU/*throw to this address*/;
27949+ stack[base + 16LLU] = 2296LLU/*throw to this address*/;
2790227950 stack[base + 17LLU] = base;
27903- stack[base + 18LLU] = 2293LLU;
27951+ stack[base + 18LLU] = 2297LLU;
2790427952 // arguments for call to printnr
2790527953 stack[base + 19LLU] = stack[base + 13]/*labelthrow*/;
2790627954 // set stack-base & callee-address
@@ -27908,14 +27956,14 @@
2790827956 label = 18446744073709551590LLU; // printnr
2790927957 break;
2791027958 }
27911- case 2292LLU: // copy-back deleter (printnr to initfrom)
27959+ case 2296LLU: // copy-back deleter (printnr to initfrom)
2791227960 {
2791327961 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2791427962 // copy mutable arguments back from call to printnr
27915- label = 2266LLU; // continue to roll stack
27963+ label = 2270LLU; // continue to roll stack
2791627964 break;
2791727965 }
27918- case 2293LLU: // return from printnr to initfrom
27966+ case 2297LLU: // return from printnr to initfrom
2791927967 {
2792027968 // copy mutable arguments back from call to printnr
2792127969 printf("%s", "LLU; // continue unrolling stack, delete next variable");
@@ -27923,9 +27971,9 @@
2792327971 printf("%s", "\n }");
2792427972 printf("%s", "\n case ");
2792527973 // call printnr from initfrom
27926- stack[base + 16LLU] = 2294LLU/*throw to this address*/;
27974+ stack[base + 16LLU] = 2298LLU/*throw to this address*/;
2792727975 stack[base + 17LLU] = base;
27928- stack[base + 18LLU] = 2295LLU;
27976+ stack[base + 18LLU] = 2299LLU;
2792927977 // arguments for call to printnr
2793027978 stack[base + 19LLU] = stack[base + 15]/*labelskip*/;
2793127979 // set stack-base & callee-address
@@ -27933,14 +27981,14 @@
2793327981 label = 18446744073709551590LLU; // printnr
2793427982 break;
2793527983 }
27936- case 2294LLU: // copy-back deleter (printnr to initfrom)
27984+ case 2298LLU: // copy-back deleter (printnr to initfrom)
2793727985 {
2793827986 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2793927987 // copy mutable arguments back from call to printnr
27940- label = 2266LLU; // continue to roll stack
27988+ label = 2270LLU; // continue to roll stack
2794127989 break;
2794227990 }
27943- case 2295LLU: // return from printnr to initfrom
27991+ case 2299LLU: // return from printnr to initfrom
2794427992 {
2794527993 // copy mutable arguments back from call to printnr
2794627994 printf("%s", "LLU: // skipped deleter");
@@ -27947,27 +27995,27 @@
2794727995 printf("%s", "\n {");
2794827996 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
2794927997 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
27950- label = 2261LLU; // case complete
27998+ label = 2265LLU; // case complete
2795127999 break;
2795228000 }
27953- case 2263LLU: // copy-back deleter (switch)
28001+ case 2267LLU: // copy-back deleter (switch)
2795428002 {
2795528003 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
2795628004 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
27957- label = 2259LLU; // continue to unroll stack
28005+ label = 2263LLU; // continue to unroll stack
2795828006 break;
2795928007 }
27960- case 2262LLU: // try next case
28008+ case 2266LLU: // try next case
2796128009 {
2796228010 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2796328011 exit(-1);
2796428012 }
27965- case 2261LLU: // completed switch
28013+ case 2265LLU: // completed switch
2796628014 {
2796728015 // call ParseToken from initfrom
27968- stack[base + 13LLU] = 2296LLU/*throw to this address*/;
28016+ stack[base + 13LLU] = 2300LLU/*throw to this address*/;
2796928017 stack[base + 14LLU] = base;
27970- stack[base + 15LLU] = 2297LLU;
28018+ stack[base + 15LLU] = 2301LLU;
2797128019 // arguments for call to ParseToken
2797228020 stack[base + 18LLU] = stack[base + 6]/*lookahead*/;
2797328021 // set stack-base & callee-address
@@ -27975,15 +28023,15 @@
2797528023 label = 3LLU; // ParseToken
2797628024 break;
2797728025 }
27978- case 2296LLU: // copy-back deleter (ParseToken to initfrom)
28026+ case 2300LLU: // copy-back deleter (ParseToken to initfrom)
2797928027 {
2798028028 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2798128029 // copy mutable arguments back from call to ParseToken
2798228030 stack[base + 6]/*lookahead*/ = stack[base + 18LLU];
27983- label = 2259LLU; // continue to roll stack
28031+ label = 2263LLU; // continue to roll stack
2798428032 break;
2798528033 }
27986- case 2297LLU: // return from ParseToken to initfrom
28034+ case 2301LLU: // return from ParseToken to initfrom
2798728035 {
2798828036 // copy mutable arguments back from call to ParseToken
2798928037 stack[base + 6]/*lookahead*/ = stack[base + 18LLU];
@@ -27991,9 +28039,9 @@
2799128039 stack[base + 10] = stack[base + 16LLU];
2799228040 stack[base + 11] = stack[base + 17LLU];
2799328041 // call issimple from initfrom
27994- stack[base + 14LLU] = 2298LLU/*throw to this address*/;
28042+ stack[base + 14LLU] = 2302LLU/*throw to this address*/;
2799528043 stack[base + 15LLU] = base;
27996- stack[base + 16LLU] = 2299LLU;
28044+ stack[base + 16LLU] = 2303LLU;
2799728045 // arguments for call to issimple
2799828046 stack[base + 18LLU] = stack[base + 10]/*variant*/;
2799928047 stack[base + 19LLU] = stack[base + 11]/*content*/;
@@ -28003,14 +28051,14 @@
2800328051 label = 158LLU; // issimple
2800428052 break;
2800528053 }
28006- case 2298LLU: // copy-back deleter (issimple to initfrom)
28054+ case 2302LLU: // copy-back deleter (issimple to initfrom)
2800728055 {
2800828056 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
2800928057 // copy mutable arguments back from call to issimple
28010- label = 2259LLU; // continue to roll stack
28058+ label = 2263LLU; // continue to roll stack
2801128059 break;
2801228060 }
28013- case 2299LLU: // return from issimple to initfrom
28061+ case 2303LLU: // return from issimple to initfrom
2801428062 {
2801528063 // copy mutable arguments back from call to issimple
2801628064 // copy back results provided by call to issimple
@@ -28017,7 +28065,7 @@
2801728065 stack[base + 13] = stack[base + 17LLU];
2801828066 if(!stack[base + 13]/*forceerror*/)
2801928067 {
28020- label = 2300LLU; // jump to alternative
28068+ label = 2304LLU; // jump to alternative
2802128069 break;
2802228070 }
2802328071
@@ -28024,9 +28072,9 @@
2802428072 // consequent
2802528073 fprintf(stderr, "%s", "in function ");
2802628074 // call reportid from initfrom
28027- stack[base + 14LLU] = 2302LLU/*throw to this address*/;
28075+ stack[base + 14LLU] = 2306LLU/*throw to this address*/;
2802828076 stack[base + 15LLU] = base;
28029- stack[base + 16LLU] = 2303LLU;
28077+ stack[base + 16LLU] = 2307LLU;
2803028078 // arguments for call to reportid
2803128079 stack[base + 17LLU] = stack[base + 0]/*fnid*/;
2803228080 // set stack-base & callee-address
@@ -28034,21 +28082,21 @@
2803428082 label = 18446744073709551586LLU; // reportid
2803528083 break;
2803628084 }
28037- case 2302LLU: // copy-back deleter (reportid to initfrom)
28085+ case 2306LLU: // copy-back deleter (reportid to initfrom)
2803828086 {
2803928087 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2804028088 // copy mutable arguments back from call to reportid
28041- label = 2259LLU; // continue to roll stack
28089+ label = 2263LLU; // continue to roll stack
2804228090 break;
2804328091 }
28044- case 2303LLU: // return from reportid to initfrom
28092+ case 2307LLU: // return from reportid to initfrom
2804528093 {
2804628094 // copy mutable arguments back from call to reportid
2804728095 fprintf(stderr, "%s", ": WARNING, FORCING CONSTRUCTION TO FAIL TO TEST THROW MECHANISM!\n");
2804828096 // call ParseToken from initfrom
28049- stack[base + 14LLU] = 2304LLU/*throw to this address*/;
28097+ stack[base + 14LLU] = 2308LLU/*throw to this address*/;
2805028098 stack[base + 15LLU] = base;
28051- stack[base + 16LLU] = 2305LLU;
28099+ stack[base + 16LLU] = 2309LLU;
2805228100 // arguments for call to ParseToken
2805328101 stack[base + 19LLU] = stack[base + 6]/*lookahead*/;
2805428102 // set stack-base & callee-address
@@ -28056,15 +28104,15 @@
2805628104 label = 3LLU; // ParseToken
2805728105 break;
2805828106 }
28059- case 2304LLU: // copy-back deleter (ParseToken to initfrom)
28107+ case 2308LLU: // copy-back deleter (ParseToken to initfrom)
2806028108 {
2806128109 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2806228110 // copy mutable arguments back from call to ParseToken
2806328111 stack[base + 6]/*lookahead*/ = stack[base + 19LLU];
28064- label = 2259LLU; // continue to roll stack
28112+ label = 2263LLU; // continue to roll stack
2806528113 break;
2806628114 }
28067- case 2305LLU: // return from ParseToken to initfrom
28115+ case 2309LLU: // return from ParseToken to initfrom
2806828116 {
2806928117 // copy mutable arguments back from call to ParseToken
2807028118 stack[base + 6]/*lookahead*/ = stack[base + 19LLU];
@@ -28071,20 +28119,20 @@
2807128119 // copy back results provided by call to ParseToken
2807228120 stack[base + 10] = stack[base + 17LLU];
2807328121 stack[base + 11] = stack[base + 18LLU];
28074- label = 2301LLU; // consequent complete
28122+ label = 2305LLU; // consequent complete
2807528123 break;
2807628124 }
28077- case 2300LLU: // alternative
28125+ case 2304LLU: // alternative
2807828126 {
28079- label = 2301LLU; // alternative complete
28127+ label = 2305LLU; // alternative complete
2808028128 break;
2808128129 }
28082- case 2301LLU: // completed if-then-else
28130+ case 2305LLU: // completed if-then-else
2808328131 {
2808428132 // call equ from initfrom
28085- stack[base + 14LLU] = 2306LLU/*throw to this address*/;
28133+ stack[base + 14LLU] = 2310LLU/*throw to this address*/;
2808628134 stack[base + 15LLU] = base;
28087- stack[base + 16LLU] = 2307LLU;
28135+ stack[base + 16LLU] = 2311LLU;
2808828136 // arguments for call to equ
2808928137 stack[base + 18LLU] = stack[base + 10]/*variant*/;
2809028138 stack[base + 19LLU] = 4LLU;
@@ -28093,14 +28141,14 @@
2809328141 label = 18446744073709551600LLU; // equ
2809428142 break;
2809528143 }
28096- case 2306LLU: // copy-back deleter (equ to initfrom)
28144+ case 2310LLU: // copy-back deleter (equ to initfrom)
2809728145 {
2809828146 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2809928147 // copy mutable arguments back from call to equ
28100- label = 2259LLU; // continue to roll stack
28148+ label = 2263LLU; // continue to roll stack
2810128149 break;
2810228150 }
28103- case 2307LLU: // return from equ to initfrom
28151+ case 2311LLU: // return from equ to initfrom
2810428152 {
2810528153 // copy mutable arguments back from call to equ
2810628154 // copy back results provided by call to equ
@@ -28107,15 +28155,15 @@
2810728155 stack[base + 9] = stack[base + 17LLU];
2810828156 if(!stack[base + 9]/*isequal*/)
2810928157 {
28110- label = 2308LLU; // jump to alternative
28158+ label = 2312LLU; // jump to alternative
2811128159 break;
2811228160 }
2811328161
2811428162 // consequent
2811528163 // call skipwscmnt from initfrom
28116- stack[base + 14LLU] = 2310LLU/*throw to this address*/;
28164+ stack[base + 14LLU] = 2314LLU/*throw to this address*/;
2811728165 stack[base + 15LLU] = base;
28118- stack[base + 16LLU] = 2311LLU;
28166+ stack[base + 16LLU] = 2315LLU;
2811928167 // arguments for call to skipwscmnt
2812028168 stack[base + 18LLU] = stack[base + 6]/*lookahead*/;
2812128169 // set stack-base & callee-address
@@ -28123,22 +28171,22 @@
2812328171 label = 18446744073709551580LLU; // skipwscmnt
2812428172 break;
2812528173 }
28126- case 2310LLU: // copy-back deleter (skipwscmnt to initfrom)
28174+ case 2314LLU: // copy-back deleter (skipwscmnt to initfrom)
2812728175 {
2812828176 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (skipwscmnt to initfrom)\n");
2812928177 // copy mutable arguments back from call to skipwscmnt
28130- label = 2259LLU; // continue to roll stack
28178+ label = 2263LLU; // continue to roll stack
2813128179 break;
2813228180 }
28133- case 2311LLU: // return from skipwscmnt to initfrom
28181+ case 2315LLU: // return from skipwscmnt to initfrom
2813428182 {
2813528183 // copy mutable arguments back from call to skipwscmnt
2813628184 // copy back results provided by call to skipwscmnt
2813728185 stack[base + 6] = stack[base + 17LLU];
2813828186 // call equ from initfrom
28139- stack[base + 15LLU] = 2312LLU/*throw to this address*/;
28187+ stack[base + 15LLU] = 2316LLU/*throw to this address*/;
2814028188 stack[base + 16LLU] = base;
28141- stack[base + 17LLU] = 2313LLU;
28189+ stack[base + 17LLU] = 2317LLU;
2814228190 // arguments for call to equ
2814328191 stack[base + 19LLU] = stack[base + 6]/*lookahead*/;
2814428192 stack[base + 20LLU] = 46LLU;
@@ -28147,14 +28195,14 @@
2814728195 label = 18446744073709551600LLU; // equ
2814828196 break;
2814928197 }
28150- case 2312LLU: // copy-back deleter (equ to initfrom)
28198+ case 2316LLU: // copy-back deleter (equ to initfrom)
2815128199 {
2815228200 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2815328201 // copy mutable arguments back from call to equ
28154- label = 2259LLU; // continue to roll stack
28202+ label = 2263LLU; // continue to roll stack
2815528203 break;
2815628204 }
28157- case 2313LLU: // return from equ to initfrom
28205+ case 2317LLU: // return from equ to initfrom
2815828206 {
2815928207 // copy mutable arguments back from call to equ
2816028208 // copy back results provided by call to equ
@@ -28161,40 +28209,40 @@
2816128209 stack[base + 14] = stack[base + 18LLU];
2816228210 if(!stack[base + 14]/*namespace*/)
2816328211 {
28164- label = 2314LLU; // jump to alternative
28212+ label = 2318LLU; // jump to alternative
2816528213 break;
2816628214 }
2816728215
2816828216 // consequent
28169- label = 2317LLU; // skip deleter
28217+ label = 2321LLU; // skip deleter
2817028218 break;
2817128219 }
28172- case 2316LLU: // deleter
28220+ case 2320LLU: // deleter
2817328221 {
2817428222 // throw from initfrom
2817528223 if(!stack[base + 15])
2817628224 {
2817728225 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28178- label = 2259LLU; // skip, variable already deleted/unscoped
28226+ label = 2263LLU; // skip, variable already deleted/unscoped
2817928227 break;
2818028228 }
2818128229 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28182- label = 2259LLU; // continue unrolling stack, delete next variable
28230+ label = 2263LLU; // continue unrolling stack, delete next variable
2818328231 break;
2818428232 }
28185- case 2317LLU: // skipped deleter
28233+ case 2321LLU: // skipped deleter
2818628234 {
2818728235 stack[base + 15] = stack[base + 11]/*content*/;
28188- label = 2319LLU; // skip deleter
28236+ label = 2323LLU; // skip deleter
2818928237 break;
2819028238 }
28191- case 2318LLU: // deleter
28239+ case 2322LLU: // deleter
2819228240 {
2819328241 // throw from initfrom
2819428242 if(!stack[base + 16])
2819528243 {
2819628244 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type \n");
28197- label = 2316LLU; // skip, variable already deleted/unscoped
28245+ label = 2320LLU; // skip, variable already deleted/unscoped
2819828246 break;
2819928247 }
2820028248 fprintf(stderr, "in function initfrom: unrolling stack, variable type \n");
@@ -28204,7 +28252,7 @@
2820428252 newstack[0] = (uint64_t)stack; // backup stack location
2820528253 newstack[1] = 1234567890;
2820628254 newstack[2] = base;
28207- newstack[3] = 2320LLU;
28255+ newstack[3] = 2324LLU;
2820828256 stack = newstack;
2820928257 // set stack-base & callee-address
2821028258 base = 4/*deloffset*/;
@@ -28211,21 +28259,21 @@
2821128259 label = 296LLU; // ~type
2821228260 break;
2821328261 }
28214- case 2320LLU: // return from ~type to initfrom
28262+ case 2324LLU: // return from ~type to initfrom
2821528263 {
2821628264 stack = (uint64_t *)stack[0];
2821728265 // releasing toplevel container
2821828266 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
2821928267
28220- label = 2316LLU; // continue unrolling stack, delete next variable
28268+ label = 2320LLU; // continue unrolling stack, delete next variable
2822128269 break;
2822228270 }
28223- case 2319LLU: // skipped deleter
28271+ case 2323LLU: // skipped deleter
2822428272 {
2822528273 // construct type.typename
2822628274 if(!(stack[base + 16] = construct(1)))
2822728275 {
28228- label = 2316LLU; // throw: begin to unroll stack
28276+ label = 2320LLU; // throw: begin to unroll stack
2822928277 break;
2823028278 }
2823128279
@@ -28235,7 +28283,7 @@
2823528283 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2823628284 if(!newstack)
2823728285 {
28238- label = 2318LLU; // throw: begin to unroll stack
28286+ label = 2322LLU; // throw: begin to unroll stack
2823928287 break;
2824028288 }
2824128289
@@ -28242,9 +28290,9 @@
2824228290 newstack[15LLU] = 9876543210LLU; // overflow-marker
2824328291 // call equtype from initfrom
2824428292 newstack[0] = (uint64_t)stack; // backup stack location
28245- newstack[1] = 2321LLU;
28293+ newstack[1] = 2325LLU;
2824628294 newstack[2] = base;
28247- newstack[3] = 2322LLU;
28295+ newstack[3] = 2326LLU;
2824828296 // arguments for call to equtype
2824928297 newstack[5LLU] = stack[base + 1]/*dsttype*/;
2825028298 newstack[6LLU] = stack[base + 16]/*assigntype*/;
@@ -28254,7 +28302,7 @@
2825428302 label = 342LLU; // equtype
2825528303 break;
2825628304 }
28257- case 2321LLU: // copy-back deleter (equtype to initfrom)
28305+ case 2325LLU: // copy-back deleter (equtype to initfrom)
2825828306 {
2825928307 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2826028308 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28266,10 +28314,10 @@
2826628314 }
2826728315 Free(15LLU + 1, sizeof(uint64_t), stack);
2826828316 stack = oldstack;
28269- label = 2318LLU; // continue to unroll stack
28317+ label = 2322LLU; // continue to unroll stack
2827028318 break;
2827128319 }
28272- case 2322LLU: // return from equtype to initfrom
28320+ case 2326LLU: // return from equtype to initfrom
2827328321 {
2827428322 uint64_t *oldstack = (uint64_t *)stack[0];
2827528323 // copy mutable arguments back from call to equtype
@@ -28284,21 +28332,21 @@
2828428332 stack = oldstack;
2828528333 if(!stack[base + 9]/*isequal*/)
2828628334 {
28287- label = 2323LLU; // jump to alternative
28335+ label = 2327LLU; // jump to alternative
2828828336 break;
2828928337 }
2829028338
2829128339 // consequent
28292- label = 2324LLU; // consequent complete
28340+ label = 2328LLU; // consequent complete
2829328341 break;
2829428342 }
28295- case 2323LLU: // alternative
28343+ case 2327LLU: // alternative
2829628344 {
2829728345 fprintf(stderr, "%s", "in function ");
2829828346 // call reportid from initfrom
28299- stack[base + 17LLU] = 2325LLU/*throw to this address*/;
28347+ stack[base + 17LLU] = 2329LLU/*throw to this address*/;
2830028348 stack[base + 18LLU] = base;
28301- stack[base + 19LLU] = 2326LLU;
28349+ stack[base + 19LLU] = 2330LLU;
2830228350 // arguments for call to reportid
2830328351 stack[base + 20LLU] = stack[base + 0]/*fnid*/;
2830428352 // set stack-base & callee-address
@@ -28306,14 +28354,14 @@
2830628354 label = 18446744073709551586LLU; // reportid
2830728355 break;
2830828356 }
28309- case 2325LLU: // copy-back deleter (reportid to initfrom)
28357+ case 2329LLU: // copy-back deleter (reportid to initfrom)
2831028358 {
2831128359 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2831228360 // copy mutable arguments back from call to reportid
28313- label = 2318LLU; // continue to roll stack
28361+ label = 2322LLU; // continue to roll stack
2831428362 break;
2831528363 }
28316- case 2326LLU: // return from reportid to initfrom
28364+ case 2330LLU: // return from reportid to initfrom
2831728365 {
2831828366 // copy mutable arguments back from call to reportid
2831928367 fprintf(stderr, "%s", ": can't construct type ");
@@ -28320,7 +28368,7 @@
2832028368 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2832128369 if(!newstack)
2832228370 {
28323- label = 2318LLU; // throw: begin to unroll stack
28371+ label = 2322LLU; // throw: begin to unroll stack
2832428372 break;
2832528373 }
2832628374
@@ -28327,9 +28375,9 @@
2832728375 newstack[10LLU] = 9876543210LLU; // overflow-marker
2832828376 // call reporttype from initfrom
2832928377 newstack[0] = (uint64_t)stack; // backup stack location
28330- newstack[1] = 2327LLU;
28378+ newstack[1] = 2331LLU;
2833128379 newstack[2] = base;
28332- newstack[3] = 2328LLU;
28380+ newstack[3] = 2332LLU;
2833328381 // arguments for call to reporttype
2833428382 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2833528383 stack = newstack;
@@ -28338,7 +28386,7 @@
2833828386 label = 316LLU; // reporttype
2833928387 break;
2834028388 }
28341- case 2327LLU: // copy-back deleter (reporttype to initfrom)
28389+ case 2331LLU: // copy-back deleter (reporttype to initfrom)
2834228390 {
2834328391 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2834428392 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28350,10 +28398,10 @@
2835028398 }
2835128399 Free(10LLU + 1, sizeof(uint64_t), stack);
2835228400 stack = oldstack;
28353- label = 2318LLU; // continue to unroll stack
28401+ label = 2322LLU; // continue to unroll stack
2835428402 break;
2835528403 }
28356- case 2328LLU: // return from reporttype to initfrom
28404+ case 2332LLU: // return from reporttype to initfrom
2835728405 {
2835828406 uint64_t *oldstack = (uint64_t *)stack[0];
2835928407 // copy mutable arguments back from call to reporttype
@@ -28368,7 +28416,7 @@
2836828416 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2836928417 if(!newstack)
2837028418 {
28371- label = 2318LLU; // throw: begin to unroll stack
28419+ label = 2322LLU; // throw: begin to unroll stack
2837228420 break;
2837328421 }
2837428422
@@ -28375,9 +28423,9 @@
2837528423 newstack[10LLU] = 9876543210LLU; // overflow-marker
2837628424 // call reporttype from initfrom
2837728425 newstack[0] = (uint64_t)stack; // backup stack location
28378- newstack[1] = 2329LLU;
28426+ newstack[1] = 2333LLU;
2837928427 newstack[2] = base;
28380- newstack[3] = 2330LLU;
28428+ newstack[3] = 2334LLU;
2838128429 // arguments for call to reporttype
2838228430 newstack[4LLU] = stack[base + 16]/*assigntype*/;
2838328431 stack = newstack;
@@ -28386,7 +28434,7 @@
2838628434 label = 316LLU; // reporttype
2838728435 break;
2838828436 }
28389- case 2329LLU: // copy-back deleter (reporttype to initfrom)
28437+ case 2333LLU: // copy-back deleter (reporttype to initfrom)
2839028438 {
2839128439 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2839228440 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28398,10 +28446,10 @@
2839828446 }
2839928447 Free(10LLU + 1, sizeof(uint64_t), stack);
2840028448 stack = oldstack;
28401- label = 2318LLU; // continue to unroll stack
28449+ label = 2322LLU; // continue to unroll stack
2840228450 break;
2840328451 }
28404- case 2330LLU: // return from reporttype to initfrom
28452+ case 2334LLU: // return from reporttype to initfrom
2840528453 {
2840628454 uint64_t *oldstack = (uint64_t *)stack[0];
2840728455 // copy mutable arguments back from call to reporttype
@@ -28414,10 +28462,10 @@
2841428462 stack = oldstack;
2841528463 fprintf(stderr, "%s", "\n");
2841628464 exit(-1);
28417- label = 2324LLU; // alternative complete
28465+ label = 2328LLU; // alternative complete
2841828466 break;
2841928467 }
28420- case 2324LLU: // completed if-then-else
28468+ case 2328LLU: // completed if-then-else
2842128469 {
2842228470
2842328471 uint64_t *newstack = (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4);
@@ -28425,7 +28473,7 @@
2842528473 newstack[0] = (uint64_t)stack; // backup stack location
2842628474 newstack[1] = 1234567890;
2842728475 newstack[2] = base;
28428- newstack[3] = 2331LLU;
28476+ newstack[3] = 2335LLU;
2842928477 stack = newstack;
2843028478 // set stack-base & callee-address
2843128479 base = 4/*deloffset*/;
@@ -28432,7 +28480,7 @@
2843228480 label = 296LLU; // ~type
2843328481 break;
2843428482 }
28435- case 2331LLU: // return from ~type to initfrom
28483+ case 2335LLU: // return from ~type to initfrom
2843628484 {
2843728485 stack = (uint64_t *)stack[0];
2843828486 // releasing toplevel container
@@ -28439,9 +28487,9 @@
2843928487 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
2844028488
2844128489 // call matchsym from initfrom
28442- stack[base + 16LLU] = 2332LLU/*throw to this address*/;
28490+ stack[base + 16LLU] = 2336LLU/*throw to this address*/;
2844328491 stack[base + 17LLU] = base;
28444- stack[base + 18LLU] = 2333LLU;
28492+ stack[base + 18LLU] = 2337LLU;
2844528493 // arguments for call to matchsym
2844628494 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
2844728495 stack[base + 20LLU] = 46LLU;
@@ -28451,22 +28499,22 @@
2845128499 label = 212LLU; // matchsym
2845228500 break;
2845328501 }
28454- case 2332LLU: // copy-back deleter (matchsym to initfrom)
28502+ case 2336LLU: // copy-back deleter (matchsym to initfrom)
2845528503 {
2845628504 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2845728505 // copy mutable arguments back from call to matchsym
2845828506 stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28459- label = 2316LLU; // continue to roll stack
28507+ label = 2320LLU; // continue to roll stack
2846028508 break;
2846128509 }
28462- case 2333LLU: // return from matchsym to initfrom
28510+ case 2337LLU: // return from matchsym to initfrom
2846328511 {
2846428512 // copy mutable arguments back from call to matchsym
2846528513 stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
2846628514 // call ParseToken from initfrom
28467- stack[base + 16LLU] = 2334LLU/*throw to this address*/;
28515+ stack[base + 16LLU] = 2338LLU/*throw to this address*/;
2846828516 stack[base + 17LLU] = base;
28469- stack[base + 18LLU] = 2335LLU;
28517+ stack[base + 18LLU] = 2339LLU;
2847028518 // arguments for call to ParseToken
2847128519 stack[base + 21LLU] = stack[base + 6]/*lookahead*/;
2847228520 // set stack-base & callee-address
@@ -28474,15 +28522,15 @@
2847428522 label = 3LLU; // ParseToken
2847528523 break;
2847628524 }
28477- case 2334LLU: // copy-back deleter (ParseToken to initfrom)
28525+ case 2338LLU: // copy-back deleter (ParseToken to initfrom)
2847828526 {
2847928527 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2848028528 // copy mutable arguments back from call to ParseToken
2848128529 stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28482- label = 2316LLU; // continue to roll stack
28530+ label = 2320LLU; // continue to roll stack
2848328531 break;
2848428532 }
28485- case 2335LLU: // return from ParseToken to initfrom
28533+ case 2339LLU: // return from ParseToken to initfrom
2848628534 {
2848728535 // copy mutable arguments back from call to ParseToken
2848828536 stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
@@ -28490,9 +28538,9 @@
2849028538 stack[base + 10] = stack[base + 19LLU];
2849128539 stack[base + 11] = stack[base + 20LLU];
2849228540 // call equ from initfrom
28493- stack[base + 16LLU] = 2336LLU/*throw to this address*/;
28541+ stack[base + 16LLU] = 2340LLU/*throw to this address*/;
2849428542 stack[base + 17LLU] = base;
28495- stack[base + 18LLU] = 2337LLU;
28543+ stack[base + 18LLU] = 2341LLU;
2849628544 // arguments for call to equ
2849728545 stack[base + 20LLU] = stack[base + 10]/*variant*/;
2849828546 stack[base + 21LLU] = 4LLU;
@@ -28501,14 +28549,14 @@
2850128549 label = 18446744073709551600LLU; // equ
2850228550 break;
2850328551 }
28504- case 2336LLU: // copy-back deleter (equ to initfrom)
28552+ case 2340LLU: // copy-back deleter (equ to initfrom)
2850528553 {
2850628554 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2850728555 // copy mutable arguments back from call to equ
28508- label = 2316LLU; // continue to roll stack
28556+ label = 2320LLU; // continue to roll stack
2850928557 break;
2851028558 }
28511- case 2337LLU: // return from equ to initfrom
28559+ case 2341LLU: // return from equ to initfrom
2851228560 {
2851328561 // copy mutable arguments back from call to equ
2851428562 // copy back results provided by call to equ
@@ -28515,21 +28563,21 @@
2851528563 stack[base + 9] = stack[base + 19LLU];
2851628564 if(!stack[base + 9]/*isequal*/)
2851728565 {
28518- label = 2338LLU; // jump to alternative
28566+ label = 2342LLU; // jump to alternative
2851928567 break;
2852028568 }
2852128569
2852228570 // consequent
28523- label = 2339LLU; // consequent complete
28571+ label = 2343LLU; // consequent complete
2852428572 break;
2852528573 }
28526- case 2338LLU: // alternative
28574+ case 2342LLU: // alternative
2852728575 {
2852828576 fprintf(stderr, "%s", "construct requires constructor but found ");
2852928577 // call reporttok from initfrom
28530- stack[base + 16LLU] = 2340LLU/*throw to this address*/;
28578+ stack[base + 16LLU] = 2344LLU/*throw to this address*/;
2853128579 stack[base + 17LLU] = base;
28532- stack[base + 18LLU] = 2341LLU;
28580+ stack[base + 18LLU] = 2345LLU;
2853328581 // arguments for call to reporttok
2853428582 stack[base + 19LLU] = stack[base + 10]/*variant*/;
2853528583 stack[base + 20LLU] = stack[base + 11]/*content*/;
@@ -28538,40 +28586,40 @@
2853828586 label = 18446744073709551582LLU; // reporttok
2853928587 break;
2854028588 }
28541- case 2340LLU: // copy-back deleter (reporttok to initfrom)
28589+ case 2344LLU: // copy-back deleter (reporttok to initfrom)
2854228590 {
2854328591 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2854428592 // copy mutable arguments back from call to reporttok
28545- label = 2316LLU; // continue to roll stack
28593+ label = 2320LLU; // continue to roll stack
2854628594 break;
2854728595 }
28548- case 2341LLU: // return from reporttok to initfrom
28596+ case 2345LLU: // return from reporttok to initfrom
2854928597 {
2855028598 // copy mutable arguments back from call to reporttok
2855128599 fprintf(stderr, "%s", "\n");
2855228600 exit(-1);
28553- label = 2339LLU; // alternative complete
28601+ label = 2343LLU; // alternative complete
2855428602 break;
2855528603 }
28556- case 2339LLU: // completed if-then-else
28604+ case 2343LLU: // completed if-then-else
2855728605 {
2855828606 if(!stack[base + 8]/*fncanthrow*/)
2855928607 {
28560- label = 2342LLU; // jump to alternative
28608+ label = 2346LLU; // jump to alternative
2856128609 break;
2856228610 }
2856328611
2856428612 // consequent
28565- label = 2343LLU; // consequent complete
28613+ label = 2347LLU; // consequent complete
2856628614 break;
2856728615 }
28568- case 2342LLU: // alternative
28616+ case 2346LLU: // alternative
2856928617 {
2857028618 fprintf(stderr, "%s", "in function ");
2857128619 // call reportid from initfrom
28572- stack[base + 16LLU] = 2344LLU/*throw to this address*/;
28620+ stack[base + 16LLU] = 2348LLU/*throw to this address*/;
2857328621 stack[base + 17LLU] = base;
28574- stack[base + 18LLU] = 2345LLU;
28622+ stack[base + 18LLU] = 2349LLU;
2857528623 // arguments for call to reportid
2857628624 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
2857728625 // set stack-base & callee-address
@@ -28579,21 +28627,21 @@
2857928627 label = 18446744073709551586LLU; // reportid
2858028628 break;
2858128629 }
28582- case 2344LLU: // copy-back deleter (reportid to initfrom)
28630+ case 2348LLU: // copy-back deleter (reportid to initfrom)
2858328631 {
2858428632 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2858528633 // copy mutable arguments back from call to reportid
28586- label = 2316LLU; // continue to roll stack
28634+ label = 2320LLU; // continue to roll stack
2858728635 break;
2858828636 }
28589- case 2345LLU: // return from reportid to initfrom
28637+ case 2349LLU: // return from reportid to initfrom
2859028638 {
2859128639 // copy mutable arguments back from call to reportid
2859228640 fprintf(stderr, "%s", ": construction of data ");
2859328641 // call reportid from initfrom
28594- stack[base + 16LLU] = 2346LLU/*throw to this address*/;
28642+ stack[base + 16LLU] = 2350LLU/*throw to this address*/;
2859528643 stack[base + 17LLU] = base;
28596- stack[base + 18LLU] = 2347LLU;
28644+ stack[base + 18LLU] = 2351LLU;
2859728645 // arguments for call to reportid
2859828646 stack[base + 19LLU] = stack[base + 15]/*typename*/;
2859928647 // set stack-base & callee-address
@@ -28601,28 +28649,28 @@
2860128649 label = 18446744073709551586LLU; // reportid
2860228650 break;
2860328651 }
28604- case 2346LLU: // copy-back deleter (reportid to initfrom)
28652+ case 2350LLU: // copy-back deleter (reportid to initfrom)
2860528653 {
2860628654 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2860728655 // copy mutable arguments back from call to reportid
28608- label = 2316LLU; // continue to roll stack
28656+ label = 2320LLU; // continue to roll stack
2860928657 break;
2861028658 }
28611- case 2347LLU: // return from reportid to initfrom
28659+ case 2351LLU: // return from reportid to initfrom
2861228660 {
2861328661 // copy mutable arguments back from call to reportid
2861428662 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2861528663 exit(-1);
28616- label = 2343LLU; // alternative complete
28664+ label = 2347LLU; // alternative complete
2861728665 break;
2861828666 }
28619- case 2343LLU: // completed if-then-else
28667+ case 2347LLU: // completed if-then-else
2862028668 {
2862128669 printf("%s", "\n // construct ");
2862228670 // call printid from initfrom
28623- stack[base + 16LLU] = 2348LLU/*throw to this address*/;
28671+ stack[base + 16LLU] = 2352LLU/*throw to this address*/;
2862428672 stack[base + 17LLU] = base;
28625- stack[base + 18LLU] = 2349LLU;
28673+ stack[base + 18LLU] = 2353LLU;
2862628674 // arguments for call to printid
2862728675 stack[base + 19LLU] = stack[base + 15]/*typename*/;
2862828676 // set stack-base & callee-address
@@ -28630,21 +28678,21 @@
2863028678 label = 18446744073709551587LLU; // printid
2863128679 break;
2863228680 }
28633- case 2348LLU: // copy-back deleter (printid to initfrom)
28681+ case 2352LLU: // copy-back deleter (printid to initfrom)
2863428682 {
2863528683 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2863628684 // copy mutable arguments back from call to printid
28637- label = 2316LLU; // continue to roll stack
28685+ label = 2320LLU; // continue to roll stack
2863828686 break;
2863928687 }
28640- case 2349LLU: // return from printid to initfrom
28688+ case 2353LLU: // return from printid to initfrom
2864128689 {
2864228690 // copy mutable arguments back from call to printid
2864328691 printf("%s", ".");
2864428692 // call printid from initfrom
28645- stack[base + 16LLU] = 2350LLU/*throw to this address*/;
28693+ stack[base + 16LLU] = 2354LLU/*throw to this address*/;
2864628694 stack[base + 17LLU] = base;
28647- stack[base + 18LLU] = 2351LLU;
28695+ stack[base + 18LLU] = 2355LLU;
2864828696 // arguments for call to printid
2864928697 stack[base + 19LLU] = stack[base + 11]/*content*/;
2865028698 // set stack-base & callee-address
@@ -28652,20 +28700,20 @@
2865228700 label = 18446744073709551587LLU; // printid
2865328701 break;
2865428702 }
28655- case 2350LLU: // copy-back deleter (printid to initfrom)
28703+ case 2354LLU: // copy-back deleter (printid to initfrom)
2865628704 {
2865728705 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2865828706 // copy mutable arguments back from call to printid
28659- label = 2316LLU; // continue to roll stack
28707+ label = 2320LLU; // continue to roll stack
2866028708 break;
2866128709 }
28662- case 2351LLU: // return from printid to initfrom
28710+ case 2355LLU: // return from printid to initfrom
2866328711 {
2866428712 // copy mutable arguments back from call to printid
2866528713 // call FindData from initfrom
28666- stack[base + 17LLU] = 2352LLU/*throw to this address*/;
28714+ stack[base + 17LLU] = 2356LLU/*throw to this address*/;
2866728715 stack[base + 18LLU] = base;
28668- stack[base + 19LLU] = 2353LLU;
28716+ stack[base + 19LLU] = 2357LLU;
2866928717 // arguments for call to FindData
2867028718 stack[base + 21LLU] = stack[base + 3]/*typedefs*/;
2867128719 stack[base + 22LLU] = stack[base + 15]/*typename*/;
@@ -28674,14 +28722,14 @@
2867428722 label = 1004LLU; // FindData
2867528723 break;
2867628724 }
28677- case 2352LLU: // copy-back deleter (FindData to initfrom)
28725+ case 2356LLU: // copy-back deleter (FindData to initfrom)
2867828726 {
2867928727 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
2868028728 // copy mutable arguments back from call to FindData
28681- label = 2316LLU; // continue to roll stack
28729+ label = 2320LLU; // continue to roll stack
2868228730 break;
2868328731 }
28684- case 2353LLU: // return from FindData to initfrom
28732+ case 2357LLU: // return from FindData to initfrom
2868528733 {
2868628734 // copy mutable arguments back from call to FindData
2868728735 // copy back results provided by call to FindData
@@ -28688,7 +28736,7 @@
2868828736 stack[base + 16] = stack[base + 20LLU];
2868928737 if(/*datadef*/0 != ((uint64_t *)(stack[base + 16]/*reftypedef*/))[0])
2869028738 {
28691- label = 2355LLU; // jump to alternative
28739+ label = 2359LLU; // jump to alternative
2869228740 break;
2869328741 }
2869428742
@@ -28698,9 +28746,9 @@
2869828746
2869928747 // case
2870028748 // call GetVariant from initfrom
28701- stack[base + 22LLU] = 2357LLU/*throw to this address*/;
28749+ stack[base + 22LLU] = 2361LLU/*throw to this address*/;
2870228750 stack[base + 23LLU] = base;
28703- stack[base + 24LLU] = 2358LLU;
28751+ stack[base + 24LLU] = 2362LLU;
2870428752 // arguments for call to GetVariant
2870528753 stack[base + 27LLU] = stack[base + 0]/*fnid*/;
2870628754 stack[base + 28LLU] = stack[base + 18]/*variants*/;
@@ -28710,14 +28758,14 @@
2871028758 label = 907LLU; // GetVariant
2871128759 break;
2871228760 }
28713- case 2357LLU: // copy-back deleter (GetVariant to initfrom)
28761+ case 2361LLU: // copy-back deleter (GetVariant to initfrom)
2871428762 {
2871528763 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
2871628764 // copy mutable arguments back from call to GetVariant
28717- label = 2356LLU; // continue to roll stack
28765+ label = 2360LLU; // continue to roll stack
2871828766 break;
2871928767 }
28720- case 2358LLU: // return from GetVariant to initfrom
28768+ case 2362LLU: // return from GetVariant to initfrom
2872128769 {
2872228770 // copy mutable arguments back from call to GetVariant
2872328771 // copy back results provided by call to GetVariant
@@ -28725,7 +28773,7 @@
2872528773 stack[base + 21] = stack[base + 26LLU];
2872628774 if(/*variant*/0 != ((uint64_t *)(stack[base + 21]/*constr*/))[0])
2872728775 {
28728- label = 2360LLU; // jump to alternative
28776+ label = 2364LLU; // jump to alternative
2872928777 break;
2873028778 }
2873128779
@@ -28733,29 +28781,29 @@
2873328781 /*TYPEIDS*/stack[base + 23] = ((uint64_t **)(stack[base + 21]/*constr*/))[1][1]/*elements*/;
2873428782
2873528783 // case
28736- label = 2363LLU; // skip deleter
28784+ label = 2367LLU; // skip deleter
2873728785 break;
2873828786 }
28739- case 2362LLU: // deleter
28787+ case 2366LLU: // deleter
2874028788 {
2874128789 // throw from initfrom
2874228790 if(!stack[base + 24])
2874328791 {
2874428792 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28745- label = 2361LLU; // skip, variable already deleted/unscoped
28793+ label = 2365LLU; // skip, variable already deleted/unscoped
2874628794 break;
2874728795 }
2874828796 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28749- label = 2361LLU; // continue unrolling stack, delete next variable
28797+ label = 2365LLU; // continue unrolling stack, delete next variable
2875028798 break;
2875128799 }
28752- case 2363LLU: // skipped deleter
28800+ case 2367LLU: // skipped deleter
2875328801 {
2875428802 stack[base + 24] = 0;
2875528803 stack[base + 24]/*size*/ = list_size(((struct listnode *)(stack[base + 23]/*TYPEIDS*/)));
2875628804 if(!stack[base + 13]/*forceerror*/)
2875728805 {
28758- label = 2364LLU; // jump to alternative
28806+ label = 2368LLU; // jump to alternative
2875928807 break;
2876028808 }
2876128809
@@ -28762,9 +28810,9 @@
2876228810 // consequent
2876328811 printf("%s", "\n // if(!(");
2876428812 // call emitvaridx from initfrom
28765- stack[base + 25LLU] = 2366LLU/*throw to this address*/;
28813+ stack[base + 25LLU] = 2370LLU/*throw to this address*/;
2876628814 stack[base + 26LLU] = base;
28767- stack[base + 27LLU] = 2367LLU;
28815+ stack[base + 27LLU] = 2371LLU;
2876828816 // arguments for call to emitvaridx
2876928817 stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
2877028818 // set stack-base & callee-address
@@ -28772,21 +28820,21 @@
2877228820 label = 691LLU; // emitvaridx
2877328821 break;
2877428822 }
28775- case 2366LLU: // copy-back deleter (emitvaridx to initfrom)
28823+ case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
2877628824 {
2877728825 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2877828826 // copy mutable arguments back from call to emitvaridx
28779- label = 2362LLU; // continue to roll stack
28827+ label = 2366LLU; // continue to roll stack
2878028828 break;
2878128829 }
28782- case 2367LLU: // return from emitvaridx to initfrom
28830+ case 2371LLU: // return from emitvaridx to initfrom
2878328831 {
2878428832 // copy mutable arguments back from call to emitvaridx
2878528833 printf("%s", " = construct(");
2878628834 // call printnr from initfrom
28787- stack[base + 25LLU] = 2368LLU/*throw to this address*/;
28835+ stack[base + 25LLU] = 2372LLU/*throw to this address*/;
2878828836 stack[base + 26LLU] = base;
28789- stack[base + 27LLU] = 2369LLU;
28837+ stack[base + 27LLU] = 2373LLU;
2879028838 // arguments for call to printnr
2879128839 stack[base + 28LLU] = stack[base + 24]/*size*/;
2879228840 // set stack-base & callee-address
@@ -28794,27 +28842,27 @@
2879428842 label = 18446744073709551590LLU; // printnr
2879528843 break;
2879628844 }
28797- case 2368LLU: // copy-back deleter (printnr to initfrom)
28845+ case 2372LLU: // copy-back deleter (printnr to initfrom)
2879828846 {
2879928847 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2880028848 // copy mutable arguments back from call to printnr
28801- label = 2362LLU; // continue to roll stack
28849+ label = 2366LLU; // continue to roll stack
2880228850 break;
2880328851 }
28804- case 2369LLU: // return from printnr to initfrom
28852+ case 2373LLU: // return from printnr to initfrom
2880528853 {
2880628854 // copy mutable arguments back from call to printnr
2880728855 printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
28808- label = 2365LLU; // consequent complete
28856+ label = 2369LLU; // consequent complete
2880928857 break;
2881028858 }
28811- case 2364LLU: // alternative
28859+ case 2368LLU: // alternative
2881228860 {
2881328861 printf("%s", "\n if(!(");
2881428862 // call emitvaridx from initfrom
28815- stack[base + 25LLU] = 2370LLU/*throw to this address*/;
28863+ stack[base + 25LLU] = 2374LLU/*throw to this address*/;
2881628864 stack[base + 26LLU] = base;
28817- stack[base + 27LLU] = 2371LLU;
28865+ stack[base + 27LLU] = 2375LLU;
2881828866 // arguments for call to emitvaridx
2881928867 stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
2882028868 // set stack-base & callee-address
@@ -28822,21 +28870,21 @@
2882228870 label = 691LLU; // emitvaridx
2882328871 break;
2882428872 }
28825- case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
28873+ case 2374LLU: // copy-back deleter (emitvaridx to initfrom)
2882628874 {
2882728875 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2882828876 // copy mutable arguments back from call to emitvaridx
28829- label = 2362LLU; // continue to roll stack
28877+ label = 2366LLU; // continue to roll stack
2883028878 break;
2883128879 }
28832- case 2371LLU: // return from emitvaridx to initfrom
28880+ case 2375LLU: // return from emitvaridx to initfrom
2883328881 {
2883428882 // copy mutable arguments back from call to emitvaridx
2883528883 printf("%s", " = construct(");
2883628884 // call printnr from initfrom
28837- stack[base + 25LLU] = 2372LLU/*throw to this address*/;
28885+ stack[base + 25LLU] = 2376LLU/*throw to this address*/;
2883828886 stack[base + 26LLU] = base;
28839- stack[base + 27LLU] = 2373LLU;
28887+ stack[base + 27LLU] = 2377LLU;
2884028888 // arguments for call to printnr
2884128889 stack[base + 28LLU] = stack[base + 24]/*size*/;
2884228890 // set stack-base & callee-address
@@ -28844,26 +28892,26 @@
2884428892 label = 18446744073709551590LLU; // printnr
2884528893 break;
2884628894 }
28847- case 2372LLU: // copy-back deleter (printnr to initfrom)
28895+ case 2376LLU: // copy-back deleter (printnr to initfrom)
2884828896 {
2884928897 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2885028898 // copy mutable arguments back from call to printnr
28851- label = 2362LLU; // continue to roll stack
28899+ label = 2366LLU; // continue to roll stack
2885228900 break;
2885328901 }
28854- case 2373LLU: // return from printnr to initfrom
28902+ case 2377LLU: // return from printnr to initfrom
2885528903 {
2885628904 // copy mutable arguments back from call to printnr
2885728905 printf("%s", ")))");
28858- label = 2365LLU; // alternative complete
28906+ label = 2369LLU; // alternative complete
2885928907 break;
2886028908 }
28861- case 2365LLU: // completed if-then-else
28909+ case 2369LLU: // completed if-then-else
2886228910 {
2886328911 // call emitthrow from initfrom
28864- stack[base + 25LLU] = 2374LLU/*throw to this address*/;
28912+ stack[base + 25LLU] = 2378LLU/*throw to this address*/;
2886528913 stack[base + 26LLU] = base;
28866- stack[base + 27LLU] = 2375LLU;
28914+ stack[base + 27LLU] = 2379LLU;
2886728915 // arguments for call to emitthrow
2886828916 stack[base + 28LLU] = stack[base + 5]/*scope*/;
2886928917 // set stack-base & callee-address
@@ -28871,22 +28919,22 @@
2887128919 label = 1559LLU; // emitthrow
2887228920 break;
2887328921 }
28874- case 2374LLU: // copy-back deleter (emitthrow to initfrom)
28922+ case 2378LLU: // copy-back deleter (emitthrow to initfrom)
2887528923 {
2887628924 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
2887728925 // copy mutable arguments back from call to emitthrow
28878- label = 2362LLU; // continue to roll stack
28926+ label = 2366LLU; // continue to roll stack
2887928927 break;
2888028928 }
28881- case 2375LLU: // return from emitthrow to initfrom
28929+ case 2379LLU: // return from emitthrow to initfrom
2888228930 {
2888328931 // copy mutable arguments back from call to emitthrow
2888428932 printf("%s", "\n // consequent");
2888528933 printf("%s", "\n ((uint64_t *)");
2888628934 // call emitvaridx from initfrom
28887- stack[base + 25LLU] = 2376LLU/*throw to this address*/;
28935+ stack[base + 25LLU] = 2380LLU/*throw to this address*/;
2888828936 stack[base + 26LLU] = base;
28889- stack[base + 27LLU] = 2377LLU;
28937+ stack[base + 27LLU] = 2381LLU;
2889028938 // arguments for call to emitvaridx
2889128939 stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
2889228940 // set stack-base & callee-address
@@ -28894,21 +28942,21 @@
2889428942 label = 691LLU; // emitvaridx
2889528943 break;
2889628944 }
28897- case 2376LLU: // copy-back deleter (emitvaridx to initfrom)
28945+ case 2380LLU: // copy-back deleter (emitvaridx to initfrom)
2889828946 {
2889928947 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2890028948 // copy mutable arguments back from call to emitvaridx
28901- label = 2362LLU; // continue to roll stack
28949+ label = 2366LLU; // continue to roll stack
2890228950 break;
2890328951 }
28904- case 2377LLU: // return from emitvaridx to initfrom
28952+ case 2381LLU: // return from emitvaridx to initfrom
2890528953 {
2890628954 // copy mutable arguments back from call to emitvaridx
2890728955 printf("%s", ")[0] = ");
2890828956 // call printnr from initfrom
28909- stack[base + 25LLU] = 2378LLU/*throw to this address*/;
28957+ stack[base + 25LLU] = 2382LLU/*throw to this address*/;
2891028958 stack[base + 26LLU] = base;
28911- stack[base + 27LLU] = 2379LLU;
28959+ stack[base + 27LLU] = 2383LLU;
2891228960 // arguments for call to printnr
2891328961 stack[base + 28LLU] = stack[base + 20]/*varnr*/;
2891428962 // set stack-base & callee-address
@@ -28916,21 +28964,21 @@
2891628964 label = 18446744073709551590LLU; // printnr
2891728965 break;
2891828966 }
28919- case 2378LLU: // copy-back deleter (printnr to initfrom)
28967+ case 2382LLU: // copy-back deleter (printnr to initfrom)
2892028968 {
2892128969 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2892228970 // copy mutable arguments back from call to printnr
28923- label = 2362LLU; // continue to roll stack
28971+ label = 2366LLU; // continue to roll stack
2892428972 break;
2892528973 }
28926- case 2379LLU: // return from printnr to initfrom
28974+ case 2383LLU: // return from printnr to initfrom
2892728975 {
2892828976 // copy mutable arguments back from call to printnr
2892928977 printf("%s", ";");
2893028978 // call matchsym from initfrom
28931- stack[base + 25LLU] = 2380LLU/*throw to this address*/;
28979+ stack[base + 25LLU] = 2384LLU/*throw to this address*/;
2893228980 stack[base + 26LLU] = base;
28933- stack[base + 27LLU] = 2381LLU;
28981+ stack[base + 27LLU] = 2385LLU;
2893428982 // arguments for call to matchsym
2893528983 stack[base + 28LLU] = stack[base + 0]/*fnid*/;
2893628984 stack[base + 29LLU] = 40LLU;
@@ -28940,46 +28988,46 @@
2894028988 label = 212LLU; // matchsym
2894128989 break;
2894228990 }
28943- case 2380LLU: // copy-back deleter (matchsym to initfrom)
28991+ case 2384LLU: // copy-back deleter (matchsym to initfrom)
2894428992 {
2894528993 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2894628994 // copy mutable arguments back from call to matchsym
2894728995 stack[base + 6]/*lookahead*/ = stack[base + 30LLU];
28948- label = 2362LLU; // continue to roll stack
28996+ label = 2366LLU; // continue to roll stack
2894928997 break;
2895028998 }
28951- case 2381LLU: // return from matchsym to initfrom
28999+ case 2385LLU: // return from matchsym to initfrom
2895229000 {
2895329001 // copy mutable arguments back from call to matchsym
2895429002 stack[base + 6]/*lookahead*/ = stack[base + 30LLU];
28955- label = 2383LLU; // skip deleter
29003+ label = 2387LLU; // skip deleter
2895629004 break;
2895729005 }
28958- case 2382LLU: // deleter
29006+ case 2386LLU: // deleter
2895929007 {
2896029008 // throw from initfrom
2896129009 if(!stack[base + 25])
2896229010 {
2896329011 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28964- label = 2362LLU; // skip, variable already deleted/unscoped
29012+ label = 2366LLU; // skip, variable already deleted/unscoped
2896529013 break;
2896629014 }
2896729015 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28968- label = 2362LLU; // continue unrolling stack, delete next variable
29016+ label = 2366LLU; // continue unrolling stack, delete next variable
2896929017 break;
2897029018 }
28971- case 2383LLU: // skipped deleter
29019+ case 2387LLU: // skipped deleter
2897229020 {
2897329021 stack[base + 25] = 0;
2897429022 flippedassign(stack[base + 23]/*TYPEIDS*/, &stack[base + 26]);
28975- label = 2384LLU; // start to repeat
29023+ label = 2388LLU; // start to repeat
2897629024 break;
2897729025 }
28978- case 2384LLU: // repeat from here
29026+ case 2388LLU: // repeat from here
2897929027 {
2898029028 if(!stack[base + 26])
2898129029 {
28982- label = 2385LLU; // break loop
29030+ label = 2389LLU; // break loop
2898329031 break;
2898429032 }
2898529033
@@ -28989,7 +29037,7 @@
2898929037 stack[base + 26] = (uint64_t)(((const struct listnode *)(stack[base + 26]))->next);
2899029038 if(/*typeid*/0 != ((uint64_t *)(stack[base + 27]/*typeid*/))[0])
2899129039 {
28992- label = 2388LLU; // jump to alternative
29040+ label = 2392LLU; // jump to alternative
2899329041 break;
2899429042 }
2899529043
@@ -28999,15 +29047,15 @@
2899929047 // case
2900029048 if(!stack[base + 25]/*elemindex*/)
2900129049 {
29002- label = 2390LLU; // jump to alternative
29050+ label = 2394LLU; // jump to alternative
2900329051 break;
2900429052 }
2900529053
2900629054 // consequent
2900729055 // call matchsym from initfrom
29008- stack[base + 31LLU] = 2392LLU/*throw to this address*/;
29056+ stack[base + 31LLU] = 2396LLU/*throw to this address*/;
2900929057 stack[base + 32LLU] = base;
29010- stack[base + 33LLU] = 2393LLU;
29058+ stack[base + 33LLU] = 2397LLU;
2901129059 // arguments for call to matchsym
2901229060 stack[base + 34LLU] = stack[base + 0]/*fnid*/;
2901329061 stack[base + 35LLU] = 44LLU;
@@ -29017,32 +29065,32 @@
2901729065 label = 212LLU; // matchsym
2901829066 break;
2901929067 }
29020- case 2392LLU: // copy-back deleter (matchsym to initfrom)
29068+ case 2396LLU: // copy-back deleter (matchsym to initfrom)
2902129069 {
2902229070 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2902329071 // copy mutable arguments back from call to matchsym
2902429072 stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29025- label = 2389LLU; // continue to roll stack
29073+ label = 2393LLU; // continue to roll stack
2902629074 break;
2902729075 }
29028- case 2393LLU: // return from matchsym to initfrom
29076+ case 2397LLU: // return from matchsym to initfrom
2902929077 {
2903029078 // copy mutable arguments back from call to matchsym
2903129079 stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29032- label = 2391LLU; // consequent complete
29080+ label = 2395LLU; // consequent complete
2903329081 break;
2903429082 }
29035- case 2390LLU: // alternative
29083+ case 2394LLU: // alternative
2903629084 {
29037- label = 2391LLU; // alternative complete
29085+ label = 2395LLU; // alternative complete
2903829086 break;
2903929087 }
29040- case 2391LLU: // completed if-then-else
29088+ case 2395LLU: // completed if-then-else
2904129089 {
2904229090 // call ParseToken from initfrom
29043- stack[base + 31LLU] = 2394LLU/*throw to this address*/;
29091+ stack[base + 31LLU] = 2398LLU/*throw to this address*/;
2904429092 stack[base + 32LLU] = base;
29045- stack[base + 33LLU] = 2395LLU;
29093+ stack[base + 33LLU] = 2399LLU;
2904629094 // arguments for call to ParseToken
2904729095 stack[base + 36LLU] = stack[base + 6]/*lookahead*/;
2904829096 // set stack-base & callee-address
@@ -29050,15 +29098,15 @@
2905029098 label = 3LLU; // ParseToken
2905129099 break;
2905229100 }
29053- case 2394LLU: // copy-back deleter (ParseToken to initfrom)
29101+ case 2398LLU: // copy-back deleter (ParseToken to initfrom)
2905429102 {
2905529103 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2905629104 // copy mutable arguments back from call to ParseToken
2905729105 stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29058- label = 2389LLU; // continue to roll stack
29106+ label = 2393LLU; // continue to roll stack
2905929107 break;
2906029108 }
29061- case 2395LLU: // return from ParseToken to initfrom
29109+ case 2399LLU: // return from ParseToken to initfrom
2906229110 {
2906329111 // copy mutable arguments back from call to ParseToken
2906429112 stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
@@ -29066,9 +29114,9 @@
2906629114 stack[base + 10] = stack[base + 34LLU];
2906729115 stack[base + 11] = stack[base + 35LLU];
2906829116 // call equ from initfrom
29069- stack[base + 31LLU] = 2396LLU/*throw to this address*/;
29117+ stack[base + 31LLU] = 2400LLU/*throw to this address*/;
2907029118 stack[base + 32LLU] = base;
29071- stack[base + 33LLU] = 2397LLU;
29119+ stack[base + 33LLU] = 2401LLU;
2907229120 // arguments for call to equ
2907329121 stack[base + 35LLU] = stack[base + 10]/*variant*/;
2907429122 stack[base + 36LLU] = 4LLU;
@@ -29077,14 +29125,14 @@
2907729125 label = 18446744073709551600LLU; // equ
2907829126 break;
2907929127 }
29080- case 2396LLU: // copy-back deleter (equ to initfrom)
29128+ case 2400LLU: // copy-back deleter (equ to initfrom)
2908129129 {
2908229130 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2908329131 // copy mutable arguments back from call to equ
29084- label = 2389LLU; // continue to roll stack
29132+ label = 2393LLU; // continue to roll stack
2908529133 break;
2908629134 }
29087- case 2397LLU: // return from equ to initfrom
29135+ case 2401LLU: // return from equ to initfrom
2908829136 {
2908929137 // copy mutable arguments back from call to equ
2909029138 // copy back results provided by call to equ
@@ -29091,21 +29139,21 @@
2909129139 stack[base + 9] = stack[base + 34LLU];
2909229140 if(!stack[base + 9]/*isequal*/)
2909329141 {
29094- label = 2398LLU; // jump to alternative
29142+ label = 2402LLU; // jump to alternative
2909529143 break;
2909629144 }
2909729145
2909829146 // consequent
29099- label = 2399LLU; // consequent complete
29147+ label = 2403LLU; // consequent complete
2910029148 break;
2910129149 }
29102- case 2398LLU: // alternative
29150+ case 2402LLU: // alternative
2910329151 {
2910429152 fprintf(stderr, "%s", "constructor requires variables but found ");
2910529153 // call reporttok from initfrom
29106- stack[base + 31LLU] = 2400LLU/*throw to this address*/;
29154+ stack[base + 31LLU] = 2404LLU/*throw to this address*/;
2910729155 stack[base + 32LLU] = base;
29108- stack[base + 33LLU] = 2401LLU;
29156+ stack[base + 33LLU] = 2405LLU;
2910929157 // arguments for call to reporttok
2911029158 stack[base + 34LLU] = stack[base + 10]/*variant*/;
2911129159 stack[base + 35LLU] = stack[base + 11]/*content*/;
@@ -29114,27 +29162,27 @@
2911429162 label = 18446744073709551582LLU; // reporttok
2911529163 break;
2911629164 }
29117- case 2400LLU: // copy-back deleter (reporttok to initfrom)
29165+ case 2404LLU: // copy-back deleter (reporttok to initfrom)
2911829166 {
2911929167 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2912029168 // copy mutable arguments back from call to reporttok
29121- label = 2389LLU; // continue to roll stack
29169+ label = 2393LLU; // continue to roll stack
2912229170 break;
2912329171 }
29124- case 2401LLU: // return from reporttok to initfrom
29172+ case 2405LLU: // return from reporttok to initfrom
2912529173 {
2912629174 // copy mutable arguments back from call to reporttok
2912729175 fprintf(stderr, "%s", "\n");
2912829176 exit(-1);
29129- label = 2399LLU; // alternative complete
29177+ label = 2403LLU; // alternative complete
2913029178 break;
2913129179 }
29132- case 2399LLU: // completed if-then-else
29180+ case 2403LLU: // completed if-then-else
2913329181 {
2913429182 // call getlettype from initfrom
29135- stack[base + 32LLU] = 2402LLU/*throw to this address*/;
29183+ stack[base + 32LLU] = 2406LLU/*throw to this address*/;
2913629184 stack[base + 33LLU] = base;
29137- stack[base + 34LLU] = 2403LLU;
29185+ stack[base + 34LLU] = 2407LLU;
2913829186 // arguments for call to getlettype
2913929187 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2914029188 stack[base + 37LLU] = stack[base + 11]/*content*/;
@@ -29145,14 +29193,14 @@
2914529193 label = 651LLU; // getlettype
2914629194 break;
2914729195 }
29148- case 2402LLU: // copy-back deleter (getlettype to initfrom)
29196+ case 2406LLU: // copy-back deleter (getlettype to initfrom)
2914929197 {
2915029198 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
2915129199 // copy mutable arguments back from call to getlettype
29152- label = 2389LLU; // continue to roll stack
29200+ label = 2393LLU; // continue to roll stack
2915329201 break;
2915429202 }
29155- case 2403LLU: // return from getlettype to initfrom
29203+ case 2407LLU: // return from getlettype to initfrom
2915629204 {
2915729205 // copy mutable arguments back from call to getlettype
2915829206 // copy back results provided by call to getlettype
@@ -29160,7 +29208,7 @@
2916029208 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2916129209 if(!newstack)
2916229210 {
29163- label = 2389LLU; // throw: begin to unroll stack
29211+ label = 2393LLU; // throw: begin to unroll stack
2916429212 break;
2916529213 }
2916629214
@@ -29167,9 +29215,9 @@
2916729215 newstack[15LLU] = 9876543210LLU; // overflow-marker
2916829216 // call equtype from initfrom
2916929217 newstack[0] = (uint64_t)stack; // backup stack location
29170- newstack[1] = 2404LLU;
29218+ newstack[1] = 2408LLU;
2917129219 newstack[2] = base;
29172- newstack[3] = 2405LLU;
29220+ newstack[3] = 2409LLU;
2917329221 // arguments for call to equtype
2917429222 newstack[5LLU] = stack[base + 29]/*dsttype*/;
2917529223 newstack[6LLU] = stack[base + 31]/*srctype*/;
@@ -29179,7 +29227,7 @@
2917929227 label = 342LLU; // equtype
2918029228 break;
2918129229 }
29182- case 2404LLU: // copy-back deleter (equtype to initfrom)
29230+ case 2408LLU: // copy-back deleter (equtype to initfrom)
2918329231 {
2918429232 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2918529233 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29191,10 +29239,10 @@
2919129239 }
2919229240 Free(15LLU + 1, sizeof(uint64_t), stack);
2919329241 stack = oldstack;
29194- label = 2389LLU; // continue to unroll stack
29242+ label = 2393LLU; // continue to unroll stack
2919529243 break;
2919629244 }
29197- case 2405LLU: // return from equtype to initfrom
29245+ case 2409LLU: // return from equtype to initfrom
2919829246 {
2919929247 uint64_t *oldstack = (uint64_t *)stack[0];
2920029248 // copy mutable arguments back from call to equtype
@@ -29209,7 +29257,7 @@
2920929257 stack = oldstack;
2921029258 if(!stack[base + 9]/*isequal*/)
2921129259 {
29212- label = 2406LLU; // jump to alternative
29260+ label = 2410LLU; // jump to alternative
2921329261 break;
2921429262 }
2921529263
@@ -29216,7 +29264,7 @@
2921629264 // consequent
2921729265 if(/*typename*/0 != ((uint64_t *)(stack[base + 29]/*dsttype*/))[0])
2921829266 {
29219- label = 2409LLU; // jump to alternative
29267+ label = 2413LLU; // jump to alternative
2922029268 break;
2922129269 }
2922229270
@@ -29224,9 +29272,9 @@
2922429272
2922529273 // case
2922629274 // call equ from initfrom
29227- stack[base + 33LLU] = 2411LLU/*throw to this address*/;
29275+ stack[base + 33LLU] = 2415LLU/*throw to this address*/;
2922829276 stack[base + 34LLU] = base;
29229- stack[base + 35LLU] = 2412LLU;
29277+ stack[base + 35LLU] = 2416LLU;
2923029278 // arguments for call to equ
2923129279 stack[base + 37LLU] = 881834713755418624LLU;
2923229280 stack[base + 38LLU] = stack[base + 32]/*name*/;
@@ -29235,14 +29283,14 @@
2923529283 label = 18446744073709551600LLU; // equ
2923629284 break;
2923729285 }
29238- case 2411LLU: // copy-back deleter (equ to initfrom)
29286+ case 2415LLU: // copy-back deleter (equ to initfrom)
2923929287 {
2924029288 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2924129289 // copy mutable arguments back from call to equ
29242- label = 2410LLU; // continue to roll stack
29290+ label = 2414LLU; // continue to roll stack
2924329291 break;
2924429292 }
29245- case 2412LLU: // return from equ to initfrom
29293+ case 2416LLU: // return from equ to initfrom
2924629294 {
2924729295 // copy mutable arguments back from call to equ
2924829296 // copy back results provided by call to equ
@@ -29249,7 +29297,7 @@
2924929297 stack[base + 9] = stack[base + 36LLU];
2925029298 if(!stack[base + 9]/*isequal*/)
2925129299 {
29252- label = 2413LLU; // jump to alternative
29300+ label = 2417LLU; // jump to alternative
2925329301 break;
2925429302 }
2925529303
@@ -29256,9 +29304,9 @@
2925629304 // consequent
2925729305 printf("%s", "\n (((uint64_t **)(");
2925829306 // call emitvaridx from initfrom
29259- stack[base + 33LLU] = 2415LLU/*throw to this address*/;
29307+ stack[base + 33LLU] = 2419LLU/*throw to this address*/;
2926029308 stack[base + 34LLU] = base;
29261- stack[base + 35LLU] = 2416LLU;
29309+ stack[base + 35LLU] = 2420LLU;
2926229310 // arguments for call to emitvaridx
2926329311 stack[base + 36LLU] = stack[base + 2]/*dstindex*/;
2926429312 // set stack-base & callee-address
@@ -29266,21 +29314,21 @@
2926629314 label = 691LLU; // emitvaridx
2926729315 break;
2926829316 }
29269- case 2415LLU: // copy-back deleter (emitvaridx to initfrom)
29317+ case 2419LLU: // copy-back deleter (emitvaridx to initfrom)
2927029318 {
2927129319 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2927229320 // copy mutable arguments back from call to emitvaridx
29273- label = 2410LLU; // continue to roll stack
29321+ label = 2414LLU; // continue to roll stack
2927429322 break;
2927529323 }
29276- case 2416LLU: // return from emitvaridx to initfrom
29324+ case 2420LLU: // return from emitvaridx to initfrom
2927729325 {
2927829326 // copy mutable arguments back from call to emitvaridx
2927929327 printf("%s", "))[1][");
2928029328 // call printnr from initfrom
29281- stack[base + 33LLU] = 2417LLU/*throw to this address*/;
29329+ stack[base + 33LLU] = 2421LLU/*throw to this address*/;
2928229330 stack[base + 34LLU] = base;
29283- stack[base + 35LLU] = 2418LLU;
29331+ stack[base + 35LLU] = 2422LLU;
2928429332 // arguments for call to printnr
2928529333 stack[base + 36LLU] = stack[base + 25]/*elemindex*/;
2928629334 // set stack-base & callee-address
@@ -29288,21 +29336,21 @@
2928829336 label = 18446744073709551590LLU; // printnr
2928929337 break;
2929029338 }
29291- case 2417LLU: // copy-back deleter (printnr to initfrom)
29339+ case 2421LLU: // copy-back deleter (printnr to initfrom)
2929229340 {
2929329341 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2929429342 // copy mutable arguments back from call to printnr
29295- label = 2410LLU; // continue to roll stack
29343+ label = 2414LLU; // continue to roll stack
2929629344 break;
2929729345 }
29298- case 2418LLU: // return from printnr to initfrom
29346+ case 2422LLU: // return from printnr to initfrom
2929929347 {
2930029348 // copy mutable arguments back from call to printnr
2930129349 printf("%s", "]) = ");
2930229350 // call emitvar from initfrom
29303- stack[base + 33LLU] = 2419LLU/*throw to this address*/;
29351+ stack[base + 33LLU] = 2423LLU/*throw to this address*/;
2930429352 stack[base + 34LLU] = base;
29305- stack[base + 35LLU] = 2420LLU;
29353+ stack[base + 35LLU] = 2424LLU;
2930629354 // arguments for call to emitvar
2930729355 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2930829356 stack[base + 37LLU] = stack[base + 11]/*content*/;
@@ -29313,27 +29361,27 @@
2931329361 label = 695LLU; // emitvar
2931429362 break;
2931529363 }
29316- case 2419LLU: // copy-back deleter (emitvar to initfrom)
29364+ case 2423LLU: // copy-back deleter (emitvar to initfrom)
2931729365 {
2931829366 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2931929367 // copy mutable arguments back from call to emitvar
29320- label = 2410LLU; // continue to roll stack
29368+ label = 2414LLU; // continue to roll stack
2932129369 break;
2932229370 }
29323- case 2420LLU: // return from emitvar to initfrom
29371+ case 2424LLU: // return from emitvar to initfrom
2932429372 {
2932529373 // copy mutable arguments back from call to emitvar
2932629374 printf("%s", ";");
29327- label = 2414LLU; // consequent complete
29375+ label = 2418LLU; // consequent complete
2932829376 break;
2932929377 }
29330- case 2413LLU: // alternative
29378+ case 2417LLU: // alternative
2933129379 {
2933229380 printf("%s", "\n INIT(&(((uint64_t **)(");
2933329381 // call emitvaridx from initfrom
29334- stack[base + 33LLU] = 2421LLU/*throw to this address*/;
29382+ stack[base + 33LLU] = 2425LLU/*throw to this address*/;
2933529383 stack[base + 34LLU] = base;
29336- stack[base + 35LLU] = 2422LLU;
29384+ stack[base + 35LLU] = 2426LLU;
2933729385 // arguments for call to emitvaridx
2933829386 stack[base + 36LLU] = stack[base + 2]/*dstindex*/;
2933929387 // set stack-base & callee-address
@@ -29341,21 +29389,21 @@
2934129389 label = 691LLU; // emitvaridx
2934229390 break;
2934329391 }
29344- case 2421LLU: // copy-back deleter (emitvaridx to initfrom)
29392+ case 2425LLU: // copy-back deleter (emitvaridx to initfrom)
2934529393 {
2934629394 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2934729395 // copy mutable arguments back from call to emitvaridx
29348- label = 2410LLU; // continue to roll stack
29396+ label = 2414LLU; // continue to roll stack
2934929397 break;
2935029398 }
29351- case 2422LLU: // return from emitvaridx to initfrom
29399+ case 2426LLU: // return from emitvaridx to initfrom
2935229400 {
2935329401 // copy mutable arguments back from call to emitvaridx
2935429402 printf("%s", "))[1][");
2935529403 // call printnr from initfrom
29356- stack[base + 33LLU] = 2423LLU/*throw to this address*/;
29404+ stack[base + 33LLU] = 2427LLU/*throw to this address*/;
2935729405 stack[base + 34LLU] = base;
29358- stack[base + 35LLU] = 2424LLU;
29406+ stack[base + 35LLU] = 2428LLU;
2935929407 // arguments for call to printnr
2936029408 stack[base + 36LLU] = stack[base + 25]/*elemindex*/;
2936129409 // set stack-base & callee-address
@@ -29363,21 +29411,21 @@
2936329411 label = 18446744073709551590LLU; // printnr
2936429412 break;
2936529413 }
29366- case 2423LLU: // copy-back deleter (printnr to initfrom)
29414+ case 2427LLU: // copy-back deleter (printnr to initfrom)
2936729415 {
2936829416 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2936929417 // copy mutable arguments back from call to printnr
29370- label = 2410LLU; // continue to roll stack
29418+ label = 2414LLU; // continue to roll stack
2937129419 break;
2937229420 }
29373- case 2424LLU: // return from printnr to initfrom
29421+ case 2428LLU: // return from printnr to initfrom
2937429422 {
2937529423 // copy mutable arguments back from call to printnr
2937629424 printf("%s", "]), &");
2937729425 // call emitvar from initfrom
29378- stack[base + 33LLU] = 2425LLU/*throw to this address*/;
29426+ stack[base + 33LLU] = 2429LLU/*throw to this address*/;
2937929427 stack[base + 34LLU] = base;
29380- stack[base + 35LLU] = 2426LLU;
29428+ stack[base + 35LLU] = 2430LLU;
2938129429 // arguments for call to emitvar
2938229430 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2938329431 stack[base + 37LLU] = stack[base + 11]/*content*/;
@@ -29388,21 +29436,21 @@
2938829436 label = 695LLU; // emitvar
2938929437 break;
2939029438 }
29391- case 2425LLU: // copy-back deleter (emitvar to initfrom)
29439+ case 2429LLU: // copy-back deleter (emitvar to initfrom)
2939229440 {
2939329441 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2939429442 // copy mutable arguments back from call to emitvar
29395- label = 2410LLU; // continue to roll stack
29443+ label = 2414LLU; // continue to roll stack
2939629444 break;
2939729445 }
29398- case 2426LLU: // return from emitvar to initfrom
29446+ case 2430LLU: // return from emitvar to initfrom
2939929447 {
2940029448 // copy mutable arguments back from call to emitvar
2940129449 printf("%s", ");");
2940229450 // call unscopelet from initfrom
29403- stack[base + 33LLU] = 2427LLU/*throw to this address*/;
29451+ stack[base + 33LLU] = 2431LLU/*throw to this address*/;
2940429452 stack[base + 34LLU] = base;
29405- stack[base + 35LLU] = 2428LLU;
29453+ stack[base + 35LLU] = 2432LLU;
2940629454 // arguments for call to unscopelet
2940729455 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2940829456 stack[base + 37LLU] = stack[base + 5]/*scope*/;
@@ -29412,41 +29460,41 @@
2941229460 label = 761LLU; // unscopelet
2941329461 break;
2941429462 }
29415- case 2427LLU: // copy-back deleter (unscopelet to initfrom)
29463+ case 2431LLU: // copy-back deleter (unscopelet to initfrom)
2941629464 {
2941729465 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2941829466 // copy mutable arguments back from call to unscopelet
2941929467 stack[base + 5]/*scope*/ = stack[base + 37LLU];
29420- label = 2410LLU; // continue to roll stack
29468+ label = 2414LLU; // continue to roll stack
2942129469 break;
2942229470 }
29423- case 2428LLU: // return from unscopelet to initfrom
29471+ case 2432LLU: // return from unscopelet to initfrom
2942429472 {
2942529473 // copy mutable arguments back from call to unscopelet
2942629474 stack[base + 5]/*scope*/ = stack[base + 37LLU];
29427- label = 2414LLU; // alternative complete
29475+ label = 2418LLU; // alternative complete
2942829476 break;
2942929477 }
29430- case 2414LLU: // completed if-then-else
29478+ case 2418LLU: // completed if-then-else
2943129479 {
2943229480 ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29433- label = 2408LLU; // case complete
29481+ label = 2412LLU; // case complete
2943429482 break;
2943529483 }
29436- case 2410LLU: // copy-back deleter (switch)
29484+ case 2414LLU: // copy-back deleter (switch)
2943729485 {
2943829486 ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29439- label = 2389LLU; // continue to unroll stack
29487+ label = 2393LLU; // continue to unroll stack
2944029488 break;
2944129489 }
29442- case 2409LLU: // try next case
29490+ case 2413LLU: // try next case
2944329491 {
2944429492 // default
2944529493 printf("%s", "\n INIT(&(((uint64_t **)(");
2944629494 // call emitvaridx from initfrom
29447- stack[base + 32LLU] = 2429LLU/*throw to this address*/;
29495+ stack[base + 32LLU] = 2433LLU/*throw to this address*/;
2944829496 stack[base + 33LLU] = base;
29449- stack[base + 34LLU] = 2430LLU;
29497+ stack[base + 34LLU] = 2434LLU;
2945029498 // arguments for call to emitvaridx
2945129499 stack[base + 35LLU] = stack[base + 2]/*dstindex*/;
2945229500 // set stack-base & callee-address
@@ -29454,21 +29502,21 @@
2945429502 label = 691LLU; // emitvaridx
2945529503 break;
2945629504 }
29457- case 2429LLU: // copy-back deleter (emitvaridx to initfrom)
29505+ case 2433LLU: // copy-back deleter (emitvaridx to initfrom)
2945829506 {
2945929507 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2946029508 // copy mutable arguments back from call to emitvaridx
29461- label = 2389LLU; // continue to roll stack
29509+ label = 2393LLU; // continue to roll stack
2946229510 break;
2946329511 }
29464- case 2430LLU: // return from emitvaridx to initfrom
29512+ case 2434LLU: // return from emitvaridx to initfrom
2946529513 {
2946629514 // copy mutable arguments back from call to emitvaridx
2946729515 printf("%s", "))[1][");
2946829516 // call printnr from initfrom
29469- stack[base + 32LLU] = 2431LLU/*throw to this address*/;
29517+ stack[base + 32LLU] = 2435LLU/*throw to this address*/;
2947029518 stack[base + 33LLU] = base;
29471- stack[base + 34LLU] = 2432LLU;
29519+ stack[base + 34LLU] = 2436LLU;
2947229520 // arguments for call to printnr
2947329521 stack[base + 35LLU] = stack[base + 25]/*elemindex*/;
2947429522 // set stack-base & callee-address
@@ -29476,21 +29524,21 @@
2947629524 label = 18446744073709551590LLU; // printnr
2947729525 break;
2947829526 }
29479- case 2431LLU: // copy-back deleter (printnr to initfrom)
29527+ case 2435LLU: // copy-back deleter (printnr to initfrom)
2948029528 {
2948129529 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2948229530 // copy mutable arguments back from call to printnr
29483- label = 2389LLU; // continue to roll stack
29531+ label = 2393LLU; // continue to roll stack
2948429532 break;
2948529533 }
29486- case 2432LLU: // return from printnr to initfrom
29534+ case 2436LLU: // return from printnr to initfrom
2948729535 {
2948829536 // copy mutable arguments back from call to printnr
2948929537 printf("%s", "]), &");
2949029538 // call emitvar from initfrom
29491- stack[base + 32LLU] = 2433LLU/*throw to this address*/;
29539+ stack[base + 32LLU] = 2437LLU/*throw to this address*/;
2949229540 stack[base + 33LLU] = base;
29493- stack[base + 34LLU] = 2434LLU;
29541+ stack[base + 34LLU] = 2438LLU;
2949429542 // arguments for call to emitvar
2949529543 stack[base + 35LLU] = stack[base + 0]/*fnid*/;
2949629544 stack[base + 36LLU] = stack[base + 11]/*content*/;
@@ -29501,21 +29549,21 @@
2950129549 label = 695LLU; // emitvar
2950229550 break;
2950329551 }
29504- case 2433LLU: // copy-back deleter (emitvar to initfrom)
29552+ case 2437LLU: // copy-back deleter (emitvar to initfrom)
2950529553 {
2950629554 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2950729555 // copy mutable arguments back from call to emitvar
29508- label = 2389LLU; // continue to roll stack
29556+ label = 2393LLU; // continue to roll stack
2950929557 break;
2951029558 }
29511- case 2434LLU: // return from emitvar to initfrom
29559+ case 2438LLU: // return from emitvar to initfrom
2951229560 {
2951329561 // copy mutable arguments back from call to emitvar
2951429562 printf("%s", ");");
2951529563 // call unscopelet from initfrom
29516- stack[base + 32LLU] = 2435LLU/*throw to this address*/;
29564+ stack[base + 32LLU] = 2439LLU/*throw to this address*/;
2951729565 stack[base + 33LLU] = base;
29518- stack[base + 34LLU] = 2436LLU;
29566+ stack[base + 34LLU] = 2440LLU;
2951929567 // arguments for call to unscopelet
2952029568 stack[base + 35LLU] = stack[base + 0]/*fnid*/;
2952129569 stack[base + 36LLU] = stack[base + 5]/*scope*/;
@@ -29525,33 +29573,33 @@
2952529573 label = 761LLU; // unscopelet
2952629574 break;
2952729575 }
29528- case 2435LLU: // copy-back deleter (unscopelet to initfrom)
29576+ case 2439LLU: // copy-back deleter (unscopelet to initfrom)
2952929577 {
2953029578 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2953129579 // copy mutable arguments back from call to unscopelet
2953229580 stack[base + 5]/*scope*/ = stack[base + 36LLU];
29533- label = 2389LLU; // continue to roll stack
29581+ label = 2393LLU; // continue to roll stack
2953429582 break;
2953529583 }
29536- case 2436LLU: // return from unscopelet to initfrom
29584+ case 2440LLU: // return from unscopelet to initfrom
2953729585 {
2953829586 // copy mutable arguments back from call to unscopelet
2953929587 stack[base + 5]/*scope*/ = stack[base + 36LLU];
29540- label = 2408LLU; // default complete
29588+ label = 2412LLU; // default complete
2954129589 break;
2954229590 }
29543- case 2408LLU: // completed switch
29591+ case 2412LLU: // completed switch
2954429592 {
29545- label = 2407LLU; // consequent complete
29593+ label = 2411LLU; // consequent complete
2954629594 break;
2954729595 }
29548- case 2406LLU: // alternative
29596+ case 2410LLU: // alternative
2954929597 {
2955029598 fprintf(stderr, "%s", "in function ");
2955129599 // call reportid from initfrom
29552- stack[base + 32LLU] = 2437LLU/*throw to this address*/;
29600+ stack[base + 32LLU] = 2441LLU/*throw to this address*/;
2955329601 stack[base + 33LLU] = base;
29554- stack[base + 34LLU] = 2438LLU;
29602+ stack[base + 34LLU] = 2442LLU;
2955529603 // arguments for call to reportid
2955629604 stack[base + 35LLU] = stack[base + 0]/*fnid*/;
2955729605 // set stack-base & callee-address
@@ -29559,14 +29607,14 @@
2955929607 label = 18446744073709551586LLU; // reportid
2956029608 break;
2956129609 }
29562- case 2437LLU: // copy-back deleter (reportid to initfrom)
29610+ case 2441LLU: // copy-back deleter (reportid to initfrom)
2956329611 {
2956429612 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2956529613 // copy mutable arguments back from call to reportid
29566- label = 2389LLU; // continue to roll stack
29614+ label = 2393LLU; // continue to roll stack
2956729615 break;
2956829616 }
29569- case 2438LLU: // return from reportid to initfrom
29617+ case 2442LLU: // return from reportid to initfrom
2957029618 {
2957129619 // copy mutable arguments back from call to reportid
2957229620 fprintf(stderr, "%s", ": constructor of type ");
@@ -29573,7 +29621,7 @@
2957329621 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2957429622 if(!newstack)
2957529623 {
29576- label = 2389LLU; // throw: begin to unroll stack
29624+ label = 2393LLU; // throw: begin to unroll stack
2957729625 break;
2957829626 }
2957929627
@@ -29580,9 +29628,9 @@
2958029628 newstack[10LLU] = 9876543210LLU; // overflow-marker
2958129629 // call reporttype from initfrom
2958229630 newstack[0] = (uint64_t)stack; // backup stack location
29583- newstack[1] = 2439LLU;
29631+ newstack[1] = 2443LLU;
2958429632 newstack[2] = base;
29585- newstack[3] = 2440LLU;
29633+ newstack[3] = 2444LLU;
2958629634 // arguments for call to reporttype
2958729635 newstack[4LLU] = stack[base + 29]/*dsttype*/;
2958829636 stack = newstack;
@@ -29591,7 +29639,7 @@
2959129639 label = 316LLU; // reporttype