• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1213 (tree)
Time2021-03-29 06:44:22
Authorjakobthomsen

Log Message

reserve keywords

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1212)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1213)
@@ -17918,7 +17918,7 @@
1791817918 }
1791917919 case 1524LLU: // try next case
1792017920 {
17921- if(788334650111033344 != stack[base + 1]/*id*/)
17921+ if(786630200929550336 != stack[base + 1]/*id*/)
1792217922 {
1792317923 label = 1528LLU; // jump to alternative
1792417924 break;
@@ -17952,7 +17952,7 @@
1795217952 }
1795317953 case 1528LLU: // try next case
1795417954 {
17955- if(819847183506341888 != stack[base + 1]/*id*/)
17955+ if(788334650111033344 != stack[base + 1]/*id*/)
1795617956 {
1795717957 label = 1532LLU; // jump to alternative
1795817958 break;
@@ -17986,7 +17986,7 @@
1798617986 }
1798717987 case 1532LLU: // try next case
1798817988 {
17989- if(819865187908583424 != stack[base + 1]/*id*/)
17989+ if(819847183506341888 != stack[base + 1]/*id*/)
1799017990 {
1799117991 label = 1536LLU; // jump to alternative
1799217992 break;
@@ -18020,7 +18020,7 @@
1802018020 }
1802118021 case 1536LLU: // try next case
1802218022 {
18023- if(819872884582252544 != stack[base + 1]/*id*/)
18023+ if(819865187908583424 != stack[base + 1]/*id*/)
1802418024 {
1802518025 label = 1540LLU; // jump to alternative
1802618026 break;
@@ -18054,7 +18054,7 @@
1805418054 }
1805518055 case 1540LLU: // try next case
1805618056 {
18057- if(856729206128640000 != stack[base + 1]/*id*/)
18057+ if(819872884582252544 != stack[base + 1]/*id*/)
1805818058 {
1805918059 label = 1544LLU; // jump to alternative
1806018060 break;
@@ -18088,7 +18088,7 @@
1808818088 }
1808918089 case 1544LLU: // try next case
1809018090 {
18091- if(859571802316210176 != stack[base + 1]/*id*/)
18091+ if(842862180511514624 != stack[base + 1]/*id*/)
1809218092 {
1809318093 label = 1548LLU; // jump to alternative
1809418094 break;
@@ -18122,7 +18122,7 @@
1812218122 }
1812318123 case 1548LLU: // try next case
1812418124 {
18125- if(842862180511514624 != stack[base + 1]/*id*/)
18125+ if(842897672560967680 != stack[base + 1]/*id*/)
1812618126 {
1812718127 label = 1552LLU; // jump to alternative
1812818128 break;
@@ -18156,11 +18156,113 @@
1815618156 }
1815718157 case 1552LLU: // try next case
1815818158 {
18159+ if(856729206128640000 != stack[base + 1]/*id*/)
18160+ {
18161+ label = 1556LLU; // jump to alternative
18162+ break;
18163+ }
18164+
18165+ // case
18166+ label = 1559LLU; // skip deleter
18167+ break;
18168+ }
18169+ case 1558LLU: // deleter
18170+ {
18171+ // throw from reservedfn
18172+ if(!stack[base + 0])
18173+ {
18174+ label = 1557LLU; // skip, variable already deleted/unscoped
18175+ break;
18176+ }
18177+ label = 1557LLU; // continue unrolling stack, delete next variable
18178+ break;
18179+ }
18180+ case 1559LLU: // skipped deleter
18181+ {
18182+ stack[base + 0] = 1;
18183+ label = 1503LLU; // case complete
18184+ break;
18185+ }
18186+ case 1557LLU: // copy-back deleter (switch)
18187+ {
18188+ label = 1502LLU; // continue to unroll stack
18189+ break;
18190+ }
18191+ case 1556LLU: // try next case
18192+ {
18193+ if(859571802316210176 != stack[base + 1]/*id*/)
18194+ {
18195+ label = 1560LLU; // jump to alternative
18196+ break;
18197+ }
18198+
18199+ // case
18200+ label = 1563LLU; // skip deleter
18201+ break;
18202+ }
18203+ case 1562LLU: // deleter
18204+ {
18205+ // throw from reservedfn
18206+ if(!stack[base + 0])
18207+ {
18208+ label = 1561LLU; // skip, variable already deleted/unscoped
18209+ break;
18210+ }
18211+ label = 1561LLU; // continue unrolling stack, delete next variable
18212+ break;
18213+ }
18214+ case 1563LLU: // skipped deleter
18215+ {
18216+ stack[base + 0] = 1;
18217+ label = 1503LLU; // case complete
18218+ break;
18219+ }
18220+ case 1561LLU: // copy-back deleter (switch)
18221+ {
18222+ label = 1502LLU; // continue to unroll stack
18223+ break;
18224+ }
18225+ case 1560LLU: // try next case
18226+ {
18227+ if(910732593752702976 != stack[base + 1]/*id*/)
18228+ {
18229+ label = 1564LLU; // jump to alternative
18230+ break;
18231+ }
18232+
18233+ // case
18234+ label = 1567LLU; // skip deleter
18235+ break;
18236+ }
18237+ case 1566LLU: // deleter
18238+ {
18239+ // throw from reservedfn
18240+ if(!stack[base + 0])
18241+ {
18242+ label = 1565LLU; // skip, variable already deleted/unscoped
18243+ break;
18244+ }
18245+ label = 1565LLU; // continue unrolling stack, delete next variable
18246+ break;
18247+ }
18248+ case 1567LLU: // skipped deleter
18249+ {
18250+ stack[base + 0] = 1;
18251+ label = 1503LLU; // case complete
18252+ break;
18253+ }
18254+ case 1565LLU: // copy-back deleter (switch)
18255+ {
18256+ label = 1502LLU; // continue to unroll stack
18257+ break;
18258+ }
18259+ case 1564LLU: // try next case
18260+ {
1815918261 // default
18160- label = 1557LLU; // skip deleter
18262+ label = 1569LLU; // skip deleter
1816118263 break;
1816218264 }
18163- case 1556LLU: // deleter
18265+ case 1568LLU: // deleter
1816418266 {
1816518267 // throw from reservedfn
1816618268 if(!stack[base + 0])
@@ -18171,7 +18273,7 @@
1817118273 label = 1502LLU; // continue unrolling stack, delete next variable
1817218274 break;
1817318275 }
18174- case 1557LLU: // skipped deleter
18276+ case 1569LLU: // skipped deleter
1817518277 {
1817618278 stack[base + 0] = 0;
1817718279 label = 1503LLU; // default complete
@@ -18184,38 +18286,38 @@
1818418286 base = stack[base - 2];
1818518287 break;
1818618288 }
18187- case 1559LLU: // function FindFn failed
18289+ case 1571LLU: // function FindFn failed
1818818290 {
1818918291 label = stack[base - 3];
1819018292 base = stack[base - 2];
1819118293 break;
1819218294 }
18193- case 1558LLU: // FindFn
18295+ case 1570LLU: // FindFn
1819418296 {
1819518297 //#define res0 0
1819618298 //#define arg0 1
1819718299 //#define arg1 2
1819818300 //#define arg2 3
18199- label = 1561LLU; // skip deleter
18301+ label = 1573LLU; // skip deleter
1820018302 break;
1820118303 }
18202- case 1560LLU: // deleter
18304+ case 1572LLU: // deleter
1820318305 {
1820418306 // throw from FindFn
1820518307 if(!stack[base + 4])
1820618308 {
18207- label = 1559LLU; // skip, variable already deleted/unscoped
18309+ label = 1571LLU; // skip, variable already deleted/unscoped
1820818310 break;
1820918311 }
18210- label = 1559LLU; // continue unrolling stack, delete next variable
18312+ label = 1571LLU; // continue unrolling stack, delete next variable
1821118313 break;
1821218314 }
18213- case 1561LLU: // skipped deleter
18315+ case 1573LLU: // skipped deleter
1821418316 {
1821518317 // call reservedfn from FindFn
18216- stack[base + 5LLU] = 1562LLU/*throw to this address*/;
18318+ stack[base + 5LLU] = 1574LLU/*throw to this address*/;
1821718319 stack[base + 6LLU] = base;
18218- stack[base + 7LLU] = 1563LLU;
18320+ stack[base + 7LLU] = 1575LLU;
1821918321 // arguments for call to reservedfn
1822018322 stack[base + 9LLU] = stack[base + 3]/*id*/;
1822118323 // set stack-base & callee-address
@@ -18223,13 +18325,13 @@
1822318325 label = 1501LLU; // reservedfn
1822418326 break;
1822518327 }
18226- case 1562LLU: // copy-back deleter (reservedfn to FindFn)
18328+ case 1574LLU: // copy-back deleter (reservedfn to FindFn)
1822718329 {
1822818330 // copy mutable arguments back from call to reservedfn
18229- label = 1559LLU; // continue to roll stack
18331+ label = 1571LLU; // continue to roll stack
1823018332 break;
1823118333 }
18232- case 1563LLU: // return from reservedfn to FindFn
18334+ case 1575LLU: // return from reservedfn to FindFn
1823318335 {
1823418336 // copy mutable arguments back from call to reservedfn
1823518337 // copy back results provided by call to reservedfn
@@ -18236,7 +18338,7 @@
1823618338 stack[base + 4] = stack[base + 8LLU];
1823718339 if(!stack[base + 4]/*found*/)
1823818340 {
18239- label = 1564LLU; // jump to alternative
18341+ label = 1576LLU; // jump to alternative
1824018342 break;
1824118343 }
1824218344
@@ -18243,9 +18345,9 @@
1824318345 // consequent
1824418346 fprintf(stderr, "%s", "in function ");
1824518347 // call reportid from FindFn
18246- stack[base + 5LLU] = 1566LLU/*throw to this address*/;
18348+ stack[base + 5LLU] = 1578LLU/*throw to this address*/;
1824718349 stack[base + 6LLU] = base;
18248- stack[base + 7LLU] = 1567LLU;
18350+ stack[base + 7LLU] = 1579LLU;
1824918351 // arguments for call to reportid
1825018352 stack[base + 8LLU] = stack[base + 1]/*fnid*/;
1825118353 // set stack-base & callee-address
@@ -18253,21 +18355,21 @@
1825318355 label = 18446744073709551586LLU; // reportid
1825418356 break;
1825518357 }
18256- case 1566LLU: // copy-back deleter (reportid to FindFn)
18358+ case 1578LLU: // copy-back deleter (reportid to FindFn)
1825718359 {
1825818360 // copy mutable arguments back from call to reportid
18259- label = 1560LLU; // continue to roll stack
18361+ label = 1572LLU; // continue to roll stack
1826018362 break;
1826118363 }
18262- case 1567LLU: // return from reportid to FindFn
18364+ case 1579LLU: // return from reportid to FindFn
1826318365 {
1826418366 // copy mutable arguments back from call to reportid
1826518367 fprintf(stderr, "%s", ": ");
1826618368 fprintf(stderr, "%s", "reserved function ");
1826718369 // call reportid from FindFn
18268- stack[base + 5LLU] = 1568LLU/*throw to this address*/;
18370+ stack[base + 5LLU] = 1580LLU/*throw to this address*/;
1826918371 stack[base + 6LLU] = base;
18270- stack[base + 7LLU] = 1569LLU;
18372+ stack[base + 7LLU] = 1581LLU;
1827118373 // arguments for call to reportid
1827218374 stack[base + 8LLU] = stack[base + 3]/*id*/;
1827318375 // set stack-base & callee-address
@@ -18275,40 +18377,40 @@
1827518377 label = 18446744073709551586LLU; // reportid
1827618378 break;
1827718379 }
18278- case 1568LLU: // copy-back deleter (reportid to FindFn)
18380+ case 1580LLU: // copy-back deleter (reportid to FindFn)
1827918381 {
1828018382 // copy mutable arguments back from call to reportid
18281- label = 1560LLU; // continue to roll stack
18383+ label = 1572LLU; // continue to roll stack
1828218384 break;
1828318385 }
18284- case 1569LLU: // return from reportid to FindFn
18386+ case 1581LLU: // return from reportid to FindFn
1828518387 {
1828618388 // copy mutable arguments back from call to reportid
1828718389 fprintf(stderr, "%s", " not called properly - check result-types & parameter-types\n");
1828818390 {
18289- label = 1560LLU; // throw: begin to unroll stack
18391+ label = 1572LLU; // throw: begin to unroll stack
1829018392 break;
1829118393 }
1829218394
18293- label = 1565LLU; // consequent complete
18395+ label = 1577LLU; // consequent complete
1829418396 break;
1829518397 }
18296- case 1564LLU: // alternative
18398+ case 1576LLU: // alternative
1829718399 {
18298- label = 1565LLU; // alternative complete
18400+ label = 1577LLU; // alternative complete
1829918401 break;
1830018402 }
18301- case 1565LLU: // completed if-then-else
18403+ case 1577LLU: // completed if-then-else
1830218404 {
18303- label = 1571LLU; // skip deleter
18405+ label = 1583LLU; // skip deleter
1830418406 break;
1830518407 }
18306- case 1570LLU: // deleter
18408+ case 1582LLU: // deleter
1830718409 {
1830818410 // throw from FindFn
1830918411 if(!stack[base + 5])
1831018412 {
18311- label = 1560LLU; // skip, variable already deleted/unscoped
18413+ label = 1572LLU; // skip, variable already deleted/unscoped
1831218414 break;
1831318415 }
1831418416
@@ -18317,7 +18419,7 @@
1831718419 newstack[0] = (uint64_t)stack; // backup stack location
1831818420 newstack[1] = 1234567890;
1831918421 newstack[2] = base;
18320- newstack[3] = 1572LLU;
18422+ newstack[3] = 1584LLU;
1832118423 stack = newstack;
1832218424 // set stack-base & callee-address
1832318425 base = 4/*deloffset*/;
@@ -18324,21 +18426,21 @@
1832418426 label = 1420LLU; // ~fndef
1832518427 break;
1832618428 }
18327- case 1572LLU: // return from ~fndef to FindFn
18429+ case 1584LLU: // return from ~fndef to FindFn
1832818430 {
1832918431 stack = (uint64_t *)stack[0];
1833018432 // releasing toplevel container
1833118433 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4));
1833218434
18333- label = 1560LLU; // continue unrolling stack, delete next variable
18435+ label = 1572LLU; // continue unrolling stack, delete next variable
1833418436 break;
1833518437 }
18336- case 1571LLU: // skipped deleter
18438+ case 1583LLU: // skipped deleter
1833718439 {
1833818440 // call mkfndummy from FindFn
18339- stack[base + 6LLU] = 1573LLU/*throw to this address*/;
18441+ stack[base + 6LLU] = 1585LLU/*throw to this address*/;
1834018442 stack[base + 7LLU] = base;
18341- stack[base + 8LLU] = 1574LLU;
18443+ stack[base + 8LLU] = 1586LLU;
1834218444 // arguments for call to mkfndummy
1834318445 // set stack-base & callee-address
1834418446 base += 9LLU;
@@ -18345,26 +18447,26 @@
1834518447 label = 1428LLU; // mkfndummy
1834618448 break;
1834718449 }
18348- case 1573LLU: // copy-back deleter (mkfndummy to FindFn)
18450+ case 1585LLU: // copy-back deleter (mkfndummy to FindFn)
1834918451 {
1835018452 // copy mutable arguments back from call to mkfndummy
18351- label = 1560LLU; // continue to roll stack
18453+ label = 1572LLU; // continue to roll stack
1835218454 break;
1835318455 }
18354- case 1574LLU: // return from mkfndummy to FindFn
18456+ case 1586LLU: // return from mkfndummy to FindFn
1835518457 {
1835618458 // copy mutable arguments back from call to mkfndummy
1835718459 // copy back results provided by call to mkfndummy
1835818460 stack[base + 5] = stack[base + 9LLU];
1835918461 flippedassign(stack[base + 2]/*fndefs*/, &stack[base + 6]);
18360- label = 1575LLU; // start to repeat
18462+ label = 1587LLU; // start to repeat
1836118463 break;
1836218464 }
18363- case 1575LLU: // repeat from here
18465+ case 1587LLU: // repeat from here
1836418466 {
1836518467 if(!stack[base + 6])
1836618468 {
18367- label = 1576LLU; // break loop
18469+ label = 1588LLU; // break loop
1836818470 break;
1836918471 }
1837018472
@@ -18374,19 +18476,19 @@
1837418476 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
1837518477 if(!stack[base + 4]/*found*/)
1837618478 {
18377- label = 1578LLU; // jump to alternative
18479+ label = 1590LLU; // jump to alternative
1837818480 break;
1837918481 }
1838018482
1838118483 // consequent
18382- label = 1579LLU; // consequent complete
18484+ label = 1591LLU; // consequent complete
1838318485 break;
1838418486 }
18385- case 1578LLU: // alternative
18487+ case 1590LLU: // alternative
1838618488 {
1838718489 if(/*fndef*/0 != ((uint64_t *)(stack[base + 7]/*fndef*/))[0])
1838818490 {
18389- label = 1581LLU; // jump to alternative
18491+ label = 1593LLU; // jump to alternative
1839018492 break;
1839118493 }
1839218494
@@ -18400,27 +18502,27 @@
1840018502 /*IO*/stack[base + 16] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][7]/*IO*/;
1840118503
1840218504 // case
18403- label = 1584LLU; // skip deleter
18505+ label = 1596LLU; // skip deleter
1840418506 break;
1840518507 }
18406- case 1583LLU: // deleter
18508+ case 1595LLU: // deleter
1840718509 {
1840818510 // throw from FindFn
1840918511 if(!stack[base + 17])
1841018512 {
18411- label = 1582LLU; // skip, variable already deleted/unscoped
18513+ label = 1594LLU; // skip, variable already deleted/unscoped
1841218514 break;
1841318515 }
18414- label = 1582LLU; // continue unrolling stack, delete next variable
18516+ label = 1594LLU; // continue unrolling stack, delete next variable
1841518517 break;
1841618518 }
18417- case 1584LLU: // skipped deleter
18519+ case 1596LLU: // skipped deleter
1841818520 {
1841918521 stack[base + 17] = 0;
1842018522 // call equ from FindFn
18421- stack[base + 18LLU] = 1585LLU/*throw to this address*/;
18523+ stack[base + 18LLU] = 1597LLU/*throw to this address*/;
1842218524 stack[base + 19LLU] = base;
18423- stack[base + 20LLU] = 1586LLU;
18525+ stack[base + 20LLU] = 1598LLU;
1842418526 // arguments for call to equ
1842518527 stack[base + 22LLU] = stack[base + 3]/*id*/;
1842618528 stack[base + 23LLU] = stack[base + 13]/*defid*/;
@@ -18429,13 +18531,13 @@
1842918531 label = 18446744073709551600LLU; // equ
1843018532 break;
1843118533 }
18432- case 1585LLU: // copy-back deleter (equ to FindFn)
18534+ case 1597LLU: // copy-back deleter (equ to FindFn)
1843318535 {
1843418536 // copy mutable arguments back from call to equ
18435- label = 1583LLU; // continue to roll stack
18537+ label = 1595LLU; // continue to roll stack
1843618538 break;
1843718539 }
18438- case 1586LLU: // return from equ to FindFn
18540+ case 1598LLU: // return from equ to FindFn
1843918541 {
1844018542 // copy mutable arguments back from call to equ
1844118543 // copy back results provided by call to equ
@@ -18442,20 +18544,20 @@
1844218544 stack[base + 17] = stack[base + 21LLU];
1844318545 if(!stack[base + 17]/*isequal*/)
1844418546 {
18445- label = 1587LLU; // jump to alternative
18547+ label = 1599LLU; // jump to alternative
1844618548 break;
1844718549 }
1844818550
1844918551 // consequent
18450- label = 1590LLU; // skip deleter
18552+ label = 1602LLU; // skip deleter
1845118553 break;
1845218554 }
18453- case 1589LLU: // deleter
18555+ case 1601LLU: // deleter
1845418556 {
1845518557 // throw from FindFn
1845618558 if(!stack[base + 18])
1845718559 {
18458- label = 1583LLU; // skip, variable already deleted/unscoped
18560+ label = 1595LLU; // skip, variable already deleted/unscoped
1845918561 break;
1846018562 }
1846118563
@@ -18464,7 +18566,7 @@
1846418566 newstack[0] = (uint64_t)stack; // backup stack location
1846518567 newstack[1] = 1234567890;
1846618568 newstack[2] = base;
18467- newstack[3] = 1591LLU;
18569+ newstack[3] = 1603LLU;
1846818570 stack = newstack;
1846918571 // set stack-base & callee-address
1847018572 base = 4/*deloffset*/;
@@ -18471,21 +18573,21 @@
1847118573 label = 1420LLU; // ~fndef
1847218574 break;
1847318575 }
18474- case 1591LLU: // return from ~fndef to FindFn
18576+ case 1603LLU: // return from ~fndef to FindFn
1847518577 {
1847618578 stack = (uint64_t *)stack[0];
1847718579 // releasing toplevel container
1847818580 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1847918581
18480- label = 1583LLU; // continue unrolling stack, delete next variable
18582+ label = 1595LLU; // continue unrolling stack, delete next variable
1848118583 break;
1848218584 }
18483- case 1590LLU: // skipped deleter
18585+ case 1602LLU: // skipped deleter
1848418586 {
1848518587 // call copyfndef from FindFn
18486- stack[base + 19LLU] = 1592LLU/*throw to this address*/;
18588+ stack[base + 19LLU] = 1604LLU/*throw to this address*/;
1848718589 stack[base + 20LLU] = base;
18488- stack[base + 21LLU] = 1593LLU;
18590+ stack[base + 21LLU] = 1605LLU;
1848918591 // arguments for call to copyfndef
1849018592 stack[base + 23LLU] = stack[base + 7]/*fndef*/;
1849118593 // set stack-base & callee-address
@@ -18493,13 +18595,13 @@
1849318595 label = 1455LLU; // copyfndef
1849418596 break;
1849518597 }
18496- case 1592LLU: // copy-back deleter (copyfndef to FindFn)
18598+ case 1604LLU: // copy-back deleter (copyfndef to FindFn)
1849718599 {
1849818600 // copy mutable arguments back from call to copyfndef
18499- label = 1583LLU; // continue to roll stack
18601+ label = 1595LLU; // continue to roll stack
1850018602 break;
1850118603 }
18502- case 1593LLU: // return from copyfndef to FindFn
18604+ case 1605LLU: // return from copyfndef to FindFn
1850318605 {
1850418606 // copy mutable arguments back from call to copyfndef
1850518607 // copy back results provided by call to copyfndef
@@ -18512,7 +18614,7 @@
1851218614 newstack[0] = (uint64_t)stack; // backup stack location
1851318615 newstack[1] = 1234567890;
1851418616 newstack[2] = base;
18515- newstack[3] = 1594LLU;
18617+ newstack[3] = 1606LLU;
1851618618 stack = newstack;
1851718619 // set stack-base & callee-address
1851818620 base = 4/*deloffset*/;
@@ -18519,21 +18621,21 @@
1851918621 label = 1420LLU; // ~fndef
1852018622 break;
1852118623 }
18522- case 1594LLU: // return from ~fndef to FindFn
18624+ case 1606LLU: // return from ~fndef to FindFn
1852318625 {
1852418626 stack = (uint64_t *)stack[0];
1852518627 // releasing toplevel container
1852618628 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1852718629
18528- label = 1588LLU; // consequent complete
18630+ label = 1600LLU; // consequent complete
1852918631 break;
1853018632 }
18531- case 1587LLU: // alternative
18633+ case 1599LLU: // alternative
1853218634 {
18533- label = 1588LLU; // alternative complete
18635+ label = 1600LLU; // alternative complete
1853418636 break;
1853518637 }
18536- case 1588LLU: // completed if-then-else
18638+ case 1600LLU: // completed if-then-else
1853718639 {
1853818640 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1853918641 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18543,10 +18645,10 @@
1854318645 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1854418646 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1854518647 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18546- label = 1580LLU; // case complete
18648+ label = 1592LLU; // case complete
1854718649 break;
1854818650 }
18549- case 1582LLU: // copy-back deleter (switch)
18651+ case 1594LLU: // copy-back deleter (switch)
1855018652 {
1855118653 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1855218654 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18556,50 +18658,50 @@
1855618658 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1855718659 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1855818660 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18559- label = 1577LLU; // continue to unroll stack
18661+ label = 1589LLU; // continue to unroll stack
1856018662 break;
1856118663 }
18562- case 1581LLU: // try next case
18664+ case 1593LLU: // try next case
1856318665 {
1856418666 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1856518667 exit(-1);
1856618668 }
18567- case 1580LLU: // completed switch
18669+ case 1592LLU: // completed switch
1856818670 {
18569- label = 1579LLU; // alternative complete
18671+ label = 1591LLU; // alternative complete
1857018672 break;
1857118673 }
18572- case 1579LLU: // completed if-then-else
18674+ case 1591LLU: // completed if-then-else
1857318675 {
1857418676 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18575- label = 1575LLU; // repeat
18677+ label = 1587LLU; // repeat
1857618678 break;
1857718679 }
18578- case 1577LLU: // copy-back deleter for while next
18680+ case 1589LLU: // copy-back deleter for while next
1857918681 {
1858018682 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18581- label = 1570LLU; // continue to unroll stack
18683+ label = 1582LLU; // continue to unroll stack
1858218684 break;
1858318685 }
18584- case 1576LLU: // loop finished
18686+ case 1588LLU: // loop finished
1858518687 {
1858618688 if(!stack[base + 4]/*found*/)
1858718689 {
18588- label = 1595LLU; // jump to alternative
18690+ label = 1607LLU; // jump to alternative
1858918691 break;
1859018692 }
1859118693
1859218694 // consequent
18593- label = 1596LLU; // consequent complete
18695+ label = 1608LLU; // consequent complete
1859418696 break;
1859518697 }
18596- case 1595LLU: // alternative
18698+ case 1607LLU: // alternative
1859718699 {
1859818700 fprintf(stderr, "%s", "in function ");
1859918701 // call reportid from FindFn
18600- stack[base + 9LLU] = 1597LLU/*throw to this address*/;
18702+ stack[base + 9LLU] = 1609LLU/*throw to this address*/;
1860118703 stack[base + 10LLU] = base;
18602- stack[base + 11LLU] = 1598LLU;
18704+ stack[base + 11LLU] = 1610LLU;
1860318705 // arguments for call to reportid
1860418706 stack[base + 12LLU] = stack[base + 1]/*fnid*/;
1860518707 // set stack-base & callee-address
@@ -18607,21 +18709,21 @@
1860718709 label = 18446744073709551586LLU; // reportid
1860818710 break;
1860918711 }
18610- case 1597LLU: // copy-back deleter (reportid to FindFn)
18712+ case 1609LLU: // copy-back deleter (reportid to FindFn)
1861118713 {
1861218714 // copy mutable arguments back from call to reportid
18613- label = 1570LLU; // continue to roll stack
18715+ label = 1582LLU; // continue to roll stack
1861418716 break;
1861518717 }
18616- case 1598LLU: // return from reportid to FindFn
18718+ case 1610LLU: // return from reportid to FindFn
1861718719 {
1861818720 // copy mutable arguments back from call to reportid
1861918721 fprintf(stderr, "%s", ": ");
1862018722 fprintf(stderr, "%s", "function ");
1862118723 // call reportid from FindFn
18622- stack[base + 9LLU] = 1599LLU/*throw to this address*/;
18724+ stack[base + 9LLU] = 1611LLU/*throw to this address*/;
1862318725 stack[base + 10LLU] = base;
18624- stack[base + 11LLU] = 1600LLU;
18726+ stack[base + 11LLU] = 1612LLU;
1862518727 // arguments for call to reportid
1862618728 stack[base + 12LLU] = stack[base + 3]/*id*/;
1862718729 // set stack-base & callee-address
@@ -18629,35 +18731,35 @@
1862918731 label = 18446744073709551586LLU; // reportid
1863018732 break;
1863118733 }
18632- case 1599LLU: // copy-back deleter (reportid to FindFn)
18734+ case 1611LLU: // copy-back deleter (reportid to FindFn)
1863318735 {
1863418736 // copy mutable arguments back from call to reportid
18635- label = 1570LLU; // continue to roll stack
18737+ label = 1582LLU; // continue to roll stack
1863618738 break;
1863718739 }
18638- case 1600LLU: // return from reportid to FindFn
18740+ case 1612LLU: // return from reportid to FindFn
1863918741 {
1864018742 // copy mutable arguments back from call to reportid
1864118743 fprintf(stderr, "%s", " not defined\n");
1864218744 {
18643- label = 1570LLU; // throw: begin to unroll stack
18745+ label = 1582LLU; // throw: begin to unroll stack
1864418746 break;
1864518747 }
1864618748
18647- label = 1596LLU; // alternative complete
18749+ label = 1608LLU; // alternative complete
1864818750 break;
1864918751 }
18650- case 1596LLU: // completed if-then-else
18752+ case 1608LLU: // completed if-then-else
1865118753 {
18652- label = 1602LLU; // skip deleter
18754+ label = 1614LLU; // skip deleter
1865318755 break;
1865418756 }
18655- case 1601LLU: // deleter
18757+ case 1613LLU: // deleter
1865618758 {
1865718759 // throw from FindFn
1865818760 if(!stack[base + 0])
1865918761 {
18660- label = 1570LLU; // skip, variable already deleted/unscoped
18762+ label = 1582LLU; // skip, variable already deleted/unscoped
1866118763 break;
1866218764 }
1866318765
@@ -18666,7 +18768,7 @@
1866618768 newstack[0] = (uint64_t)stack; // backup stack location
1866718769 newstack[1] = 1234567890;
1866818770 newstack[2] = base;
18669- newstack[3] = 1603LLU;
18771+ newstack[3] = 1615LLU;
1867018772 stack = newstack;
1867118773 // set stack-base & callee-address
1867218774 base = 4/*deloffset*/;
@@ -18673,16 +18775,16 @@
1867318775 label = 1420LLU; // ~fndef
1867418776 break;
1867518777 }
18676- case 1603LLU: // return from ~fndef to FindFn
18778+ case 1615LLU: // return from ~fndef to FindFn
1867718779 {
1867818780 stack = (uint64_t *)stack[0];
1867918781 // releasing toplevel container
1868018782 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1868118783
18682- label = 1570LLU; // continue unrolling stack, delete next variable
18784+ label = 1582LLU; // continue unrolling stack, delete next variable
1868318785 break;
1868418786 }
18685- case 1602LLU: // skipped deleter
18787+ case 1614LLU: // skipped deleter
1868618788 {
1868718789 INIT(&stack[base + 0], &stack[base + 5]/*copy*/);
1868818790 // return from FindFn
@@ -18690,37 +18792,37 @@
1869018792 base = stack[base - 2];
1869118793 break;
1869218794 }
18693- case 1605LLU: // function existsfn failed
18795+ case 1617LLU: // function existsfn failed
1869418796 {
1869518797 label = stack[base - 3];
1869618798 base = stack[base - 2];
1869718799 break;
1869818800 }
18699- case 1604LLU: // existsfn
18801+ case 1616LLU: // existsfn
1870018802 {
1870118803 //#define res0 0
1870218804 //#define arg0 1
1870318805 //#define arg1 2
18704- label = 1607LLU; // skip deleter
18806+ label = 1619LLU; // skip deleter
1870518807 break;
1870618808 }
18707- case 1606LLU: // deleter
18809+ case 1618LLU: // deleter
1870818810 {
1870918811 // throw from existsfn
1871018812 if(!stack[base + 3])
1871118813 {
18712- label = 1605LLU; // skip, variable already deleted/unscoped
18814+ label = 1617LLU; // skip, variable already deleted/unscoped
1871318815 break;
1871418816 }
18715- label = 1605LLU; // continue unrolling stack, delete next variable
18817+ label = 1617LLU; // continue unrolling stack, delete next variable
1871618818 break;
1871718819 }
18718- case 1607LLU: // skipped deleter
18820+ case 1619LLU: // skipped deleter
1871918821 {
1872018822 // call reservedfn from existsfn
18721- stack[base + 4LLU] = 1608LLU/*throw to this address*/;
18823+ stack[base + 4LLU] = 1620LLU/*throw to this address*/;
1872218824 stack[base + 5LLU] = base;
18723- stack[base + 6LLU] = 1609LLU;
18825+ stack[base + 6LLU] = 1621LLU;
1872418826 // arguments for call to reservedfn
1872518827 stack[base + 8LLU] = stack[base + 2]/*id*/;
1872618828 // set stack-base & callee-address
@@ -18728,26 +18830,26 @@
1872818830 label = 1501LLU; // reservedfn
1872918831 break;
1873018832 }
18731- case 1608LLU: // copy-back deleter (reservedfn to existsfn)
18833+ case 1620LLU: // copy-back deleter (reservedfn to existsfn)
1873218834 {
1873318835 // copy mutable arguments back from call to reservedfn
18734- label = 1605LLU; // continue to roll stack
18836+ label = 1617LLU; // continue to roll stack
1873518837 break;
1873618838 }
18737- case 1609LLU: // return from reservedfn to existsfn
18839+ case 1621LLU: // return from reservedfn to existsfn
1873818840 {
1873918841 // copy mutable arguments back from call to reservedfn
1874018842 // copy back results provided by call to reservedfn
1874118843 stack[base + 3] = stack[base + 7LLU];
1874218844 flippedassign(stack[base + 1]/*fndefs*/, &stack[base + 4]);
18743- label = 1610LLU; // start to repeat
18845+ label = 1622LLU; // start to repeat
1874418846 break;
1874518847 }
18746- case 1610LLU: // repeat from here
18848+ case 1622LLU: // repeat from here
1874718849 {
1874818850 if(!stack[base + 4])
1874918851 {
18750- label = 1611LLU; // break loop
18852+ label = 1623LLU; // break loop
1875118853 break;
1875218854 }
1875318855
@@ -18757,19 +18859,19 @@
1875718859 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1875818860 if(!stack[base + 3]/*found*/)
1875918861 {
18760- label = 1613LLU; // jump to alternative
18862+ label = 1625LLU; // jump to alternative
1876118863 break;
1876218864 }
1876318865
1876418866 // consequent
18765- label = 1614LLU; // consequent complete
18867+ label = 1626LLU; // consequent complete
1876618868 break;
1876718869 }
18768- case 1613LLU: // alternative
18870+ case 1625LLU: // alternative
1876918871 {
1877018872 if(/*fndef*/0 != ((uint64_t *)(stack[base + 5]/*fndef*/))[0])
1877118873 {
18772- label = 1616LLU; // jump to alternative
18874+ label = 1628LLU; // jump to alternative
1877318875 break;
1877418876 }
1877518877
@@ -18783,27 +18885,27 @@
1878318885 /*IO*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][7]/*IO*/;
1878418886
1878518887 // case
18786- label = 1619LLU; // skip deleter
18888+ label = 1631LLU; // skip deleter
1878718889 break;
1878818890 }
18789- case 1618LLU: // deleter
18891+ case 1630LLU: // deleter
1879018892 {
1879118893 // throw from existsfn
1879218894 if(!stack[base + 15])
1879318895 {
18794- label = 1617LLU; // skip, variable already deleted/unscoped
18896+ label = 1629LLU; // skip, variable already deleted/unscoped
1879518897 break;
1879618898 }
18797- label = 1617LLU; // continue unrolling stack, delete next variable
18899+ label = 1629LLU; // continue unrolling stack, delete next variable
1879818900 break;
1879918901 }
18800- case 1619LLU: // skipped deleter
18902+ case 1631LLU: // skipped deleter
1880118903 {
1880218904 stack[base + 15] = 0;
1880318905 // call equ from existsfn
18804- stack[base + 16LLU] = 1620LLU/*throw to this address*/;
18906+ stack[base + 16LLU] = 1632LLU/*throw to this address*/;
1880518907 stack[base + 17LLU] = base;
18806- stack[base + 18LLU] = 1621LLU;
18908+ stack[base + 18LLU] = 1633LLU;
1880718909 // arguments for call to equ
1880818910 stack[base + 20LLU] = stack[base + 2]/*id*/;
1880918911 stack[base + 21LLU] = stack[base + 11]/*defid*/;
@@ -18812,13 +18914,13 @@
1881218914 label = 18446744073709551600LLU; // equ
1881318915 break;
1881418916 }
18815- case 1620LLU: // copy-back deleter (equ to existsfn)
18917+ case 1632LLU: // copy-back deleter (equ to existsfn)
1881618918 {
1881718919 // copy mutable arguments back from call to equ
18818- label = 1618LLU; // continue to roll stack
18920+ label = 1630LLU; // continue to roll stack
1881918921 break;
1882018922 }
18821- case 1621LLU: // return from equ to existsfn
18923+ case 1633LLU: // return from equ to existsfn
1882218924 {
1882318925 // copy mutable arguments back from call to equ
1882418926 // copy back results provided by call to equ
@@ -18825,21 +18927,21 @@
1882518927 stack[base + 15] = stack[base + 19LLU];
1882618928 if(!stack[base + 15]/*isequal*/)
1882718929 {
18828- label = 1622LLU; // jump to alternative
18930+ label = 1634LLU; // jump to alternative
1882918931 break;
1883018932 }
1883118933
1883218934 // consequent
1883318935 stack[base + 3]/*found*/ = 1;
18834- label = 1623LLU; // consequent complete
18936+ label = 1635LLU; // consequent complete
1883518937 break;
1883618938 }
18837- case 1622LLU: // alternative
18939+ case 1634LLU: // alternative
1883818940 {
18839- label = 1623LLU; // alternative complete
18941+ label = 1635LLU; // alternative complete
1884018942 break;
1884118943 }
18842- case 1623LLU: // completed if-then-else
18944+ case 1635LLU: // completed if-then-else
1884318945 {
1884418946 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1884518947 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18849,10 +18951,10 @@
1884918951 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1885018952 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1885118953 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18852- label = 1615LLU; // case complete
18954+ label = 1627LLU; // case complete
1885318955 break;
1885418956 }
18855- case 1617LLU: // copy-back deleter (switch)
18957+ case 1629LLU: // copy-back deleter (switch)
1885618958 {
1885718959 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1885818960 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18862,48 +18964,48 @@
1886218964 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1886318965 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1886418966 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18865- label = 1612LLU; // continue to unroll stack
18967+ label = 1624LLU; // continue to unroll stack
1886618968 break;
1886718969 }
18868- case 1616LLU: // try next case
18970+ case 1628LLU: // try next case
1886918971 {
1887018972 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1887118973 exit(-1);
1887218974 }
18873- case 1615LLU: // completed switch
18975+ case 1627LLU: // completed switch
1887418976 {
18875- label = 1614LLU; // alternative complete
18977+ label = 1626LLU; // alternative complete
1887618978 break;
1887718979 }
18878- case 1614LLU: // completed if-then-else
18980+ case 1626LLU: // completed if-then-else
1887918981 {
1888018982 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18881- label = 1610LLU; // repeat
18983+ label = 1622LLU; // repeat
1888218984 break;
1888318985 }
18884- case 1612LLU: // copy-back deleter for while next
18986+ case 1624LLU: // copy-back deleter for while next
1888518987 {
1888618988 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18887- label = 1606LLU; // continue to unroll stack
18989+ label = 1618LLU; // continue to unroll stack
1888818990 break;
1888918991 }
18890- case 1611LLU: // loop finished
18992+ case 1623LLU: // loop finished
1889118993 {
18892- label = 1625LLU; // skip deleter
18994+ label = 1637LLU; // skip deleter
1889318995 break;
1889418996 }
18895- case 1624LLU: // deleter
18997+ case 1636LLU: // deleter
1889618998 {
1889718999 // throw from existsfn
1889819000 if(!stack[base + 0])
1889919001 {
18900- label = 1606LLU; // skip, variable already deleted/unscoped
19002+ label = 1618LLU; // skip, variable already deleted/unscoped
1890119003 break;
1890219004 }
18903- label = 1606LLU; // continue unrolling stack, delete next variable
19005+ label = 1618LLU; // continue unrolling stack, delete next variable
1890419006 break;
1890519007 }
18906- case 1625LLU: // skipped deleter
19008+ case 1637LLU: // skipped deleter
1890719009 {
1890819010 stack[base + 0] = stack[base + 3]/*found*/;
1890919011 // return from existsfn
@@ -18911,7 +19013,7 @@
1891119013 base = stack[base - 2];
1891219014 break;
1891319015 }
18914- case 1626LLU: // ~idfndef
19016+ case 1638LLU: // ~idfndef
1891519017 {
1891619018 if(stack[base + 0]/*variant-nr*/ >= 1)
1891719019 {
@@ -18918,10 +19020,10 @@
1891819020 fprintf(stderr, "in ~idfndef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1891919021 exit(-1);
1892019022 }
18921- label = 1626LLU + 1LLU + stack[base + 0]/*variant-nr*/;
19023+ label = 1638LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1892219024 break;
1892319025 }
18924- case 1626LLU + 1LLU + 0LLU: // ~idfndef.idfndef
19026+ case 1638LLU + 1LLU + 0LLU: // ~idfndef.idfndef
1892519027 {
1892619028 // release element id
1892719029 // release element fndef
@@ -18932,7 +19034,7 @@
1893219034 newstack[0] = (uint64_t)stack; // backup stack location
1893319035 newstack[1] = 1234567890;
1893419036 newstack[2] = base;
18935- newstack[3] = 1628LLU;
19037+ newstack[3] = 1640LLU;
1893619038 stack = newstack;
1893719039 // set stack-base & callee-address
1893819040 base = 4/*deloffset*/;
@@ -18939,7 +19041,7 @@
1893919041 label = 1420LLU; // ~fndef
1894019042 break;
1894119043 }
18942- case 1628LLU: // return from ~fndef to idfndef
19044+ case 1640LLU: // return from ~fndef to idfndef
1894319045 {
1894419046 stack = (uint64_t *)stack[0];
1894519047 // releasing toplevel container
@@ -18951,43 +19053,43 @@
1895119053 base = stack[base - 2];
1895219054 break;
1895319055 }
18954- case 1630LLU: // function existsidfn failed
19056+ case 1642LLU: // function existsidfn failed
1895519057 {
1895619058 label = stack[base - 3];
1895719059 base = stack[base - 2];
1895819060 break;
1895919061 }
18960- case 1629LLU: // existsidfn
19062+ case 1641LLU: // existsidfn
1896119063 {
1896219064 //#define res0 0
1896319065 //#define arg0 1
1896419066 //#define arg1 2
18965- label = 1632LLU; // skip deleter
19067+ label = 1644LLU; // skip deleter
1896619068 break;
1896719069 }
18968- case 1631LLU: // deleter
19070+ case 1643LLU: // deleter
1896919071 {
1897019072 // throw from existsidfn
1897119073 if(!stack[base + 3])
1897219074 {
18973- label = 1630LLU; // skip, variable already deleted/unscoped
19075+ label = 1642LLU; // skip, variable already deleted/unscoped
1897419076 break;
1897519077 }
18976- label = 1630LLU; // continue unrolling stack, delete next variable
19078+ label = 1642LLU; // continue unrolling stack, delete next variable
1897719079 break;
1897819080 }
18979- case 1632LLU: // skipped deleter
19081+ case 1644LLU: // skipped deleter
1898019082 {
1898119083 stack[base + 3] = 0;
1898219084 flippedassign(stack[base + 1]/*idfndefs*/, &stack[base + 4]);
18983- label = 1633LLU; // start to repeat
19085+ label = 1645LLU; // start to repeat
1898419086 break;
1898519087 }
18986- case 1633LLU: // repeat from here
19088+ case 1645LLU: // repeat from here
1898719089 {
1898819090 if(!stack[base + 4])
1898919091 {
18990- label = 1634LLU; // break loop
19092+ label = 1646LLU; // break loop
1899119093 break;
1899219094 }
1899319095
@@ -18997,19 +19099,19 @@
1899719099 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1899819100 if(!stack[base + 3]/*found*/)
1899919101 {
19000- label = 1636LLU; // jump to alternative
19102+ label = 1648LLU; // jump to alternative
1900119103 break;
1900219104 }
1900319105
1900419106 // consequent
19005- label = 1637LLU; // consequent complete
19107+ label = 1649LLU; // consequent complete
1900619108 break;
1900719109 }
19008- case 1636LLU: // alternative
19110+ case 1648LLU: // alternative
1900919111 {
1901019112 if(/*idfndef*/0 != ((uint64_t *)(stack[base + 5]/*idfndef*/))[0])
1901119113 {
19012- label = 1639LLU; // jump to alternative
19114+ label = 1651LLU; // jump to alternative
1901319115 break;
1901419116 }
1901519117
@@ -19017,27 +19119,27 @@
1901719119 /*fndef*/stack[base + 8] = ((uint64_t **)(stack[base + 5]/*idfndef*/))[1][1]/*fndef*/;
1901819120
1901919121 // case
19020- label = 1642LLU; // skip deleter
19122+ label = 1654LLU; // skip deleter
1902119123 break;
1902219124 }
19023- case 1641LLU: // deleter
19125+ case 1653LLU: // deleter
1902419126 {
1902519127 // throw from existsidfn
1902619128 if(!stack[base + 9])
1902719129 {
19028- label = 1640LLU; // skip, variable already deleted/unscoped
19130+ label = 1652LLU; // skip, variable already deleted/unscoped
1902919131 break;
1903019132 }
19031- label = 1640LLU; // continue unrolling stack, delete next variable
19133+ label = 1652LLU; // continue unrolling stack, delete next variable
1903219134 break;
1903319135 }
19034- case 1642LLU: // skipped deleter
19136+ case 1654LLU: // skipped deleter
1903519137 {
1903619138 stack[base + 9] = 0;
1903719139 // call equ from existsidfn
19038- stack[base + 10LLU] = 1643LLU/*throw to this address*/;
19140+ stack[base + 10LLU] = 1655LLU/*throw to this address*/;
1903919141 stack[base + 11LLU] = base;
19040- stack[base + 12LLU] = 1644LLU;
19142+ stack[base + 12LLU] = 1656LLU;
1904119143 // arguments for call to equ
1904219144 stack[base + 14LLU] = stack[base + 7]/*id*/;
1904319145 stack[base + 15LLU] = stack[base + 2]/*searchid*/;
@@ -19046,13 +19148,13 @@
1904619148 label = 18446744073709551600LLU; // equ
1904719149 break;
1904819150 }
19049- case 1643LLU: // copy-back deleter (equ to existsidfn)
19151+ case 1655LLU: // copy-back deleter (equ to existsidfn)
1905019152 {
1905119153 // copy mutable arguments back from call to equ
19052- label = 1641LLU; // continue to roll stack
19154+ label = 1653LLU; // continue to roll stack
1905319155 break;
1905419156 }
19055- case 1644LLU: // return from equ to existsidfn
19157+ case 1656LLU: // return from equ to existsidfn
1905619158 {
1905719159 // copy mutable arguments back from call to equ
1905819160 // copy back results provided by call to equ
@@ -19059,73 +19161,73 @@
1905919161 stack[base + 9] = stack[base + 13LLU];
1906019162 if(!stack[base + 9]/*isequal*/)
1906119163 {
19062- label = 1645LLU; // jump to alternative
19164+ label = 1657LLU; // jump to alternative
1906319165 break;
1906419166 }
1906519167
1906619168 // consequent
1906719169 stack[base + 3]/*found*/ = 1;
19068- label = 1646LLU; // consequent complete
19170+ label = 1658LLU; // consequent complete
1906919171 break;
1907019172 }
19071- case 1645LLU: // alternative
19173+ case 1657LLU: // alternative
1907219174 {
19073- label = 1646LLU; // alternative complete
19175+ label = 1658LLU; // alternative complete
1907419176 break;
1907519177 }
19076- case 1646LLU: // completed if-then-else
19178+ case 1658LLU: // completed if-then-else
1907719179 {
1907819180 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1907919181 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
19080- label = 1638LLU; // case complete
19182+ label = 1650LLU; // case complete
1908119183 break;
1908219184 }
19083- case 1640LLU: // copy-back deleter (switch)
19185+ case 1652LLU: // copy-back deleter (switch)
1908419186 {
1908519187 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1908619188 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
19087- label = 1635LLU; // continue to unroll stack
19189+ label = 1647LLU; // continue to unroll stack
1908819190 break;
1908919191 }
19090- case 1639LLU: // try next case
19192+ case 1651LLU: // try next case
1909119193 {
1909219194 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1909319195 exit(-1);
1909419196 }
19095- case 1638LLU: // completed switch
19197+ case 1650LLU: // completed switch
1909619198 {
19097- label = 1637LLU; // alternative complete
19199+ label = 1649LLU; // alternative complete
1909819200 break;
1909919201 }
19100- case 1637LLU: // completed if-then-else
19202+ case 1649LLU: // completed if-then-else
1910119203 {
1910219204 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
19103- label = 1633LLU; // repeat
19205+ label = 1645LLU; // repeat
1910419206 break;
1910519207 }
19106- case 1635LLU: // copy-back deleter for while next
19208+ case 1647LLU: // copy-back deleter for while next
1910719209 {
1910819210 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
19109- label = 1631LLU; // continue to unroll stack
19211+ label = 1643LLU; // continue to unroll stack
1911019212 break;
1911119213 }
19112- case 1634LLU: // loop finished
19214+ case 1646LLU: // loop finished
1911319215 {
19114- label = 1648LLU; // skip deleter
19216+ label = 1660LLU; // skip deleter
1911519217 break;
1911619218 }
19117- case 1647LLU: // deleter
19219+ case 1659LLU: // deleter
1911819220 {
1911919221 // throw from existsidfn
1912019222 if(!stack[base + 0])
1912119223 {
19122- label = 1631LLU; // skip, variable already deleted/unscoped
19224+ label = 1643LLU; // skip, variable already deleted/unscoped
1912319225 break;
1912419226 }
19125- label = 1631LLU; // continue unrolling stack, delete next variable
19227+ label = 1643LLU; // continue unrolling stack, delete next variable
1912619228 break;
1912719229 }
19128- case 1648LLU: // skipped deleter
19230+ case 1660LLU: // skipped deleter
1912919231 {
1913019232 stack[base + 0] = stack[base + 3]/*found*/;
1913119233 // return from existsidfn
@@ -19133,21 +19235,21 @@
1913319235 base = stack[base - 2];
1913419236 break;
1913519237 }
19136- case 1650LLU: // function emitcase failed
19238+ case 1662LLU: // function emitcase failed
1913719239 {
1913819240 label = stack[base - 3];
1913919241 base = stack[base - 2];
1914019242 break;
1914119243 }
19142- case 1649LLU: // emitcase
19244+ case 1661LLU: // emitcase
1914319245 {
1914419246 //#define arg0 0
1914519247 //#define arg1 1
1914619248 printf("%s", "\n case -");
1914719249 // call printnr from emitcase
19148- stack[base + 2LLU] = 1651LLU/*throw to this address*/;
19250+ stack[base + 2LLU] = 1663LLU/*throw to this address*/;
1914919251 stack[base + 3LLU] = base;
19150- stack[base + 4LLU] = 1652LLU;
19252+ stack[base + 4LLU] = 1664LLU;
1915119253 // arguments for call to printnr
1915219254 stack[base + 5LLU] = stack[base + 0]/*label*/;
1915319255 // set stack-base & callee-address
@@ -19155,20 +19257,20 @@
1915519257 label = 18446744073709551590LLU; // printnr
1915619258 break;
1915719259 }
19158- case 1651LLU: // copy-back deleter (printnr to emitcase)
19260+ case 1663LLU: // copy-back deleter (printnr to emitcase)
1915919261 {
1916019262 // copy mutable arguments back from call to printnr
19161- label = 1650LLU; // continue to roll stack
19263+ label = 1662LLU; // continue to roll stack
1916219264 break;
1916319265 }
19164- case 1652LLU: // return from printnr to emitcase
19266+ case 1664LLU: // return from printnr to emitcase
1916519267 {
1916619268 // copy mutable arguments back from call to printnr
1916719269 printf("%s", ": // ");
1916819270 // call printid from emitcase
19169- stack[base + 2LLU] = 1653LLU/*throw to this address*/;
19271+ stack[base + 2LLU] = 1665LLU/*throw to this address*/;
1917019272 stack[base + 3LLU] = base;
19171- stack[base + 4LLU] = 1654LLU;
19273+ stack[base + 4LLU] = 1666LLU;
1917219274 // arguments for call to printid
1917319275 stack[base + 5LLU] = stack[base + 1]/*defid*/;
1917419276 // set stack-base & callee-address
@@ -19176,13 +19278,13 @@
1917619278 label = 18446744073709551587LLU; // printid
1917719279 break;
1917819280 }
19179- case 1653LLU: // copy-back deleter (printid to emitcase)
19281+ case 1665LLU: // copy-back deleter (printid to emitcase)
1918019282 {
1918119283 // copy mutable arguments back from call to printid
19182- label = 1650LLU; // continue to roll stack
19284+ label = 1662LLU; // continue to roll stack
1918319285 break;
1918419286 }
19185- case 1654LLU: // return from printid to emitcase
19287+ case 1666LLU: // return from printid to emitcase
1918619288 {
1918719289 // copy mutable arguments back from call to printid
1918819290 printf("%s", "\n {");
@@ -19191,13 +19293,13 @@
1919119293 base = stack[base - 2];
1919219294 break;
1919319295 }
19194- case 1656LLU: // function emitreturn failed
19296+ case 1668LLU: // function emitreturn failed
1919519297 {
1919619298 label = stack[base - 3];
1919719299 base = stack[base - 2];
1919819300 break;
1919919301 }
19200- case 1655LLU: // emitreturn
19302+ case 1667LLU: // emitreturn
1920119303 {
1920219304 printf("%s", "\n");
1920319305 printf("%s", "\n label = stack[base - 1];");
@@ -19209,13 +19311,13 @@
1920919311 base = stack[base - 2];
1921019312 break;
1921119313 }
19212- case 1658LLU: // function EMITTHROW failed
19314+ case 1670LLU: // function EMITTHROW failed
1921319315 {
1921419316 label = stack[base - 3];
1921519317 base = stack[base - 2];
1921619318 break;
1921719319 }
19218- case 1657LLU: // EMITTHROW
19320+ case 1669LLU: // EMITTHROW
1921919321 {
1922019322 printf("%s", "\n label = stack[base - 3];");
1922119323 printf("%s", "\n base = stack[base - 2];");
@@ -19226,38 +19328,38 @@
1922619328 base = stack[base - 2];
1922719329 break;
1922819330 }
19229- case 1660LLU: // function isparam failed
19331+ case 1672LLU: // function isparam failed
1923019332 {
1923119333 label = stack[base - 3];
1923219334 base = stack[base - 2];
1923319335 break;
1923419336 }
19235- case 1659LLU: // isparam
19337+ case 1671LLU: // isparam
1923619338 {
1923719339 //#define res0 0
1923819340 //#define arg0 1
1923919341 //#define arg1 2
1924019342 //#define arg2 3
19241- label = 1662LLU; // skip deleter
19343+ label = 1674LLU; // skip deleter
1924219344 break;
1924319345 }
19244- case 1661LLU: // deleter
19346+ case 1673LLU: // deleter
1924519347 {
1924619348 // throw from isparam
1924719349 if(!stack[base + 4])
1924819350 {
19249- label = 1660LLU; // skip, variable already deleted/unscoped
19351+ label = 1672LLU; // skip, variable already deleted/unscoped
1925019352 break;
1925119353 }
19252- label = 1660LLU; // continue unrolling stack, delete next variable
19354+ label = 1672LLU; // continue unrolling stack, delete next variable
1925319355 break;
1925419356 }
19255- case 1662LLU: // skipped deleter
19357+ case 1674LLU: // skipped deleter
1925619358 {
1925719359 // call add from isparam
19258- stack[base + 5LLU] = 1663LLU/*throw to this address*/;
19360+ stack[base + 5LLU] = 1675LLU/*throw to this address*/;
1925919361 stack[base + 6LLU] = base;
19260- stack[base + 7LLU] = 1664LLU;
19362+ stack[base + 7LLU] = 1676LLU;
1926119363 // arguments for call to add
1926219364 stack[base + 9LLU] = stack[base + 1]/*rescount*/;
1926319365 stack[base + 10LLU] = stack[base + 2]/*argcount*/;
@@ -19266,21 +19368,21 @@
1926619368 label = 18446744073709551605LLU; // add
1926719369 break;
1926819370 }
19269- case 1663LLU: // copy-back deleter (add to isparam)
19371+ case 1675LLU: // copy-back deleter (add to isparam)
1927019372 {
1927119373 // copy mutable arguments back from call to add
19272- label = 1660LLU; // continue to roll stack
19374+ label = 1672LLU; // continue to roll stack
1927319375 break;
1927419376 }
19275- case 1664LLU: // return from add to isparam
19377+ case 1676LLU: // return from add to isparam
1927619378 {
1927719379 // copy mutable arguments back from call to add
1927819380 // copy back results provided by call to add
1927919381 stack[base + 4] = stack[base + 8LLU];
1928019382 // call lss from isparam
19281- stack[base + 5LLU] = 1665LLU/*throw to this address*/;
19383+ stack[base + 5LLU] = 1677LLU/*throw to this address*/;
1928219384 stack[base + 6LLU] = base;
19283- stack[base + 7LLU] = 1666LLU;
19385+ stack[base + 7LLU] = 1678LLU;
1928419386 // arguments for call to lss
1928519387 stack[base + 9LLU] = stack[base + 3]/*index*/;
1928619388 stack[base + 10LLU] = stack[base + 4]/*varbase*/;
@@ -19289,13 +19391,13 @@
1928919391 label = 18446744073709551597LLU; // lss
1929019392 break;
1929119393 }
19292- case 1665LLU: // copy-back deleter (lss to isparam)
19394+ case 1677LLU: // copy-back deleter (lss to isparam)
1929319395 {
1929419396 // copy mutable arguments back from call to lss
19295- label = 1661LLU; // continue to roll stack
19397+ label = 1673LLU; // continue to roll stack
1929619398 break;
1929719399 }
19298- case 1666LLU: // return from lss to isparam
19400+ case 1678LLU: // return from lss to isparam
1929919401 {
1930019402 // copy mutable arguments back from call to lss
1930119403 // copy back results provided by call to lss
@@ -19305,13 +19407,13 @@
1930519407 base = stack[base - 2];
1930619408 break;
1930719409 }
19308- case 1668LLU: // function REGISTER failed
19410+ case 1680LLU: // function REGISTER failed
1930919411 {
1931019412 label = stack[base - 3];
1931119413 base = stack[base - 2];
1931219414 break;
1931319415 }
19314- case 1667LLU: // REGISTER
19416+ case 1679LLU: // REGISTER
1931519417 {
1931619418 //#define arg0 0
1931719419 //#define arg1 1
@@ -19321,26 +19423,26 @@
1932119423 //#define arg5 5
1932219424 //#define arg6 6
1932319425 //#define arg7 7
19324- label = 1670LLU; // skip deleter
19426+ label = 1682LLU; // skip deleter
1932519427 break;
1932619428 }
19327- case 1669LLU: // deleter
19429+ case 1681LLU: // deleter
1932819430 {
1932919431 // throw from REGISTER
1933019432 if(!stack[base + 8])
1933119433 {
19332- label = 1668LLU; // skip, variable already deleted/unscoped
19434+ label = 1680LLU; // skip, variable already deleted/unscoped
1933319435 break;
1933419436 }
1933519437 // delete list
19336- label = 1671LLU; // start to repeat
19438+ label = 1683LLU; // start to repeat
1933719439 break;
1933819440 }
19339- case 1671LLU: // repeat from here
19441+ case 1683LLU: // repeat from here
1934019442 {
1934119443 if(!stack[base + 8])
1934219444 {
19343- label = 1672LLU; // break loop
19445+ label = 1684LLU; // break loop
1934419446 break;
1934519447 }
1934619448
@@ -19351,7 +19453,7 @@
1935119453 newstack[0] = (uint64_t)stack; // backup stack location
1935219454 newstack[1] = 1234567890;
1935319455 newstack[2] = base;
19354- newstack[3] = 1673LLU;
19456+ newstack[3] = 1685LLU;
1935519457 stack = newstack;
1935619458 // set stack-base & callee-address
1935719459 base = 4/*deloffset*/;
@@ -19358,7 +19460,7 @@
1935819460 label = 417LLU; // ~result
1935919461 break;
1936019462 }
19361- case 1673LLU: // return from ~result to REGISTER
19463+ case 1685LLU: // return from ~result to REGISTER
1936219464 {
1936319465 stack = (uint64_t *)stack[0];
1936419466 // releasing toplevel container
@@ -19369,40 +19471,40 @@
1936919471 stack[base + 8] = (uint64_t)list->next;
1937019472 Free(1, sizeof(struct listnode), list);
1937119473 }
19372- label = 1671LLU; // repeat
19474+ label = 1683LLU; // repeat
1937319475 break;
1937419476 }
19375- case 1672LLU: // loop finished
19477+ case 1684LLU: // loop finished
1937619478 {
19377- label = 1668LLU; // continue unrolling stack, delete next variable
19479+ label = 1680LLU; // continue unrolling stack, delete next variable
1937819480 break;
1937919481 }
19380- case 1670LLU: // skipped deleter
19482+ case 1682LLU: // skipped deleter
1938119483 {
1938219484 stack[base + 8] = 0;
1938319485 stack[base + 9] = stack[base + 0]/*rescount*/;
1938419486
19385- label = 1674LLU; // start to repeat
19487+ label = 1686LLU; // start to repeat
1938619488 break;
1938719489 }
19388- case 1674LLU: // repeat from here
19490+ case 1686LLU: // repeat from here
1938919491 {
1939019492 if(!stack[base + 9]--)
1939119493 {
19392- label = 1675LLU; // break loop
19494+ label = 1687LLU; // break loop
1939319495 break;
1939419496 }
1939519497
1939619498 // loop body
19397- label = 1677LLU; // skip deleter
19499+ label = 1689LLU; // skip deleter
1939819500 break;
1939919501 }
19400- case 1676LLU: // deleter
19502+ case 1688LLU: // deleter
1940119503 {
1940219504 // throw from REGISTER
1940319505 if(!stack[base + 10])
1940419506 {
19405- label = 1669LLU; // skip, variable already deleted/unscoped
19507+ label = 1681LLU; // skip, variable already deleted/unscoped
1940619508 break;
1940719509 }
1940819510
@@ -19411,7 +19513,7 @@
1941119513 newstack[0] = (uint64_t)stack; // backup stack location
1941219514 newstack[1] = 1234567890;
1941319515 newstack[2] = base;
19414- newstack[3] = 1678LLU;
19516+ newstack[3] = 1690LLU;
1941519517 stack = newstack;
1941619518 // set stack-base & callee-address
1941719519 base = 4/*deloffset*/;
@@ -19418,21 +19520,21 @@
1941819520 label = 310LLU; // ~type
1941919521 break;
1942019522 }
19421- case 1678LLU: // return from ~type to REGISTER
19523+ case 1690LLU: // return from ~type to REGISTER
1942219524 {
1942319525 stack = (uint64_t *)stack[0];
1942419526 // releasing toplevel container
1942519527 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 10] - sizeof(uint64_t) * 4));
1942619528
19427- label = 1669LLU; // continue unrolling stack, delete next variable
19529+ label = 1681LLU; // continue unrolling stack, delete next variable
1942819530 break;
1942919531 }
19430- case 1677LLU: // skipped deleter
19532+ case 1689LLU: // skipped deleter
1943119533 {
1943219534 // call mktypedata from REGISTER
19433- stack[base + 11LLU] = 1679LLU/*throw to this address*/;
19535+ stack[base + 11LLU] = 1691LLU/*throw to this address*/;
1943419536 stack[base + 12LLU] = base;
19435- stack[base + 13LLU] = 1680LLU;
19537+ stack[base + 13LLU] = 1692LLU;
1943619538 // arguments for call to mktypedata
1943719539 stack[base + 15LLU] = 881834713755418624LLU;
1943819540 // set stack-base & callee-address
@@ -19440,43 +19542,43 @@
1944019542 label = 314LLU; // mktypedata
1944119543 break;
1944219544 }
19443- case 1679LLU: // copy-back deleter (mktypedata to REGISTER)
19545+ case 1691LLU: // copy-back deleter (mktypedata to REGISTER)
1944419546 {
1944519547 // copy mutable arguments back from call to mktypedata
19446- label = 1669LLU; // continue to roll stack
19548+ label = 1681LLU; // continue to roll stack
1944719549 break;
1944819550 }
19449- case 1680LLU: // return from mktypedata to REGISTER
19551+ case 1692LLU: // return from mktypedata to REGISTER
1945019552 {
1945119553 // copy mutable arguments back from call to mktypedata
1945219554 // copy back results provided by call to mktypedata
1945319555 stack[base + 10] = stack[base + 14LLU];
19454- label = 1682LLU; // skip deleter
19556+ label = 1694LLU; // skip deleter
1945519557 break;
1945619558 }
19457- case 1681LLU: // deleter
19559+ case 1693LLU: // deleter
1945819560 {
1945919561 // throw from REGISTER
1946019562 if(!stack[base + 11])
1946119563 {
19462- label = 1676LLU; // skip, variable already deleted/unscoped
19564+ label = 1688LLU; // skip, variable already deleted/unscoped
1946319565 break;
1946419566 }
19465- label = 1676LLU; // continue unrolling stack, delete next variable
19567+ label = 1688LLU; // continue unrolling stack, delete next variable
1946619568 break;
1946719569 }
19468- case 1682LLU: // skipped deleter
19570+ case 1694LLU: // skipped deleter
1946919571 {
1947019572 stack[base + 11] = 1;
19471- label = 1684LLU; // skip deleter
19573+ label = 1696LLU; // skip deleter
1947219574 break;
1947319575 }
19474- case 1683LLU: // deleter
19576+ case 1695LLU: // deleter
1947519577 {
1947619578 // throw from REGISTER
1947719579 if(!stack[base + 12])
1947819580 {
19479- label = 1681LLU; // skip, variable already deleted/unscoped
19581+ label = 1693LLU; // skip, variable already deleted/unscoped
1948019582 break;
1948119583 }
1948219584
@@ -19485,7 +19587,7 @@
1948519587 newstack[0] = (uint64_t)stack; // backup stack location
1948619588 newstack[1] = 1234567890;
1948719589 newstack[2] = base;
19488- newstack[3] = 1685LLU;
19590+ newstack[3] = 1697LLU;
1948919591 stack = newstack;
1949019592 // set stack-base & callee-address
1949119593 base = 4/*deloffset*/;
@@ -19492,21 +19594,21 @@
1949219594 label = 417LLU; // ~result
1949319595 break;
1949419596 }
19495- case 1685LLU: // return from ~result to REGISTER
19597+ case 1697LLU: // return from ~result to REGISTER
1949619598 {
1949719599 stack = (uint64_t *)stack[0];
1949819600 // releasing toplevel container
1949919601 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1950019602
19501- label = 1681LLU; // continue unrolling stack, delete next variable
19603+ label = 1693LLU; // continue unrolling stack, delete next variable
1950219604 break;
1950319605 }
19504- case 1684LLU: // skipped deleter
19606+ case 1696LLU: // skipped deleter
1950519607 {
1950619608 // construct result.result
1950719609 if(!(stack[base + 12] = construct(2)))
1950819610 {
19509- label = 1681LLU; // throw: begin to unroll stack
19611+ label = 1693LLU; // throw: begin to unroll stack
1951019612 break;
1951119613 }
1951219614
@@ -19527,31 +19629,31 @@
1952719629 /*fnrestypes*/stack[base + 8] = (uint64_t)list;
1952819630 MOVE(&list->data, &stack[base + 12]/*result*/);
1952919631 }
19530- label = 1674LLU; // repeat
19632+ label = 1686LLU; // repeat
1953119633 break;
1953219634 }
19533- case 1675LLU: // loop finished
19635+ case 1687LLU: // loop finished
1953419636 {
19535- label = 1687LLU; // skip deleter
19637+ label = 1699LLU; // skip deleter
1953619638 break;
1953719639 }
19538- case 1686LLU: // deleter
19640+ case 1698LLU: // deleter
1953919641 {
1954019642 // throw from REGISTER
1954119643 if(!stack[base + 10])
1954219644 {
19543- label = 1669LLU; // skip, variable already deleted/unscoped
19645+ label = 1681LLU; // skip, variable already deleted/unscoped
1954419646 break;
1954519647 }
1954619648 // delete list
19547- label = 1688LLU; // start to repeat
19649+ label = 1700LLU; // start to repeat
1954819650 break;
1954919651 }
19550- case 1688LLU: // repeat from here
19652+ case 1700LLU: // repeat from here
1955119653 {
1955219654 if(!stack[base + 10])
1955319655 {
19554- label = 1689LLU; // break loop
19656+ label = 1701LLU; // break loop
1955519657 break;
1955619658 }
1955719659
@@ -19562,7 +19664,7 @@
1956219664 newstack[0] = (uint64_t)stack; // backup stack location
1956319665 newstack[1] = 1234567890;
1956419666 newstack[2] = base;
19565- newstack[3] = 1690LLU;
19667+ newstack[3] = 1702LLU;
1956619668 stack = newstack;
1956719669 // set stack-base & callee-address
1956819670 base = 4/*deloffset*/;
@@ -19569,7 +19671,7 @@
1956919671 label = 440LLU; // ~param
1957019672 break;
1957119673 }
19572- case 1690LLU: // return from ~param to REGISTER
19674+ case 1702LLU: // return from ~param to REGISTER
1957319675 {
1957419676 stack = (uint64_t *)stack[0];
1957519677 // releasing toplevel container
@@ -19580,40 +19682,40 @@
1958019682 stack[base + 10] = (uint64_t)list->next;
1958119683 Free(1, sizeof(struct listnode), list);
1958219684 }
19583- label = 1688LLU; // repeat
19685+ label = 1700LLU; // repeat
1958419686 break;
1958519687 }
19586- case 1689LLU: // loop finished
19688+ case 1701LLU: // loop finished
1958719689 {
19588- label = 1669LLU; // continue unrolling stack, delete next variable
19690+ label = 1681LLU; // continue unrolling stack, delete next variable
1958919691 break;
1959019692 }
19591- case 1687LLU: // skipped deleter
19693+ case 1699LLU: // skipped deleter
1959219694 {
1959319695 stack[base + 10] = 0;
1959419696 stack[base + 11] = stack[base + 1]/*argcount*/;
1959519697
19596- label = 1691LLU; // start to repeat
19698+ label = 1703LLU; // start to repeat
1959719699 break;
1959819700 }
19599- case 1691LLU: // repeat from here
19701+ case 1703LLU: // repeat from here
1960019702 {
1960119703 if(!stack[base + 11]--)
1960219704 {
19603- label = 1692LLU; // break loop
19705+ label = 1704LLU; // break loop
1960419706 break;
1960519707 }
1960619708
1960719709 // loop body
19608- label = 1694LLU; // skip deleter
19710+ label = 1706LLU; // skip deleter
1960919711 break;
1961019712 }
19611- case 1693LLU: // deleter
19713+ case 1705LLU: // deleter
1961219714 {
1961319715 // throw from REGISTER
1961419716 if(!stack[base + 12])
1961519717 {
19616- label = 1686LLU; // skip, variable already deleted/unscoped
19718+ label = 1698LLU; // skip, variable already deleted/unscoped
1961719719 break;
1961819720 }
1961919721
@@ -19622,7 +19724,7 @@
1962219724 newstack[0] = (uint64_t)stack; // backup stack location
1962319725 newstack[1] = 1234567890;
1962419726 newstack[2] = base;
19625- newstack[3] = 1695LLU;
19727+ newstack[3] = 1707LLU;
1962619728 stack = newstack;
1962719729 // set stack-base & callee-address
1962819730 base = 4/*deloffset*/;
@@ -19629,21 +19731,21 @@
1962919731 label = 310LLU; // ~type
1963019732 break;
1963119733 }
19632- case 1695LLU: // return from ~type to REGISTER
19734+ case 1707LLU: // return from ~type to REGISTER
1963319735 {
1963419736 stack = (uint64_t *)stack[0];
1963519737 // releasing toplevel container
1963619738 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1963719739
19638- label = 1686LLU; // continue unrolling stack, delete next variable
19740+ label = 1698LLU; // continue unrolling stack, delete next variable
1963919741 break;
1964019742 }
19641- case 1694LLU: // skipped deleter
19743+ case 1706LLU: // skipped deleter
1964219744 {
1964319745 // call mktypedata from REGISTER
19644- stack[base + 13LLU] = 1696LLU/*throw to this address*/;
19746+ stack[base + 13LLU] = 1708LLU/*throw to this address*/;
1964519747 stack[base + 14LLU] = base;
19646- stack[base + 15LLU] = 1697LLU;
19748+ stack[base + 15LLU] = 1709LLU;
1964719749 // arguments for call to mktypedata
1964819750 stack[base + 17LLU] = 881834713755418624LLU;
1964919751 // set stack-base & callee-address
@@ -19651,37 +19753,37 @@
1965119753 label = 314LLU; // mktypedata
1965219754 break;
1965319755 }
19654- case 1696LLU: // copy-back deleter (mktypedata to REGISTER)
19756+ case 1708LLU: // copy-back deleter (mktypedata to REGISTER)
1965519757 {
1965619758 // copy mutable arguments back from call to mktypedata
19657- label = 1686LLU; // continue to roll stack
19759+ label = 1698LLU; // continue to roll stack
1965819760 break;
1965919761 }
19660- case 1697LLU: // return from mktypedata to REGISTER
19762+ case 1709LLU: // return from mktypedata to REGISTER
1966119763 {
1966219764 // copy mutable arguments back from call to mktypedata
1966319765 // copy back results provided by call to mktypedata
1966419766 stack[base + 12] = stack[base + 16LLU];
19665- label = 1699LLU; // skip deleter
19767+ label = 1711LLU; // skip deleter
1966619768 break;
1966719769 }
19668- case 1698LLU: // deleter
19770+ case 1710LLU: // deleter
1966919771 {
1967019772 // throw from REGISTER
1967119773 if(!stack[base + 13])
1967219774 {
19673- label = 1693LLU; // skip, variable already deleted/unscoped
19775+ label = 1705LLU; // skip, variable already deleted/unscoped
1967419776 break;
1967519777 }
19676- label = 1693LLU; // continue unrolling stack, delete next variable
19778+ label = 1705LLU; // continue unrolling stack, delete next variable
1967719779 break;
1967819780 }
19679- case 1699LLU: // skipped deleter
19781+ case 1711LLU: // skipped deleter
1968019782 {
1968119783 // call idwithnr from REGISTER
19682- stack[base + 14LLU] = 1700LLU/*throw to this address*/;
19784+ stack[base + 14LLU] = 1712LLU/*throw to this address*/;
1968319785 stack[base + 15LLU] = base;
19684- stack[base + 16LLU] = 1701LLU;
19786+ stack[base + 16LLU] = 1713LLU;
1968519787 // arguments for call to idwithnr
1968619788 stack[base + 18LLU] = 517219065798852608LLU;
1968719789 stack[base + 19LLU] = stack[base + 11]/*ARGCOUNT*/;
@@ -19690,26 +19792,26 @@
1969019792 label = 18446744073709551579LLU; // idwithnr
1969119793 break;
1969219794 }
19693- case 1700LLU: // copy-back deleter (idwithnr to REGISTER)
19795+ case 1712LLU: // copy-back deleter (idwithnr to REGISTER)
1969419796 {
1969519797 // copy mutable arguments back from call to idwithnr
19696- label = 1693LLU; // continue to roll stack
19798+ label = 1705LLU; // continue to roll stack
1969719799 break;
1969819800 }
19699- case 1701LLU: // return from idwithnr to REGISTER
19801+ case 1713LLU: // return from idwithnr to REGISTER
1970019802 {
1970119803 // copy mutable arguments back from call to idwithnr
1970219804 // copy back results provided by call to idwithnr
1970319805 stack[base + 13] = stack[base + 17LLU];
19704- label = 1703LLU; // skip deleter
19806+ label = 1715LLU; // skip deleter
1970519807 break;
1970619808 }
19707- case 1702LLU: // deleter
19809+ case 1714LLU: // deleter
1970819810 {
1970919811 // throw from REGISTER
1971019812 if(!stack[base + 14])
1971119813 {
19712- label = 1698LLU; // skip, variable already deleted/unscoped
19814+ label = 1710LLU; // skip, variable already deleted/unscoped
1971319815 break;
1971419816 }
1971519817
@@ -19718,7 +19820,7 @@
1971819820 newstack[0] = (uint64_t)stack; // backup stack location
1971919821 newstack[1] = 1234567890;
1972019822 newstack[2] = base;
19721- newstack[3] = 1704LLU;
19823+ newstack[3] = 1716LLU;
1972219824 stack = newstack;
1972319825 // set stack-base & callee-address
1972419826 base = 4/*deloffset*/;
@@ -19725,21 +19827,21 @@
1972519827 label = 372LLU; // ~typeid
1972619828 break;
1972719829 }
19728- case 1704LLU: // return from ~typeid to REGISTER
19830+ case 1716LLU: // return from ~typeid to REGISTER
1972919831 {
1973019832 stack = (uint64_t *)stack[0];
1973119833 // releasing toplevel container
1973219834 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1973319835
19734- label = 1698LLU; // continue unrolling stack, delete next variable
19836+ label = 1710LLU; // continue unrolling stack, delete next variable
1973519837 break;
1973619838 }
19737- case 1703LLU: // skipped deleter
19839+ case 1715LLU: // skipped deleter
1973819840 {
1973919841 // construct typeid.typeid
1974019842 if(!(stack[base + 14] = construct(2)))
1974119843 {
19742- label = 1698LLU; // throw: begin to unroll stack
19844+ label = 1710LLU; // throw: begin to unroll stack
1974319845 break;
1974419846 }
1974519847
@@ -19747,32 +19849,32 @@
1974719849 ((uint64_t *)stack[base + 14])[0] = 0;
1974819850 INIT(&(((uint64_t **)(stack[base + 14]))[1][0]), &stack[base + 12]/*type*/);
1974919851 (((uint64_t **)(stack[base + 14]))[1][1]) = stack[base + 13]/*id*/;
19750- label = 1706LLU; // skip deleter
19852+ label = 1718LLU; // skip deleter
1975119853 break;
1975219854 }
19753- case 1705LLU: // deleter
19855+ case 1717LLU: // deleter
1975419856 {
1975519857 // throw from REGISTER
1975619858 if(!stack[base + 15])
1975719859 {
19758- label = 1702LLU; // skip, variable already deleted/unscoped
19860+ label = 1714LLU; // skip, variable already deleted/unscoped
1975919861 break;
1976019862 }
19761- label = 1702LLU; // continue unrolling stack, delete next variable
19863+ label = 1714LLU; // continue unrolling stack, delete next variable
1976219864 break;
1976319865 }
19764- case 1706LLU: // skipped deleter
19866+ case 1718LLU: // skipped deleter
1976519867 {
1976619868 stack[base + 15] = 0;
19767- label = 1708LLU; // skip deleter
19869+ label = 1720LLU; // skip deleter
1976819870 break;
1976919871 }
19770- case 1707LLU: // deleter
19872+ case 1719LLU: // deleter
1977119873 {
1977219874 // throw from REGISTER
1977319875 if(!stack[base + 16])
1977419876 {
19775- label = 1705LLU; // skip, variable already deleted/unscoped
19877+ label = 1717LLU; // skip, variable already deleted/unscoped
1977619878 break;
1977719879 }
1977819880
@@ -19781,7 +19883,7 @@
1978119883 newstack[0] = (uint64_t)stack; // backup stack location
1978219884 newstack[1] = 1234567890;
1978319885 newstack[2] = base;
19784- newstack[3] = 1709LLU;
19886+ newstack[3] = 1721LLU;
1978519887 stack = newstack;
1978619888 // set stack-base & callee-address
1978719889 base = 4/*deloffset*/;
@@ -19788,21 +19890,21 @@
1978819890 label = 440LLU; // ~param
1978919891 break;
1979019892 }
19791- case 1709LLU: // return from ~param to REGISTER
19893+ case 1721LLU: // return from ~param to REGISTER
1979219894 {
1979319895 stack = (uint64_t *)stack[0];
1979419896 // releasing toplevel container
1979519897 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
1979619898
19797- label = 1705LLU; // continue unrolling stack, delete next variable
19899+ label = 1717LLU; // continue unrolling stack, delete next variable
1979819900 break;
1979919901 }
19800- case 1708LLU: // skipped deleter
19902+ case 1720LLU: // skipped deleter
1980119903 {
1980219904 // construct param.param
1980319905 if(!(stack[base + 16] = construct(2)))
1980419906 {
19805- label = 1705LLU; // throw: begin to unroll stack
19907+ label = 1717LLU; // throw: begin to unroll stack
1980619908 break;
1980719909 }
1980819910
@@ -19823,49 +19925,49 @@
1982319925 /*fnargtypes*/stack[base + 10] = (uint64_t)list;
1982419926 MOVE(&list->data, &stack[base + 16]/*param*/);
1982519927 }
19826- label = 1691LLU; // repeat
19928+ label = 1703LLU; // repeat
1982719929 break;
1982819930 }
19829- case 1692LLU: // loop finished
19931+ case 1704LLU: // loop finished
1983019932 {
19831- label = 1711LLU; // skip deleter
19933+ label = 1723LLU; // skip deleter
1983219934 break;
1983319935 }
19834- case 1710LLU: // deleter
19936+ case 1722LLU: // deleter
1983519937 {
1983619938 // throw from REGISTER
1983719939 if(!stack[base + 12])
1983819940 {
19839- label = 1686LLU; // skip, variable already deleted/unscoped
19941+ label = 1698LLU; // skip, variable already deleted/unscoped
1984019942 break;
1984119943 }
19842- label = 1686LLU; // continue unrolling stack, delete next variable
19944+ label = 1698LLU; // continue unrolling stack, delete next variable
1984319945 break;
1984419946 }
19845- case 1711LLU: // skipped deleter
19947+ case 1723LLU: // skipped deleter
1984619948 {
1984719949 stack[base + 12] = 0;
19848- label = 1713LLU; // skip deleter
19950+ label = 1725LLU; // skip deleter
1984919951 break;
1985019952 }
19851- case 1712LLU: // deleter
19953+ case 1724LLU: // deleter
1985219954 {
1985319955 // throw from REGISTER
1985419956 if(!stack[base + 13])
1985519957 {
19856- label = 1710LLU; // skip, variable already deleted/unscoped
19958+ label = 1722LLU; // skip, variable already deleted/unscoped
1985719959 break;
1985819960 }
19859- label = 1710LLU; // continue unrolling stack, delete next variable
19961+ label = 1722LLU; // continue unrolling stack, delete next variable
1986019962 break;
1986119963 }
19862- case 1713LLU: // skipped deleter
19964+ case 1725LLU: // skipped deleter
1986319965 {
1986419966 stack[base + 13] = 0;
1986519967 // call sub from REGISTER
19866- stack[base + 14LLU] = 1714LLU/*throw to this address*/;
19968+ stack[base + 14LLU] = 1726LLU/*throw to this address*/;
1986719969 stack[base + 15LLU] = base;
19868- stack[base + 16LLU] = 1715LLU;
19970+ stack[base + 16LLU] = 1727LLU;
1986919971 // arguments for call to sub
1987019972 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1987119973 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
@@ -19874,21 +19976,21 @@
1987419976 label = 18446744073709551604LLU; // sub
1987519977 break;
1987619978 }
19877- case 1714LLU: // copy-back deleter (sub to REGISTER)
19979+ case 1726LLU: // copy-back deleter (sub to REGISTER)
1987819980 {
1987919981 // copy mutable arguments back from call to sub
19880- label = 1712LLU; // continue to roll stack
19982+ label = 1724LLU; // continue to roll stack
1988119983 break;
1988219984 }
19883- case 1715LLU: // return from sub to REGISTER
19985+ case 1727LLU: // return from sub to REGISTER
1988419986 {
1988519987 // copy mutable arguments back from call to sub
1988619988 // copy back results provided by call to sub
1988719989 stack[base + 13] = stack[base + 17LLU];
1988819990 // call sub from REGISTER
19889- stack[base + 14LLU] = 1716LLU/*throw to this address*/;
19991+ stack[base + 14LLU] = 1728LLU/*throw to this address*/;
1989019992 stack[base + 15LLU] = base;
19891- stack[base + 16LLU] = 1717LLU;
19993+ stack[base + 16LLU] = 1729LLU;
1989219994 // arguments for call to sub
1989319995 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1989419996 stack[base + 19LLU] = 1LLU;
@@ -19897,26 +19999,26 @@
1989719999 label = 18446744073709551604LLU; // sub
1989820000 break;
1989920001 }
19900- case 1716LLU: // copy-back deleter (sub to REGISTER)
20002+ case 1728LLU: // copy-back deleter (sub to REGISTER)
1990120003 {
1990220004 // copy mutable arguments back from call to sub
19903- label = 1712LLU; // continue to roll stack
20005+ label = 1724LLU; // continue to roll stack
1990420006 break;
1990520007 }
19906- case 1717LLU: // return from sub to REGISTER
20008+ case 1729LLU: // return from sub to REGISTER
1990720009 {
1990820010 // copy mutable arguments back from call to sub
1990920011 // copy back results provided by call to sub
1991020012 stack[base + 13] = stack[base + 17LLU];
19911- label = 1719LLU; // skip deleter
20013+ label = 1731LLU; // skip deleter
1991220014 break;
1991320015 }
19914- case 1718LLU: // deleter
20016+ case 1730LLU: // deleter
1991520017 {
1991620018 // throw from REGISTER
1991720019 if(!stack[base + 14])
1991820020 {
19919- label = 1712LLU; // skip, variable already deleted/unscoped
20021+ label = 1724LLU; // skip, variable already deleted/unscoped
1992020022 break;
1992120023 }
1992220024
@@ -19925,7 +20027,7 @@
1992520027 newstack[0] = (uint64_t)stack; // backup stack location
1992620028 newstack[1] = 1234567890;
1992720029 newstack[2] = base;
19928- newstack[3] = 1720LLU;
20030+ newstack[3] = 1732LLU;
1992920031 stack = newstack;
1993020032 // set stack-base & callee-address
1993120033 base = 4/*deloffset*/;
@@ -19932,21 +20034,21 @@
1993220034 label = 1420LLU; // ~fndef
1993320035 break;
1993420036 }
19935- case 1720LLU: // return from ~fndef to REGISTER
20037+ case 1732LLU: // return from ~fndef to REGISTER
1993620038 {
1993720039 stack = (uint64_t *)stack[0];
1993820040 // releasing toplevel container
1993920041 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1994020042
19941- label = 1712LLU; // continue unrolling stack, delete next variable
20043+ label = 1724LLU; // continue unrolling stack, delete next variable
1994220044 break;
1994320045 }
19944- case 1719LLU: // skipped deleter
20046+ case 1731LLU: // skipped deleter
1994520047 {
1994620048 // construct fndef.fndef
1994720049 if(!(stack[base + 14] = construct(8)))
1994820050 {
19949- label = 1712LLU; // throw: begin to unroll stack
20051+ label = 1724LLU; // throw: begin to unroll stack
1995020052 break;
1995120053 }
1995220054
@@ -19974,9 +20076,9 @@
1997420076 MOVE(&list->data, &stack[base + 14]/*fndef*/);
1997520077 }
1997620078 // call add from REGISTER
19977- stack[base + 15LLU] = 1721LLU/*throw to this address*/;
20079+ stack[base + 15LLU] = 1733LLU/*throw to this address*/;
1997820080 stack[base + 16LLU] = base;
19979- stack[base + 17LLU] = 1722LLU;
20081+ stack[base + 17LLU] = 1734LLU;
1998020082 // arguments for call to add
1998120083 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
1998220084 stack[base + 20LLU] = 1LLU;
@@ -19985,13 +20087,13 @@
1998520087 label = 18446744073709551605LLU; // add
1998620088 break;
1998720089 }
19988- case 1721LLU: // copy-back deleter (add to REGISTER)
20090+ case 1733LLU: // copy-back deleter (add to REGISTER)
1998920091 {
1999020092 // copy mutable arguments back from call to add
19991- label = 1718LLU; // continue to roll stack
20093+ label = 1730LLU; // continue to roll stack
1999220094 break;
1999320095 }
19994- case 1722LLU: // return from add to REGISTER
20096+ case 1734LLU: // return from add to REGISTER
1999520097 {
1999620098 // copy mutable arguments back from call to add
1999720099 // copy back results provided by call to add
@@ -20001,13 +20103,13 @@
2000120103 base = stack[base - 2];
2000220104 break;
2000320105 }
20004- case 1724LLU: // function register failed
20106+ case 1736LLU: // function register failed
2000520107 {
2000620108 label = stack[base - 3];
2000720109 base = stack[base - 2];
2000820110 break;
2000920111 }
20010- case 1723LLU: // register
20112+ case 1735LLU: // register
2001120113 {
2001220114 //#define arg0 0
2001320115 //#define arg1 1
@@ -20018,28 +20120,28 @@
2001820120 //#define arg6 6
2001920121 //#define arg7 7
2002020122 // call emitreturn from register
20021- stack[base + 8LLU] = 1725LLU/*throw to this address*/;
20123+ stack[base + 8LLU] = 1737LLU/*throw to this address*/;
2002220124 stack[base + 9LLU] = base;
20023- stack[base + 10LLU] = 1726LLU;
20125+ stack[base + 10LLU] = 1738LLU;
2002420126 // arguments for call to emitreturn
2002520127 // set stack-base & callee-address
2002620128 base += 11LLU;
20027- label = 1655LLU; // emitreturn
20129+ label = 1667LLU; // emitreturn
2002820130 break;
2002920131 }
20030- case 1725LLU: // copy-back deleter (emitreturn to register)
20132+ case 1737LLU: // copy-back deleter (emitreturn to register)
2003120133 {
2003220134 // copy mutable arguments back from call to emitreturn
20033- label = 1724LLU; // continue to roll stack
20135+ label = 1736LLU; // continue to roll stack
2003420136 break;
2003520137 }
20036- case 1726LLU: // return from emitreturn to register
20138+ case 1738LLU: // return from emitreturn to register
2003720139 {
2003820140 // copy mutable arguments back from call to emitreturn
2003920141 // call REGISTER from register
20040- stack[base + 8LLU] = 1727LLU/*throw to this address*/;
20142+ stack[base + 8LLU] = 1739LLU/*throw to this address*/;
2004120143 stack[base + 9LLU] = base;
20042- stack[base + 10LLU] = 1728LLU;
20144+ stack[base + 10LLU] = 1740LLU;
2004320145 // arguments for call to REGISTER
2004420146 stack[base + 11LLU] = stack[base + 0]/*rescount*/;
2004520147 stack[base + 12LLU] = stack[base + 1]/*argcount*/;
@@ -20051,41 +20153,41 @@
2005120153 stack[base + 18LLU] = stack[base + 7]/*IO*/;
2005220154 // set stack-base & callee-address
2005320155 base += 11LLU;
20054- label = 1667LLU; // REGISTER
20156+ label = 1679LLU; // REGISTER
2005520157 break;
2005620158 }
20057- case 1727LLU: // copy-back deleter (REGISTER to register)
20159+ case 1739LLU: // copy-back deleter (REGISTER to register)
2005820160 {
2005920161 // copy mutable arguments back from call to REGISTER
2006020162 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
2006120163 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
20062- label = 1724LLU; // continue to roll stack
20164+ label = 1736LLU; // continue to roll stack
2006320165 break;
2006420166 }
20065- case 1728LLU: // return from REGISTER to register
20167+ case 1740LLU: // return from REGISTER to register
2006620168 {
2006720169 // copy mutable arguments back from call to REGISTER
2006820170 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
2006920171 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
2007020172 // call emitcase from register
20071- stack[base + 8LLU] = 1729LLU/*throw to this address*/;
20173+ stack[base + 8LLU] = 1741LLU/*throw to this address*/;
2007220174 stack[base + 9LLU] = base;
20073- stack[base + 10LLU] = 1730LLU;
20175+ stack[base + 10LLU] = 1742LLU;
2007420176 // arguments for call to emitcase
2007520177 stack[base + 11LLU] = stack[base + 5]/*defcount*/;
2007620178 stack[base + 12LLU] = stack[base + 3]/*fnid*/;
2007720179 // set stack-base & callee-address
2007820180 base += 11LLU;
20079- label = 1649LLU; // emitcase
20181+ label = 1661LLU; // emitcase
2008020182 break;
2008120183 }
20082- case 1729LLU: // copy-back deleter (emitcase to register)
20184+ case 1741LLU: // copy-back deleter (emitcase to register)
2008320185 {
2008420186 // copy mutable arguments back from call to emitcase
20085- label = 1724LLU; // continue to roll stack
20187+ label = 1736LLU; // continue to roll stack
2008620188 break;
2008720189 }
20088- case 1730LLU: // return from emitcase to register
20190+ case 1742LLU: // return from emitcase to register
2008920191 {
2009020192 // copy mutable arguments back from call to emitcase
2009120193 // return from register
@@ -20093,19 +20195,19 @@
2009320195 base = stack[base - 2];
2009420196 break;
2009520197 }
20096- case 1732LLU: // function linkthrow failed
20198+ case 1744LLU: // function linkthrow failed
2009720199 {
2009820200 label = stack[base - 3];
2009920201 base = stack[base - 2];
2010020202 break;
2010120203 }
20102- case 1731LLU: // linkthrow
20204+ case 1743LLU: // linkthrow
2010320205 {
2010420206 //#define arg0 0
2010520207 //#define arg1 1
2010620208 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
2010720209 {
20108- label = 1734LLU; // jump to alternative
20210+ label = 1746LLU; // jump to alternative
2010920211 break;
2011020212 }
2011120213
@@ -20116,22 +20218,22 @@
2011620218 stack[base + 2]/*labelthrow*/ = stack[base + 1]/*labelfail*/;
2011720219 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
2011820220 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
20119- label = 1733LLU; // case complete
20221+ label = 1745LLU; // case complete
2012020222 break;
2012120223 }
20122- case 1735LLU: // copy-back deleter (switch)
20224+ case 1747LLU: // copy-back deleter (switch)
2012320225 {
2012420226 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
2012520227 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
20126- label = 1732LLU; // continue to unroll stack
20228+ label = 1744LLU; // continue to unroll stack
2012720229 break;
2012820230 }
20129- case 1734LLU: // try next case
20231+ case 1746LLU: // try next case
2013020232 {
2013120233 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2013220234 exit(-1);
2013320235 }
20134- case 1733LLU: // completed switch
20236+ case 1745LLU: // completed switch
2013520237 {
2013620238 // return from linkthrow
2013720239 label = stack[base - 1];
@@ -20138,19 +20240,19 @@
2013820240 base = stack[base - 2];
2013920241 break;
2014020242 }
20141- case 1737LLU: // function emitthrow failed
20243+ case 1749LLU: // function emitthrow failed
2014220244 {
2014320245 label = stack[base - 3];
2014420246 base = stack[base - 2];
2014520247 break;
2014620248 }
20147- case 1736LLU: // emitthrow
20249+ case 1748LLU: // emitthrow
2014820250 {
2014920251 //#define arg0 0
2015020252 printf("%s", "\n {");
2015120253 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
2015220254 {
20153- label = 1739LLU; // jump to alternative
20255+ label = 1751LLU; // jump to alternative
2015420256 break;
2015520257 }
2015620258
@@ -20160,9 +20262,9 @@
2016020262 // case
2016120263 printf("%s", "\n label = ");
2016220264 // call printnr from emitthrow
20163- stack[base + 3LLU] = 1741LLU/*throw to this address*/;
20265+ stack[base + 3LLU] = 1753LLU/*throw to this address*/;
2016420266 stack[base + 4LLU] = base;
20165- stack[base + 5LLU] = 1742LLU;
20267+ stack[base + 5LLU] = 1754LLU;
2016620268 // arguments for call to printnr
2016720269 stack[base + 6LLU] = stack[base + 1]/*labelthrow*/;
2016820270 // set stack-base & callee-address
@@ -20170,34 +20272,34 @@
2017020272 label = 18446744073709551590LLU; // printnr
2017120273 break;
2017220274 }
20173- case 1741LLU: // copy-back deleter (printnr to emitthrow)
20275+ case 1753LLU: // copy-back deleter (printnr to emitthrow)
2017420276 {
2017520277 // copy mutable arguments back from call to printnr
20176- label = 1740LLU; // continue to roll stack
20278+ label = 1752LLU; // continue to roll stack
2017720279 break;
2017820280 }
20179- case 1742LLU: // return from printnr to emitthrow
20281+ case 1754LLU: // return from printnr to emitthrow
2018020282 {
2018120283 // copy mutable arguments back from call to printnr
2018220284 printf("%s", "LLU; // throw: begin to unroll stack");
2018320285 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
2018420286 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
20185- label = 1738LLU; // case complete
20287+ label = 1750LLU; // case complete
2018620288 break;
2018720289 }
20188- case 1740LLU: // copy-back deleter (switch)
20290+ case 1752LLU: // copy-back deleter (switch)
2018920291 {
2019020292 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
2019120293 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
20192- label = 1737LLU; // continue to unroll stack
20294+ label = 1749LLU; // continue to unroll stack
2019320295 break;
2019420296 }
20195- case 1739LLU: // try next case
20297+ case 1751LLU: // try next case
2019620298 {
2019720299 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2019820300 exit(-1);
2019920301 }
20200- case 1738LLU: // completed switch
20302+ case 1750LLU: // completed switch
2020120303 {
2020220304 printf("%s", "\n break;");
2020320305 printf("%s", "\n }");
@@ -20207,13 +20309,13 @@
2020720309 base = stack[base - 2];
2020820310 break;
2020920311 }
20210- case 1744LLU: // function ProcCall failed
20312+ case 1756LLU: // function ProcCall failed
2021120313 {
2021220314 label = stack[base - 3];
2021320315 base = stack[base - 2];
2021420316 break;
2021520317 }
20216- case 1743LLU: // ProcCall
20318+ case 1755LLU: // ProcCall
2021720319 {
2021820320 //#define arg0 0
2021920321 //#define arg1 1
@@ -20233,43 +20335,43 @@
2023320335 //#define arg15 15
2023420336 //#define arg16 16
2023520337 //#define arg17 17
20236- label = 1746LLU; // skip deleter
20338+ label = 1758LLU; // skip deleter
2023720339 break;
2023820340 }
20239- case 1745LLU: // deleter
20341+ case 1757LLU: // deleter
2024020342 {
2024120343 // throw from ProcCall
2024220344 if(!stack[base + 18])
2024320345 {
20244- label = 1744LLU; // skip, variable already deleted/unscoped
20346+ label = 1756LLU; // skip, variable already deleted/unscoped
2024520347 break;
2024620348 }
20247- label = 1744LLU; // continue unrolling stack, delete next variable
20349+ label = 1756LLU; // continue unrolling stack, delete next variable
2024820350 break;
2024920351 }
20250- case 1746LLU: // skipped deleter
20352+ case 1758LLU: // skipped deleter
2025120353 {
2025220354 stack[base + 18] = 0;
20253- label = 1748LLU; // skip deleter
20355+ label = 1760LLU; // skip deleter
2025420356 break;
2025520357 }
20256- case 1747LLU: // deleter
20358+ case 1759LLU: // deleter
2025720359 {
2025820360 // throw from ProcCall
2025920361 if(!stack[base + 19])
2026020362 {
20261- label = 1745LLU; // skip, variable already deleted/unscoped
20363+ label = 1757LLU; // skip, variable already deleted/unscoped
2026220364 break;
2026320365 }
2026420366 // delete list
20265- label = 1749LLU; // start to repeat
20367+ label = 1761LLU; // start to repeat
2026620368 break;
2026720369 }
20268- case 1749LLU: // repeat from here
20370+ case 1761LLU: // repeat from here
2026920371 {
2027020372 if(!stack[base + 19])
2027120373 {
20272- label = 1750LLU; // break loop
20374+ label = 1762LLU; // break loop
2027320375 break;
2027420376 }
2027520377
@@ -20280,7 +20382,7 @@
2028020382 newstack[0] = (uint64_t)stack; // backup stack location
2028120383 newstack[1] = 1234567890;
2028220384 newstack[2] = base;
20283- newstack[3] = 1751LLU;
20385+ newstack[3] = 1763LLU;
2028420386 stack = newstack;
2028520387 // set stack-base & callee-address
2028620388 base = 4/*deloffset*/;
@@ -20287,7 +20389,7 @@
2028720389 label = 833LLU; // ~idnr
2028820390 break;
2028920391 }
20290- case 1751LLU: // return from ~idnr to ProcCall
20392+ case 1763LLU: // return from ~idnr to ProcCall
2029120393 {
2029220394 stack = (uint64_t *)stack[0];
2029320395 // releasing toplevel container
@@ -20298,20 +20400,20 @@
2029820400 stack[base + 19] = (uint64_t)list->next;
2029920401 Free(1, sizeof(struct listnode), list);
2030020402 }
20301- label = 1749LLU; // repeat
20403+ label = 1761LLU; // repeat
2030220404 break;
2030320405 }
20304- case 1750LLU: // loop finished
20406+ case 1762LLU: // loop finished
2030520407 {
20306- label = 1745LLU; // continue unrolling stack, delete next variable
20408+ label = 1757LLU; // continue unrolling stack, delete next variable
2030720409 break;
2030820410 }
20309- case 1748LLU: // skipped deleter
20411+ case 1760LLU: // skipped deleter
2031020412 {
2031120413 stack[base + 19] = 0;
2031220414 if(/*fndef*/0 != ((uint64_t *)(stack[base + 13]/*calleedef*/))[0])
2031320415 {
20314- label = 1753LLU; // jump to alternative
20416+ label = 1765LLU; // jump to alternative
2031520417 break;
2031620418 }
2031720419
@@ -20327,19 +20429,19 @@
2032720429 // case
2032820430 if(!stack[base + 6]/*fncanthrow*/)
2032920431 {
20330- label = 1755LLU; // jump to alternative
20432+ label = 1767LLU; // jump to alternative
2033120433 break;
2033220434 }
2033320435
2033420436 // consequent
20335- label = 1756LLU; // consequent complete
20437+ label = 1768LLU; // consequent complete
2033620438 break;
2033720439 }
20338- case 1755LLU: // alternative
20440+ case 1767LLU: // alternative
2033920441 {
2034020442 if(!stack[base + 26]/*cecanthrow*/)
2034120443 {
20342- label = 1757LLU; // jump to alternative
20444+ label = 1769LLU; // jump to alternative
2034320445 break;
2034420446 }
2034520447
@@ -20346,9 +20448,9 @@
2034620448 // consequent
2034720449 fprintf(stderr, "%s", "in function ");
2034820450 // call reportid from ProcCall
20349- stack[base + 28LLU] = 1759LLU/*throw to this address*/;
20451+ stack[base + 28LLU] = 1771LLU/*throw to this address*/;
2035020452 stack[base + 29LLU] = base;
20351- stack[base + 30LLU] = 1760LLU;
20453+ stack[base + 30LLU] = 1772LLU;
2035220454 // arguments for call to reportid
2035320455 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2035420456 // set stack-base & callee-address
@@ -20356,20 +20458,20 @@
2035620458 label = 18446744073709551586LLU; // reportid
2035720459 break;
2035820460 }
20359- case 1759LLU: // copy-back deleter (reportid to ProcCall)
20461+ case 1771LLU: // copy-back deleter (reportid to ProcCall)
2036020462 {
2036120463 // copy mutable arguments back from call to reportid
20362- label = 1754LLU; // continue to roll stack
20464+ label = 1766LLU; // continue to roll stack
2036320465 break;
2036420466 }
20365- case 1760LLU: // return from reportid to ProcCall
20467+ case 1772LLU: // return from reportid to ProcCall
2036620468 {
2036720469 // copy mutable arguments back from call to reportid
2036820470 fprintf(stderr, "%s", ": call to function ");
2036920471 // call reportid from ProcCall
20370- stack[base + 28LLU] = 1761LLU/*throw to this address*/;
20472+ stack[base + 28LLU] = 1773LLU/*throw to this address*/;
2037120473 stack[base + 29LLU] = base;
20372- stack[base + 30LLU] = 1762LLU;
20474+ stack[base + 30LLU] = 1774LLU;
2037320475 // arguments for call to reportid
2037420476 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2037520477 // set stack-base & callee-address
@@ -20377,51 +20479,51 @@
2037720479 label = 18446744073709551586LLU; // reportid
2037820480 break;
2037920481 }
20380- case 1761LLU: // copy-back deleter (reportid to ProcCall)
20482+ case 1773LLU: // copy-back deleter (reportid to ProcCall)
2038120483 {
2038220484 // copy mutable arguments back from call to reportid
20383- label = 1754LLU; // continue to roll stack
20485+ label = 1766LLU; // continue to roll stack
2038420486 break;
2038520487 }
20386- case 1762LLU: // return from reportid to ProcCall
20488+ case 1774LLU: // return from reportid to ProcCall
2038720489 {
2038820490 // copy mutable arguments back from call to reportid
2038920491 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2039020492 {
20391- label = 1754LLU; // throw: begin to unroll stack
20493+ label = 1766LLU; // throw: begin to unroll stack
2039220494 break;
2039320495 }
2039420496
20395- label = 1758LLU; // consequent complete
20497+ label = 1770LLU; // consequent complete
2039620498 break;
2039720499 }
20398- case 1757LLU: // alternative
20500+ case 1769LLU: // alternative
2039920501 {
20400- label = 1758LLU; // alternative complete
20502+ label = 1770LLU; // alternative complete
2040120503 break;
2040220504 }
20403- case 1758LLU: // completed if-then-else
20505+ case 1770LLU: // completed if-then-else
2040420506 {
20405- label = 1756LLU; // alternative complete
20507+ label = 1768LLU; // alternative complete
2040620508 break;
2040720509 }
20408- case 1756LLU: // completed if-then-else
20510+ case 1768LLU: // completed if-then-else
2040920511 {
2041020512 if(!stack[base + 7]/*fnIO*/)
2041120513 {
20412- label = 1763LLU; // jump to alternative
20514+ label = 1775LLU; // jump to alternative
2041320515 break;
2041420516 }
2041520517
2041620518 // consequent
20417- label = 1764LLU; // consequent complete
20519+ label = 1776LLU; // consequent complete
2041820520 break;
2041920521 }
20420- case 1763LLU: // alternative
20522+ case 1775LLU: // alternative
2042120523 {
2042220524 if(!stack[base + 27]/*ceIO*/)
2042320525 {
20424- label = 1765LLU; // jump to alternative
20526+ label = 1777LLU; // jump to alternative
2042520527 break;
2042620528 }
2042720529
@@ -20428,9 +20530,9 @@
2042820530 // consequent
2042920531 fprintf(stderr, "%s", "in function ");
2043020532 // call reportid from ProcCall
20431- stack[base + 28LLU] = 1767LLU/*throw to this address*/;
20533+ stack[base + 28LLU] = 1779LLU/*throw to this address*/;
2043220534 stack[base + 29LLU] = base;
20433- stack[base + 30LLU] = 1768LLU;
20535+ stack[base + 30LLU] = 1780LLU;
2043420536 // arguments for call to reportid
2043520537 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2043620538 // set stack-base & callee-address
@@ -20438,20 +20540,20 @@
2043820540 label = 18446744073709551586LLU; // reportid
2043920541 break;
2044020542 }
20441- case 1767LLU: // copy-back deleter (reportid to ProcCall)
20543+ case 1779LLU: // copy-back deleter (reportid to ProcCall)
2044220544 {
2044320545 // copy mutable arguments back from call to reportid
20444- label = 1754LLU; // continue to roll stack
20546+ label = 1766LLU; // continue to roll stack
2044520547 break;
2044620548 }
20447- case 1768LLU: // return from reportid to ProcCall
20549+ case 1780LLU: // return from reportid to ProcCall
2044820550 {
2044920551 // copy mutable arguments back from call to reportid
2045020552 fprintf(stderr, "%s", ": call to IO-function ");
2045120553 // call reportid from ProcCall
20452- stack[base + 28LLU] = 1769LLU/*throw to this address*/;
20554+ stack[base + 28LLU] = 1781LLU/*throw to this address*/;
2045320555 stack[base + 29LLU] = base;
20454- stack[base + 30LLU] = 1770LLU;
20556+ stack[base + 30LLU] = 1782LLU;
2045520557 // arguments for call to reportid
2045620558 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2045720559 // set stack-base & callee-address
@@ -20459,147 +20561,147 @@
2045920561 label = 18446744073709551586LLU; // reportid
2046020562 break;
2046120563 }
20462- case 1769LLU: // copy-back deleter (reportid to ProcCall)
20564+ case 1781LLU: // copy-back deleter (reportid to ProcCall)
2046320565 {
2046420566 // copy mutable arguments back from call to reportid
20465- label = 1754LLU; // continue to roll stack
20567+ label = 1766LLU; // continue to roll stack
2046620568 break;
2046720569 }
20468- case 1770LLU: // return from reportid to ProcCall
20570+ case 1782LLU: // return from reportid to ProcCall
2046920571 {
2047020572 // copy mutable arguments back from call to reportid
2047120573 fprintf(stderr, "%s", " in non-IO environment\n");
2047220574 {
20473- label = 1754LLU; // throw: begin to unroll stack
20575+ label = 1766LLU; // throw: begin to unroll stack
2047420576 break;
2047520577 }
2047620578
20477- label = 1766LLU; // consequent complete
20579+ label = 1778LLU; // consequent complete
2047820580 break;
2047920581 }
20480- case 1765LLU: // alternative
20582+ case 1777LLU: // alternative
2048120583 {
20482- label = 1766LLU; // alternative complete
20584+ label = 1778LLU; // alternative complete
2048320585 break;
2048420586 }
20485- case 1766LLU: // completed if-then-else
20587+ case 1778LLU: // completed if-then-else
2048620588 {
20487- label = 1764LLU; // alternative complete
20589+ label = 1776LLU; // alternative complete
2048820590 break;
2048920591 }
20490- case 1764LLU: // completed if-then-else
20592+ case 1776LLU: // completed if-then-else
2049120593 {
20492- label = 1772LLU; // skip deleter
20594+ label = 1784LLU; // skip deleter
2049320595 break;
2049420596 }
20495- case 1771LLU: // deleter
20597+ case 1783LLU: // deleter
2049620598 {
2049720599 // throw from ProcCall
2049820600 if(!stack[base + 28])
2049920601 {
20500- label = 1754LLU; // skip, variable already deleted/unscoped
20602+ label = 1766LLU; // skip, variable already deleted/unscoped
2050120603 break;
2050220604 }
20503- label = 1754LLU; // continue unrolling stack, delete next variable
20605+ label = 1766LLU; // continue unrolling stack, delete next variable
2050420606 break;
2050520607 }
20506- case 1772LLU: // skipped deleter
20608+ case 1784LLU: // skipped deleter
2050720609 {
2050820610 stack[base + 28] = list_size(((struct listnode *)(stack[base + 21]/*cerestypes*/)));
20509- label = 1774LLU; // skip deleter
20611+ label = 1786LLU; // skip deleter
2051020612 break;
2051120613 }
20512- case 1773LLU: // deleter
20614+ case 1785LLU: // deleter
2051320615 {
2051420616 // throw from ProcCall
2051520617 if(!stack[base + 29])
2051620618 {
20517- label = 1771LLU; // skip, variable already deleted/unscoped
20619+ label = 1783LLU; // skip, variable already deleted/unscoped
2051820620 break;
2051920621 }
20520- label = 1771LLU; // continue unrolling stack, delete next variable
20622+ label = 1783LLU; // continue unrolling stack, delete next variable
2052120623 break;
2052220624 }
20523- case 1774LLU: // skipped deleter
20625+ case 1786LLU: // skipped deleter
2052420626 {
2052520627 stack[base + 29] = list_size(((struct listnode *)(stack[base + 22]/*ceargtypes*/)));
2052620628 if(!stack[base + 20]/*celabel*/)
2052720629 {
20528- label = 1775LLU; // jump to alternative
20630+ label = 1787LLU; // jump to alternative
2052920631 break;
2053020632 }
2053120633
2053220634 // consequent
20533- label = 1776LLU; // consequent complete
20635+ label = 1788LLU; // consequent complete
2053420636 break;
2053520637 }
20536- case 1775LLU: // alternative
20638+ case 1787LLU: // alternative
2053720639 {
2053820640 fprintf(stderr, "%s", " NULL-label!\n");
2053920641 {
20540- label = 1773LLU; // throw: begin to unroll stack
20642+ label = 1785LLU; // throw: begin to unroll stack
2054120643 break;
2054220644 }
2054320645
20544- label = 1776LLU; // alternative complete
20646+ label = 1788LLU; // alternative complete
2054520647 break;
2054620648 }
20547- case 1776LLU: // completed if-then-else
20649+ case 1788LLU: // completed if-then-else
2054820650 {
20549- label = 1778LLU; // skip deleter
20651+ label = 1790LLU; // skip deleter
2055020652 break;
2055120653 }
20552- case 1777LLU: // deleter
20654+ case 1789LLU: // deleter
2055320655 {
2055420656 // throw from ProcCall
2055520657 if(!stack[base + 30])
2055620658 {
20557- label = 1773LLU; // skip, variable already deleted/unscoped
20659+ label = 1785LLU; // skip, variable already deleted/unscoped
2055820660 break;
2055920661 }
20560- label = 1773LLU; // continue unrolling stack, delete next variable
20662+ label = 1785LLU; // continue unrolling stack, delete next variable
2056120663 break;
2056220664 }
20563- case 1778LLU: // skipped deleter
20665+ case 1790LLU: // skipped deleter
2056420666 {
2056520667 stack[base + 30] = 0;
20566- label = 1780LLU; // skip deleter
20668+ label = 1792LLU; // skip deleter
2056720669 break;
2056820670 }
20569- case 1779LLU: // deleter
20671+ case 1791LLU: // deleter
2057020672 {
2057120673 // throw from ProcCall
2057220674 if(!stack[base + 31])
2057320675 {
20574- label = 1777LLU; // skip, variable already deleted/unscoped
20676+ label = 1789LLU; // skip, variable already deleted/unscoped
2057520677 break;
2057620678 }
20577- label = 1777LLU; // continue unrolling stack, delete next variable
20679+ label = 1789LLU; // continue unrolling stack, delete next variable
2057820680 break;
2057920681 }
20580- case 1780LLU: // skipped deleter
20682+ case 1792LLU: // skipped deleter
2058120683 {
2058220684 stack[base + 31] = 0;
20583- label = 1782LLU; // skip deleter
20685+ label = 1794LLU; // skip deleter
2058420686 break;
2058520687 }
20586- case 1781LLU: // deleter
20688+ case 1793LLU: // deleter
2058720689 {
2058820690 // throw from ProcCall
2058920691 if(!stack[base + 32])
2059020692 {
20591- label = 1779LLU; // skip, variable already deleted/unscoped
20693+ label = 1791LLU; // skip, variable already deleted/unscoped
2059220694 break;
2059320695 }
20594- label = 1779LLU; // continue unrolling stack, delete next variable
20696+ label = 1791LLU; // continue unrolling stack, delete next variable
2059520697 break;
2059620698 }
20597- case 1782LLU: // skipped deleter
20699+ case 1794LLU: // skipped deleter
2059820700 {
2059920701 stack[base + 32] = 0;
2060020702 if(!stack[base + 25]/*cerec*/)
2060120703 {
20602- label = 1783LLU; // jump to alternative
20704+ label = 1795LLU; // jump to alternative
2060320705 break;
2060420706 }
2060520707
@@ -20606,21 +20708,21 @@
2060620708 // consequent
2060720709 if(!stack[base + 6]/*fncanthrow*/)
2060820710 {
20609- label = 1785LLU; // jump to alternative
20711+ label = 1797LLU; // jump to alternative
2061020712 break;
2061120713 }
2061220714
2061320715 // consequent
20614- label = 1786LLU; // consequent complete
20716+ label = 1798LLU; // consequent complete
2061520717 break;
2061620718 }
20617- case 1785LLU: // alternative
20719+ case 1797LLU: // alternative
2061820720 {
2061920721 fprintf(stderr, "%s", "in function ");
2062020722 // call reportid from ProcCall
20621- stack[base + 33LLU] = 1787LLU/*throw to this address*/;
20723+ stack[base + 33LLU] = 1799LLU/*throw to this address*/;
2062220724 stack[base + 34LLU] = base;
20623- stack[base + 35LLU] = 1788LLU;
20725+ stack[base + 35LLU] = 1800LLU;
2062420726 // arguments for call to reportid
2062520727 stack[base + 36LLU] = stack[base + 8]/*fnid*/;
2062620728 // set stack-base & callee-address
@@ -20628,20 +20730,20 @@
2062820730 label = 18446744073709551586LLU; // reportid
2062920731 break;
2063020732 }
20631- case 1787LLU: // copy-back deleter (reportid to ProcCall)
20733+ case 1799LLU: // copy-back deleter (reportid to ProcCall)
2063220734 {
2063320735 // copy mutable arguments back from call to reportid
20634- label = 1781LLU; // continue to roll stack
20736+ label = 1793LLU; // continue to roll stack
2063520737 break;
2063620738 }
20637- case 1788LLU: // return from reportid to ProcCall
20739+ case 1800LLU: // return from reportid to ProcCall
2063820740 {
2063920741 // copy mutable arguments back from call to reportid
2064020742 fprintf(stderr, "%s", ": call to recursive function ");
2064120743 // call reportid from ProcCall
20642- stack[base + 33LLU] = 1789LLU/*throw to this address*/;
20744+ stack[base + 33LLU] = 1801LLU/*throw to this address*/;
2064320745 stack[base + 34LLU] = base;
20644- stack[base + 35LLU] = 1790LLU;
20746+ stack[base + 35LLU] = 1802LLU;
2064520747 // arguments for call to reportid
2064620748 stack[base + 36LLU] = stack[base + 24]/*ceid*/;
2064720749 // set stack-base & callee-address
@@ -20649,30 +20751,30 @@
2064920751 label = 18446744073709551586LLU; // reportid
2065020752 break;
2065120753 }
20652- case 1789LLU: // copy-back deleter (reportid to ProcCall)
20754+ case 1801LLU: // copy-back deleter (reportid to ProcCall)
2065320755 {
2065420756 // copy mutable arguments back from call to reportid
20655- label = 1781LLU; // continue to roll stack
20757+ label = 1793LLU; // continue to roll stack
2065620758 break;
2065720759 }
20658- case 1790LLU: // return from reportid to ProcCall
20760+ case 1802LLU: // return from reportid to ProcCall
2065920761 {
2066020762 // copy mutable arguments back from call to reportid
2066120763 fprintf(stderr, "%s", " in no-throw environment\n");
2066220764 {
20663- label = 1781LLU; // throw: begin to unroll stack
20765+ label = 1793LLU; // throw: begin to unroll stack
2066420766 break;
2066520767 }
2066620768
20667- label = 1786LLU; // alternative complete
20769+ label = 1798LLU; // alternative complete
2066820770 break;
2066920771 }
20670- case 1786LLU: // completed if-then-else
20772+ case 1798LLU: // completed if-then-else
2067120773 {
2067220774 // call add from ProcCall
20673- stack[base + 33LLU] = 1791LLU/*throw to this address*/;
20775+ stack[base + 33LLU] = 1803LLU/*throw to this address*/;
2067420776 stack[base + 34LLU] = base;
20675- stack[base + 35LLU] = 1792LLU;
20777+ stack[base + 35LLU] = 1804LLU;
2067620778 // arguments for call to add
2067720779 stack[base + 37LLU] = 1LLU;
2067820780 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -20681,56 +20783,56 @@
2068120783 label = 18446744073709551605LLU; // add
2068220784 break;
2068320785 }
20684- case 1791LLU: // copy-back deleter (add to ProcCall)
20786+ case 1803LLU: // copy-back deleter (add to ProcCall)
2068520787 {
2068620788 // copy mutable arguments back from call to add
20687- label = 1781LLU; // continue to roll stack
20789+ label = 1793LLU; // continue to roll stack
2068820790 break;
2068920791 }
20690- case 1792LLU: // return from add to ProcCall
20792+ case 1804LLU: // return from add to ProcCall
2069120793 {
2069220794 // copy mutable arguments back from call to add
2069320795 // copy back results provided by call to add
2069420796 stack[base + 17] = stack[base + 36LLU];
20695- label = 1794LLU; // skip deleter
20797+ label = 1806LLU; // skip deleter
2069620798 break;
2069720799 }
20698- case 1793LLU: // deleter
20800+ case 1805LLU: // deleter
2069920801 {
2070020802 // throw from ProcCall
2070120803 if(!stack[base + 33])
2070220804 {
20703- label = 1781LLU; // skip, variable already deleted/unscoped
20805+ label = 1793LLU; // skip, variable already deleted/unscoped
2070420806 break;
2070520807 }
20706- label = 1781LLU; // continue unrolling stack, delete next variable
20808+ label = 1793LLU; // continue unrolling stack, delete next variable
2070720809 break;
2070820810 }
20709- case 1794LLU: // skipped deleter
20811+ case 1806LLU: // skipped deleter
2071020812 {
2071120813 stack[base + 33] = stack[base + 17]/*label*/;
20712- label = 1796LLU; // skip deleter
20814+ label = 1808LLU; // skip deleter
2071320815 break;
2071420816 }
20715- case 1795LLU: // deleter
20817+ case 1807LLU: // deleter
2071620818 {
2071720819 // throw from ProcCall
2071820820 if(!stack[base + 34])
2071920821 {
20720- label = 1793LLU; // skip, variable already deleted/unscoped
20822+ label = 1805LLU; // skip, variable already deleted/unscoped
2072120823 break;
2072220824 }
20723- label = 1793LLU; // continue unrolling stack, delete next variable
20825+ label = 1805LLU; // continue unrolling stack, delete next variable
2072420826 break;
2072520827 }
20726- case 1796LLU: // skipped deleter
20828+ case 1808LLU: // skipped deleter
2072720829 {
2072820830 stack[base + 34] = 0;
2072920831 stack[base + 34]/*recsztotal*/ = 0;
2073020832 // call add from ProcCall
20731- stack[base + 35LLU] = 1797LLU/*throw to this address*/;
20833+ stack[base + 35LLU] = 1809LLU/*throw to this address*/;
2073220834 stack[base + 36LLU] = base;
20733- stack[base + 37LLU] = 1798LLU;
20835+ stack[base + 37LLU] = 1810LLU;
2073420836 // arguments for call to add
2073520837 stack[base + 39LLU] = 4LLU;
2073620838 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20739,21 +20841,21 @@
2073920841 label = 18446744073709551605LLU; // add
2074020842 break;
2074120843 }
20742- case 1797LLU: // copy-back deleter (add to ProcCall)
20844+ case 1809LLU: // copy-back deleter (add to ProcCall)
2074320845 {
2074420846 // copy mutable arguments back from call to add
20745- label = 1795LLU; // continue to roll stack
20847+ label = 1807LLU; // continue to roll stack
2074620848 break;
2074720849 }
20748- case 1798LLU: // return from add to ProcCall
20850+ case 1810LLU: // return from add to ProcCall
2074920851 {
2075020852 // copy mutable arguments back from call to add
2075120853 // copy back results provided by call to add
2075220854 stack[base + 34] = stack[base + 38LLU];
2075320855 // call add from ProcCall
20754- stack[base + 35LLU] = 1799LLU/*throw to this address*/;
20856+ stack[base + 35LLU] = 1811LLU/*throw to this address*/;
2075520857 stack[base + 36LLU] = base;
20756- stack[base + 37LLU] = 1800LLU;
20858+ stack[base + 37LLU] = 1812LLU;
2075720859 // arguments for call to add
2075820860 stack[base + 39LLU] = stack[base + 28]/*cerescount*/;
2075920861 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20762,21 +20864,21 @@
2076220864 label = 18446744073709551605LLU; // add
2076320865 break;
2076420866 }
20765- case 1799LLU: // copy-back deleter (add to ProcCall)
20867+ case 1811LLU: // copy-back deleter (add to ProcCall)
2076620868 {
2076720869 // copy mutable arguments back from call to add
20768- label = 1795LLU; // continue to roll stack
20870+ label = 1807LLU; // continue to roll stack
2076920871 break;
2077020872 }
20771- case 1800LLU: // return from add to ProcCall
20873+ case 1812LLU: // return from add to ProcCall
2077220874 {
2077320875 // copy mutable arguments back from call to add
2077420876 // copy back results provided by call to add
2077520877 stack[base + 34] = stack[base + 38LLU];
2077620878 // call add from ProcCall
20777- stack[base + 35LLU] = 1801LLU/*throw to this address*/;
20879+ stack[base + 35LLU] = 1813LLU/*throw to this address*/;
2077820880 stack[base + 36LLU] = base;
20779- stack[base + 37LLU] = 1802LLU;
20881+ stack[base + 37LLU] = 1814LLU;
2078020882 // arguments for call to add
2078120883 stack[base + 39LLU] = stack[base + 29]/*ceargcount*/;
2078220884 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20785,21 +20887,21 @@
2078520887 label = 18446744073709551605LLU; // add
2078620888 break;
2078720889 }
20788- case 1801LLU: // copy-back deleter (add to ProcCall)
20890+ case 1813LLU: // copy-back deleter (add to ProcCall)
2078920891 {
2079020892 // copy mutable arguments back from call to add
20791- label = 1795LLU; // continue to roll stack
20893+ label = 1807LLU; // continue to roll stack
2079220894 break;
2079320895 }
20794- case 1802LLU: // return from add to ProcCall
20896+ case 1814LLU: // return from add to ProcCall
2079520897 {
2079620898 // copy mutable arguments back from call to add
2079720899 // copy back results provided by call to add
2079820900 stack[base + 34] = stack[base + 38LLU];
2079920901 // call add from ProcCall
20800- stack[base + 35LLU] = 1803LLU/*throw to this address*/;
20902+ stack[base + 35LLU] = 1815LLU/*throw to this address*/;
2080120903 stack[base + 36LLU] = base;
20802- stack[base + 37LLU] = 1804LLU;
20904+ stack[base + 37LLU] = 1816LLU;
2080320905 // arguments for call to add
2080420906 stack[base + 39LLU] = stack[base + 23]/*cemaxcount*/;
2080520907 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20808,13 +20910,13 @@
2080820910 label = 18446744073709551605LLU; // add
2080920911 break;
2081020912 }
20811- case 1803LLU: // copy-back deleter (add to ProcCall)
20913+ case 1815LLU: // copy-back deleter (add to ProcCall)
2081220914 {
2081320915 // copy mutable arguments back from call to add
20814- label = 1795LLU; // continue to roll stack
20916+ label = 1807LLU; // continue to roll stack
2081520917 break;
2081620918 }
20817- case 1804LLU: // return from add to ProcCall
20919+ case 1816LLU: // return from add to ProcCall
2081820920 {
2081920921 // copy mutable arguments back from call to add
2082020922 // copy back results provided by call to add
@@ -20821,9 +20923,9 @@
2082120923 stack[base + 34] = stack[base + 38LLU];
2082220924 printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
2082320925 // call printnr from ProcCall
20824- stack[base + 35LLU] = 1805LLU/*throw to this address*/;
20926+ stack[base + 35LLU] = 1817LLU/*throw to this address*/;
2082520927 stack[base + 36LLU] = base;
20826- stack[base + 37LLU] = 1806LLU;
20928+ stack[base + 37LLU] = 1818LLU;
2082720929 // arguments for call to printnr
2082820930 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2082920931 // set stack-base & callee-address
@@ -20831,42 +20933,42 @@
2083120933 label = 18446744073709551590LLU; // printnr
2083220934 break;
2083320935 }
20834- case 1805LLU: // copy-back deleter (printnr to ProcCall)
20936+ case 1817LLU: // copy-back deleter (printnr to ProcCall)
2083520937 {
2083620938 // copy mutable arguments back from call to printnr
20837- label = 1795LLU; // continue to roll stack
20939+ label = 1807LLU; // continue to roll stack
2083820940 break;
2083920941 }
20840- case 1806LLU: // return from printnr to ProcCall
20942+ case 1818LLU: // return from printnr to ProcCall
2084120943 {
2084220944 // copy mutable arguments back from call to printnr
2084320945 printf("%s", "LLU + 1, sizeof(uint64_t));");
2084420946 printf("%s", "\n if(!newstack)");
2084520947 // call emitthrow from ProcCall
20846- stack[base + 35LLU] = 1807LLU/*throw to this address*/;
20948+ stack[base + 35LLU] = 1819LLU/*throw to this address*/;
2084720949 stack[base + 36LLU] = base;
20848- stack[base + 37LLU] = 1808LLU;
20950+ stack[base + 37LLU] = 1820LLU;
2084920951 // arguments for call to emitthrow
2085020952 stack[base + 38LLU] = stack[base + 3]/*scope*/;
2085120953 // set stack-base & callee-address
2085220954 base += 38LLU;
20853- label = 1736LLU; // emitthrow
20955+ label = 1748LLU; // emitthrow
2085420956 break;
2085520957 }
20856- case 1807LLU: // copy-back deleter (emitthrow to ProcCall)
20958+ case 1819LLU: // copy-back deleter (emitthrow to ProcCall)
2085720959 {
2085820960 // copy mutable arguments back from call to emitthrow
20859- label = 1795LLU; // continue to roll stack
20961+ label = 1807LLU; // continue to roll stack
2086020962 break;
2086120963 }
20862- case 1808LLU: // return from emitthrow to ProcCall
20964+ case 1820LLU: // return from emitthrow to ProcCall
2086320965 {
2086420966 // copy mutable arguments back from call to emitthrow
2086520967 printf("%s", "\n newstack[");
2086620968 // call printnr from ProcCall
20867- stack[base + 35LLU] = 1809LLU/*throw to this address*/;
20969+ stack[base + 35LLU] = 1821LLU/*throw to this address*/;
2086820970 stack[base + 36LLU] = base;
20869- stack[base + 37LLU] = 1810LLU;
20971+ stack[base + 37LLU] = 1822LLU;
2087020972 // arguments for call to printnr
2087120973 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2087220974 // set stack-base & callee-address
@@ -20874,21 +20976,21 @@
2087420976 label = 18446744073709551590LLU; // printnr
2087520977 break;
2087620978 }
20877- case 1809LLU: // copy-back deleter (printnr to ProcCall)
20979+ case 1821LLU: // copy-back deleter (printnr to ProcCall)
2087820980 {
2087920981 // copy mutable arguments back from call to printnr
20880- label = 1795LLU; // continue to roll stack
20982+ label = 1807LLU; // continue to roll stack
2088120983 break;
2088220984 }
20883- case 1810LLU: // return from printnr to ProcCall
20985+ case 1822LLU: // return from printnr to ProcCall
2088420986 {
2088520987 // copy mutable arguments back from call to printnr
2088620988 printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
2088720989 printf("%s", "\n // call ");
2088820990 // call printid from ProcCall
20889- stack[base + 35LLU] = 1811LLU/*throw to this address*/;
20991+ stack[base + 35LLU] = 1823LLU/*throw to this address*/;
2089020992 stack[base + 36LLU] = base;
20891- stack[base + 37LLU] = 1812LLU;
20993+ stack[base + 37LLU] = 1824LLU;
2089220994 // arguments for call to printid
2089320995 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2089420996 // set stack-base & callee-address
@@ -20896,20 +20998,20 @@
2089620998 label = 18446744073709551587LLU; // printid
2089720999 break;
2089821000 }
20899- case 1811LLU: // copy-back deleter (printid to ProcCall)
21001+ case 1823LLU: // copy-back deleter (printid to ProcCall)
2090021002 {
2090121003 // copy mutable arguments back from call to printid
20902- label = 1795LLU; // continue to roll stack
21004+ label = 1807LLU; // continue to roll stack
2090321005 break;
2090421006 }
20905- case 1812LLU: // return from printid to ProcCall
21007+ case 1824LLU: // return from printid to ProcCall
2090621008 {
2090721009 // copy mutable arguments back from call to printid
2090821010 printf("%s", " from ");
2090921011 // call printid from ProcCall
20910- stack[base + 35LLU] = 1813LLU/*throw to this address*/;
21012+ stack[base + 35LLU] = 1825LLU/*throw to this address*/;
2091121013 stack[base + 36LLU] = base;
20912- stack[base + 37LLU] = 1814LLU;
21014+ stack[base + 37LLU] = 1826LLU;
2091321015 // arguments for call to printid
2091421016 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2091521017 // set stack-base & callee-address
@@ -20917,21 +21019,21 @@
2091721019 label = 18446744073709551587LLU; // printid
2091821020 break;
2091921021 }
20920- case 1813LLU: // copy-back deleter (printid to ProcCall)
21022+ case 1825LLU: // copy-back deleter (printid to ProcCall)
2092121023 {
2092221024 // copy mutable arguments back from call to printid
20923- label = 1795LLU; // continue to roll stack
21025+ label = 1807LLU; // continue to roll stack
2092421026 break;
2092521027 }
20926- case 1814LLU: // return from printid to ProcCall
21028+ case 1826LLU: // return from printid to ProcCall
2092721029 {
2092821030 // copy mutable arguments back from call to printid
2092921031 printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
2093021032 printf("%s", "\n newstack[1] = ");
2093121033 // call printnr from ProcCall
20932- stack[base + 35LLU] = 1815LLU/*throw to this address*/;
21034+ stack[base + 35LLU] = 1827LLU/*throw to this address*/;
2093321035 stack[base + 36LLU] = base;
20934- stack[base + 37LLU] = 1816LLU;
21036+ stack[base + 37LLU] = 1828LLU;
2093521037 // arguments for call to printnr
2093621038 stack[base + 38LLU] = stack[base + 33]/*labelfail*/;
2093721039 // set stack-base & callee-address
@@ -20939,21 +21041,21 @@
2093921041 label = 18446744073709551590LLU; // printnr
2094021042 break;
2094121043 }
20942- case 1815LLU: // copy-back deleter (printnr to ProcCall)
21044+ case 1827LLU: // copy-back deleter (printnr to ProcCall)
2094321045 {
2094421046 // copy mutable arguments back from call to printnr
20945- label = 1795LLU; // continue to roll stack
21047+ label = 1807LLU; // continue to roll stack
2094621048 break;
2094721049 }
20948- case 1816LLU: // return from printnr to ProcCall
21050+ case 1828LLU: // return from printnr to ProcCall
2094921051 {
2095021052 // copy mutable arguments back from call to printnr
2095121053 printf("%s", "LLU;");
2095221054 printf("%s", "\n newstack[2] = base;");
2095321055 // call add from ProcCall
20954- stack[base + 35LLU] = 1817LLU/*throw to this address*/;
21056+ stack[base + 35LLU] = 1829LLU/*throw to this address*/;
2095521057 stack[base + 36LLU] = base;
20956- stack[base + 37LLU] = 1818LLU;
21058+ stack[base + 37LLU] = 1830LLU;
2095721059 // arguments for call to add
2095821060 stack[base + 39LLU] = 1LLU;
2095921061 stack[base + 40LLU] = stack[base + 17]/*label*/;
@@ -20962,13 +21064,13 @@
2096221064 label = 18446744073709551605LLU; // add
2096321065 break;
2096421066 }
20965- case 1817LLU: // copy-back deleter (add to ProcCall)
21067+ case 1829LLU: // copy-back deleter (add to ProcCall)
2096621068 {
2096721069 // copy mutable arguments back from call to add
20968- label = 1795LLU; // continue to roll stack
21070+ label = 1807LLU; // continue to roll stack
2096921071 break;
2097021072 }
20971- case 1818LLU: // return from add to ProcCall
21073+ case 1830LLU: // return from add to ProcCall
2097221074 {
2097321075 // copy mutable arguments back from call to add
2097421076 // copy back results provided by call to add
@@ -20975,9 +21077,9 @@
2097521077 stack[base + 17] = stack[base + 38LLU];
2097621078 printf("%s", "\n newstack[3] = ");
2097721079 // call printnr from ProcCall
20978- stack[base + 35LLU] = 1819LLU/*throw to this address*/;
21080+ stack[base + 35LLU] = 1831LLU/*throw to this address*/;
2097921081 stack[base + 36LLU] = base;
20980- stack[base + 37LLU] = 1820LLU;
21082+ stack[base + 37LLU] = 1832LLU;
2098121083 // arguments for call to printnr
2098221084 stack[base + 38LLU] = stack[base + 17]/*label*/;
2098321085 // set stack-base & callee-address
@@ -20985,13 +21087,13 @@
2098521087 label = 18446744073709551590LLU; // printnr
2098621088 break;
2098721089 }
20988- case 1819LLU: // copy-back deleter (printnr to ProcCall)
21090+ case 1831LLU: // copy-back deleter (printnr to ProcCall)
2098921091 {
2099021092 // copy mutable arguments back from call to printnr
20991- label = 1795LLU; // continue to roll stack
21093+ label = 1807LLU; // continue to roll stack
2099221094 break;
2099321095 }
20994- case 1820LLU: // return from printnr to ProcCall
21096+ case 1832LLU: // return from printnr to ProcCall
2099521097 {
2099621098 // copy mutable arguments back from call to printnr
2099721099 printf("%s", "LLU;");
@@ -20998,9 +21100,9 @@
2099821100 stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
2099921101 printf("%s", "\n // arguments for call to ");
2100021102 // call printid from ProcCall
21001- stack[base + 35LLU] = 1821LLU/*throw to this address*/;
21103+ stack[base + 35LLU] = 1833LLU/*throw to this address*/;
2100221104 stack[base + 36LLU] = base;
21003- stack[base + 37LLU] = 1822LLU;
21105+ stack[base + 37LLU] = 1834LLU;
2100421106 // arguments for call to printid
2100521107 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2100621108 // set stack-base & callee-address
@@ -21008,41 +21110,41 @@
2100821110 label = 18446744073709551587LLU; // printid
2100921111 break;
2101021112 }
21011- case 1821LLU: // copy-back deleter (printid to ProcCall)
21113+ case 1833LLU: // copy-back deleter (printid to ProcCall)
2101221114 {
2101321115 // copy mutable arguments back from call to printid
21014- label = 1795LLU; // continue to roll stack
21116+ label = 1807LLU; // continue to roll stack
2101521117 break;
2101621118 }
21017- case 1822LLU: // return from printid to ProcCall
21119+ case 1834LLU: // return from printid to ProcCall
2101821120 {
2101921121 // copy mutable arguments back from call to printid
21020- label = 1824LLU; // skip deleter
21122+ label = 1836LLU; // skip deleter
2102121123 break;
2102221124 }
21023- case 1823LLU: // deleter
21125+ case 1835LLU: // deleter
2102421126 {
2102521127 // throw from ProcCall
2102621128 if(!stack[base + 35])
2102721129 {
21028- label = 1795LLU; // skip, variable already deleted/unscoped
21130+ label = 1807LLU; // skip, variable already deleted/unscoped
2102921131 break;
2103021132 }
21031- label = 1795LLU; // continue unrolling stack, delete next variable
21133+ label = 1807LLU; // continue unrolling stack, delete next variable
2103221134 break;
2103321135 }
21034- case 1824LLU: // skipped deleter
21136+ case 1836LLU: // skipped deleter
2103521137 {
2103621138 stack[base + 35] = 0;
2103721139 flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 36]);
21038- label = 1825LLU; // start to repeat
21140+ label = 1837LLU; // start to repeat
2103921141 break;
2104021142 }
21041- case 1825LLU: // repeat from here
21143+ case 1837LLU: // repeat from here
2104221144 {
2104321145 if(!stack[base + 36])
2104421146 {
21045- label = 1826LLU; // break loop
21147+ label = 1838LLU; // break loop
2104621148 break;
2104721149 }
2104821150
@@ -21051,9 +21153,9 @@
2105121153 stack[base + 38]/*previous*/ = stack[base + 36];
2105221154 stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
2105321155 // call sub from ProcCall
21054- stack[base + 39LLU] = 1828LLU/*throw to this address*/;
21156+ stack[base + 39LLU] = 1840LLU/*throw to this address*/;
2105521157 stack[base + 40LLU] = base;
21056- stack[base + 41LLU] = 1829LLU;
21158+ stack[base + 41LLU] = 1841LLU;
2105721159 // arguments for call to sub
2105821160 stack[base + 43LLU] = stack[base + 29]/*ceargcount*/;
2105921161 stack[base + 44LLU] = stack[base + 31]/*n*/;
@@ -21062,21 +21164,21 @@
2106221164 label = 18446744073709551604LLU; // sub
2106321165 break;
2106421166 }
21065- case 1828LLU: // copy-back deleter (sub to ProcCall)
21167+ case 1840LLU: // copy-back deleter (sub to ProcCall)
2106621168 {
2106721169 // copy mutable arguments back from call to sub
21068- label = 1827LLU; // continue to roll stack
21170+ label = 1839LLU; // continue to roll stack
2106921171 break;
2107021172 }
21071- case 1829LLU: // return from sub to ProcCall
21173+ case 1841LLU: // return from sub to ProcCall
2107221174 {
2107321175 // copy mutable arguments back from call to sub
2107421176 // copy back results provided by call to sub
2107521177 stack[base + 32] = stack[base + 42LLU];
2107621178 // call sub from ProcCall
21077- stack[base + 39LLU] = 1830LLU/*throw to this address*/;
21179+ stack[base + 39LLU] = 1842LLU/*throw to this address*/;
2107821180 stack[base + 40LLU] = base;
21079- stack[base + 41LLU] = 1831LLU;
21181+ stack[base + 41LLU] = 1843LLU;
2108021182 // arguments for call to sub
2108121183 stack[base + 43LLU] = stack[base + 31]/*n*/;
2108221184 stack[base + 44LLU] = 1LLU;
@@ -21085,13 +21187,13 @@
2108521187 label = 18446744073709551604LLU; // sub
2108621188 break;
2108721189 }
21088- case 1830LLU: // copy-back deleter (sub to ProcCall)
21190+ case 1842LLU: // copy-back deleter (sub to ProcCall)
2108921191 {
2109021192 // copy mutable arguments back from call to sub
21091- label = 1827LLU; // continue to roll stack
21193+ label = 1839LLU; // continue to roll stack
2109221194 break;
2109321195 }
21094- case 1831LLU: // return from sub to ProcCall
21196+ case 1843LLU: // return from sub to ProcCall
2109521197 {
2109621198 // copy mutable arguments back from call to sub
2109721199 // copy back results provided by call to sub
@@ -21098,15 +21200,15 @@
2109821200 stack[base + 31] = stack[base + 42LLU];
2109921201 if(!stack[base + 32]/*index*/)
2110021202 {
21101- label = 1832LLU; // jump to alternative
21203+ label = 1844LLU; // jump to alternative
2110221204 break;
2110321205 }
2110421206
2110521207 // consequent
2110621208 // call matchsym from ProcCall
21107- stack[base + 39LLU] = 1834LLU/*throw to this address*/;
21209+ stack[base + 39LLU] = 1846LLU/*throw to this address*/;
2110821210 stack[base + 40LLU] = base;
21109- stack[base + 41LLU] = 1835LLU;
21211+ stack[base + 41LLU] = 1847LLU;
2111021212 // arguments for call to matchsym
2111121213 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2111221214 stack[base + 43LLU] = 44LLU;
@@ -21116,32 +21218,32 @@
2111621218 label = 246LLU; // matchsym
2111721219 break;
2111821220 }
21119- case 1834LLU: // copy-back deleter (matchsym to ProcCall)
21221+ case 1846LLU: // copy-back deleter (matchsym to ProcCall)
2112021222 {
2112121223 // copy mutable arguments back from call to matchsym
2112221224 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
21123- label = 1827LLU; // continue to roll stack
21225+ label = 1839LLU; // continue to roll stack
2112421226 break;
2112521227 }
21126- case 1835LLU: // return from matchsym to ProcCall
21228+ case 1847LLU: // return from matchsym to ProcCall
2112721229 {
2112821230 // copy mutable arguments back from call to matchsym
2112921231 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
21130- label = 1833LLU; // consequent complete
21232+ label = 1845LLU; // consequent complete
2113121233 break;
2113221234 }
21133- case 1832LLU: // alternative
21235+ case 1844LLU: // alternative
2113421236 {
21135- label = 1833LLU; // alternative complete
21237+ label = 1845LLU; // alternative complete
2113621238 break;
2113721239 }
21138- case 1833LLU: // completed if-then-else
21240+ case 1845LLU: // completed if-then-else
2113921241 {
2114021242 stack[base + 30]/*sum*/ = 0;
2114121243 // call add from ProcCall
21142- stack[base + 39LLU] = 1836LLU/*throw to this address*/;
21244+ stack[base + 39LLU] = 1848LLU/*throw to this address*/;
2114321245 stack[base + 40LLU] = base;
21144- stack[base + 41LLU] = 1837LLU;
21246+ stack[base + 41LLU] = 1849LLU;
2114521247 // arguments for call to add
2114621248 stack[base + 43LLU] = 4LLU;
2114721249 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21150,21 +21252,21 @@
2115021252 label = 18446744073709551605LLU; // add
2115121253 break;
2115221254 }
21153- case 1836LLU: // copy-back deleter (add to ProcCall)
21255+ case 1848LLU: // copy-back deleter (add to ProcCall)
2115421256 {
2115521257 // copy mutable arguments back from call to add
21156- label = 1827LLU; // continue to roll stack
21258+ label = 1839LLU; // continue to roll stack
2115721259 break;
2115821260 }
21159- case 1837LLU: // return from add to ProcCall
21261+ case 1849LLU: // return from add to ProcCall
2116021262 {
2116121263 // copy mutable arguments back from call to add
2116221264 // copy back results provided by call to add
2116321265 stack[base + 30] = stack[base + 42LLU];
2116421266 // call add from ProcCall
21165- stack[base + 39LLU] = 1838LLU/*throw to this address*/;
21267+ stack[base + 39LLU] = 1850LLU/*throw to this address*/;
2116621268 stack[base + 40LLU] = base;
21167- stack[base + 41LLU] = 1839LLU;
21269+ stack[base + 41LLU] = 1851LLU;
2116821270 // arguments for call to add
2116921271 stack[base + 43LLU] = stack[base + 28]/*cerescount*/;
2117021272 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21173,21 +21275,21 @@
2117321275 label = 18446744073709551605LLU; // add
2117421276 break;
2117521277 }
21176- case 1838LLU: // copy-back deleter (add to ProcCall)
21278+ case 1850LLU: // copy-back deleter (add to ProcCall)
2117721279 {
2117821280 // copy mutable arguments back from call to add
21179- label = 1827LLU; // continue to roll stack
21281+ label = 1839LLU; // continue to roll stack
2118021282 break;
2118121283 }
21182- case 1839LLU: // return from add to ProcCall
21284+ case 1851LLU: // return from add to ProcCall
2118321285 {
2118421286 // copy mutable arguments back from call to add
2118521287 // copy back results provided by call to add
2118621288 stack[base + 30] = stack[base + 42LLU];
2118721289 // call add from ProcCall
21188- stack[base + 39LLU] = 1840LLU/*throw to this address*/;
21290+ stack[base + 39LLU] = 1852LLU/*throw to this address*/;
2118921291 stack[base + 40LLU] = base;
21190- stack[base + 41LLU] = 1841LLU;
21292+ stack[base + 41LLU] = 1853LLU;
2119121293 // arguments for call to add
2119221294 stack[base + 43LLU] = stack[base + 32]/*index*/;
2119321295 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21196,13 +21298,13 @@
2119621298 label = 18446744073709551605LLU; // add
2119721299 break;
2119821300 }
21199- case 1840LLU: // copy-back deleter (add to ProcCall)
21301+ case 1852LLU: // copy-back deleter (add to ProcCall)
2120021302 {
2120121303 // copy mutable arguments back from call to add
21202- label = 1827LLU; // continue to roll stack
21304+ label = 1839LLU; // continue to roll stack
2120321305 break;
2120421306 }
21205- case 1841LLU: // return from add to ProcCall
21307+ case 1853LLU: // return from add to ProcCall
2120621308 {
2120721309 // copy mutable arguments back from call to add
2120821310 // copy back results provided by call to add
@@ -21209,7 +21311,7 @@
2120921311 stack[base + 30] = stack[base + 42LLU];
2121021312 if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0])
2121121313 {
21212- label = 1843LLU; // jump to alternative
21314+ label = 1855LLU; // jump to alternative
2121321315 break;
2121421316 }
2121521317
@@ -21219,7 +21321,7 @@
2121921321 // case
2122021322 if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0])
2122121323 {
21222- label = 1846LLU; // jump to alternative
21324+ label = 1858LLU; // jump to alternative
2122321325 break;
2122421326 }
2122521327
@@ -21228,9 +21330,9 @@
2122821330
2122921331 // case
2123021332 // call ParseToken from ProcCall
21231- stack[base + 43LLU] = 1848LLU/*throw to this address*/;
21333+ stack[base + 43LLU] = 1860LLU/*throw to this address*/;
2123221334 stack[base + 44LLU] = base;
21233- stack[base + 45LLU] = 1849LLU;
21335+ stack[base + 45LLU] = 1861LLU;
2123421336 // arguments for call to ParseToken
2123521337 stack[base + 48LLU] = stack[base + 14]/*lookahead*/;
2123621338 // set stack-base & callee-address
@@ -21238,14 +21340,14 @@
2123821340 label = 3LLU; // ParseToken
2123921341 break;
2124021342 }
21241- case 1848LLU: // copy-back deleter (ParseToken to ProcCall)
21343+ case 1860LLU: // copy-back deleter (ParseToken to ProcCall)
2124221344 {
2124321345 // copy mutable arguments back from call to ParseToken
2124421346 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21245- label = 1847LLU; // continue to roll stack
21347+ label = 1859LLU; // continue to roll stack
2124621348 break;
2124721349 }
21248- case 1849LLU: // return from ParseToken to ProcCall
21350+ case 1861LLU: // return from ParseToken to ProcCall
2124921351 {
2125021352 // copy mutable arguments back from call to ParseToken
2125121353 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
@@ -21253,9 +21355,9 @@
2125321355 stack[base + 15] = stack[base + 46LLU];
2125421356 stack[base + 16] = stack[base + 47LLU];
2125521357 // call isncs from ProcCall
21256- stack[base + 43LLU] = 1850LLU/*throw to this address*/;
21358+ stack[base + 43LLU] = 1862LLU/*throw to this address*/;
2125721359 stack[base + 44LLU] = base;
21258- stack[base + 45LLU] = 1851LLU;
21360+ stack[base + 45LLU] = 1863LLU;
2125921361 // arguments for call to isncs
2126021362 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2126121363 // set stack-base & callee-address
@@ -21263,13 +21365,13 @@
2126321365 label = 286LLU; // isncs
2126421366 break;
2126521367 }
21266- case 1850LLU: // copy-back deleter (isncs to ProcCall)
21368+ case 1862LLU: // copy-back deleter (isncs to ProcCall)
2126721369 {
2126821370 // copy mutable arguments back from call to isncs
21269- label = 1847LLU; // continue to roll stack
21371+ label = 1859LLU; // continue to roll stack
2127021372 break;
2127121373 }
21272- case 1851LLU: // return from isncs to ProcCall
21374+ case 1863LLU: // return from isncs to ProcCall
2127321375 {
2127421376 // copy mutable arguments back from call to isncs
2127521377 // copy back results provided by call to isncs
@@ -21276,20 +21378,20 @@
2127621378 stack[base + 18] = stack[base + 46LLU];
2127721379 if(!stack[base + 18]/*isequal*/)
2127821380 {
21279- label = 1852LLU; // jump to alternative
21381+ label = 1864LLU; // jump to alternative
2128021382 break;
2128121383 }
2128221384
2128321385 // consequent
21284- label = 1855LLU; // skip deleter
21386+ label = 1867LLU; // skip deleter
2128521387 break;
2128621388 }
21287- case 1854LLU: // deleter
21389+ case 1866LLU: // deleter
2128821390 {
2128921391 // throw from ProcCall
2129021392 if(!stack[base + 43])
2129121393 {
21292- label = 1847LLU; // skip, variable already deleted/unscoped
21394+ label = 1859LLU; // skip, variable already deleted/unscoped
2129321395 break;
2129421396 }
2129521397
@@ -21298,7 +21400,7 @@
2129821400 newstack[0] = (uint64_t)stack; // backup stack location
2129921401 newstack[1] = 1234567890;
2130021402 newstack[2] = base;
21301- newstack[3] = 1856LLU;
21403+ newstack[3] = 1868LLU;
2130221404 stack = newstack;
2130321405 // set stack-base & callee-address
2130421406 base = 4/*deloffset*/;
@@ -21305,21 +21407,21 @@
2130521407 label = 310LLU; // ~type
2130621408 break;
2130721409 }
21308- case 1856LLU: // return from ~type to ProcCall
21410+ case 1868LLU: // return from ~type to ProcCall
2130921411 {
2131021412 stack = (uint64_t *)stack[0];
2131121413 // releasing toplevel container
2131221414 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2131321415
21314- label = 1847LLU; // continue unrolling stack, delete next variable
21416+ label = 1859LLU; // continue unrolling stack, delete next variable
2131521417 break;
2131621418 }
21317- case 1855LLU: // skipped deleter
21419+ case 1867LLU: // skipped deleter
2131821420 {
2131921421 // call mktypedata from ProcCall
21320- stack[base + 44LLU] = 1857LLU/*throw to this address*/;
21422+ stack[base + 44LLU] = 1869LLU/*throw to this address*/;
2132121423 stack[base + 45LLU] = base;
21322- stack[base + 46LLU] = 1858LLU;
21424+ stack[base + 46LLU] = 1870LLU;
2132321425 // arguments for call to mktypedata
2132421426 stack[base + 48LLU] = 881834713755418624LLU;
2132521427 // set stack-base & callee-address
@@ -21327,13 +21429,13 @@
2132721429 label = 314LLU; // mktypedata
2132821430 break;
2132921431 }
21330- case 1857LLU: // copy-back deleter (mktypedata to ProcCall)
21432+ case 1869LLU: // copy-back deleter (mktypedata to ProcCall)
2133121433 {
2133221434 // copy mutable arguments back from call to mktypedata
21333- label = 1847LLU; // continue to roll stack
21435+ label = 1859LLU; // continue to roll stack
2133421436 break;
2133521437 }
21336- case 1858LLU: // return from mktypedata to ProcCall
21438+ case 1870LLU: // return from mktypedata to ProcCall
2133721439 {
2133821440 // copy mutable arguments back from call to mktypedata
2133921441 // copy back results provided by call to mktypedata
@@ -21341,7 +21443,7 @@
2134121443 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2134221444 if(!newstack)
2134321445 {
21344- label = 1854LLU; // throw: begin to unroll stack
21446+ label = 1866LLU; // throw: begin to unroll stack
2134521447 break;
2134621448 }
2134721449
@@ -21348,9 +21450,9 @@
2134821450 newstack[15LLU] = 9876543210LLU; // overflow-marker
2134921451 // call equtype from ProcCall
2135021452 newstack[0] = (uint64_t)stack; // backup stack location
21351- newstack[1] = 1859LLU;
21453+ newstack[1] = 1871LLU;
2135221454 newstack[2] = base;
21353- newstack[3] = 1860LLU;
21455+ newstack[3] = 1872LLU;
2135421456 // arguments for call to equtype
2135521457 newstack[5LLU] = stack[base + 43]/*type*/;
2135621458 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -21360,7 +21462,7 @@
2136021462 label = 359LLU; // equtype
2136121463 break;
2136221464 }
21363- case 1859LLU: // copy-back deleter (equtype to ProcCall)
21465+ case 1871LLU: // copy-back deleter (equtype to ProcCall)
2136421466 {
2136521467 uint64_t *oldstack = (uint64_t *)stack[0];
2136621468 // copy mutable arguments back from call to equtype
@@ -21371,10 +21473,10 @@
2137121473 }
2137221474 Free(15LLU + 1, sizeof(uint64_t), stack);
2137321475 stack = oldstack;
21374- label = 1854LLU; // continue to unroll stack
21476+ label = 1866LLU; // continue to unroll stack
2137521477 break;
2137621478 }
21377- case 1860LLU: // return from equtype to ProcCall
21479+ case 1872LLU: // return from equtype to ProcCall
2137821480 {
2137921481 uint64_t *oldstack = (uint64_t *)stack[0];
2138021482 // copy mutable arguments back from call to equtype
@@ -21389,21 +21491,21 @@
2138921491 stack = oldstack;
2139021492 if(!stack[base + 18]/*isequal*/)
2139121493 {
21392- label = 1861LLU; // jump to alternative
21494+ label = 1873LLU; // jump to alternative
2139321495 break;
2139421496 }
2139521497
2139621498 // consequent
21397- label = 1862LLU; // consequent complete
21499+ label = 1874LLU; // consequent complete
2139821500 break;
2139921501 }
21400- case 1861LLU: // alternative
21502+ case 1873LLU: // alternative
2140121503 {
2140221504 fprintf(stderr, "%s", "in function ");
2140321505 // call reportid from ProcCall
21404- stack[base + 44LLU] = 1863LLU/*throw to this address*/;
21506+ stack[base + 44LLU] = 1875LLU/*throw to this address*/;
2140521507 stack[base + 45LLU] = base;
21406- stack[base + 46LLU] = 1864LLU;
21508+ stack[base + 46LLU] = 1876LLU;
2140721509 // arguments for call to reportid
2140821510 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2140921511 // set stack-base & callee-address
@@ -21411,20 +21513,20 @@
2141121513 label = 18446744073709551586LLU; // reportid
2141221514 break;
2141321515 }
21414- case 1863LLU: // copy-back deleter (reportid to ProcCall)
21516+ case 1875LLU: // copy-back deleter (reportid to ProcCall)
2141521517 {
2141621518 // copy mutable arguments back from call to reportid
21417- label = 1854LLU; // continue to roll stack
21519+ label = 1866LLU; // continue to roll stack
2141821520 break;
2141921521 }
21420- case 1864LLU: // return from reportid to ProcCall
21522+ case 1876LLU: // return from reportid to ProcCall
2142121523 {
2142221524 // copy mutable arguments back from call to reportid
2142321525 fprintf(stderr, "%s", " call to ");
2142421526 // call reportid from ProcCall
21425- stack[base + 44LLU] = 1865LLU/*throw to this address*/;
21527+ stack[base + 44LLU] = 1877LLU/*throw to this address*/;
2142621528 stack[base + 45LLU] = base;
21427- stack[base + 46LLU] = 1866LLU;
21529+ stack[base + 46LLU] = 1878LLU;
2142821530 // arguments for call to reportid
2142921531 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2143021532 // set stack-base & callee-address
@@ -21432,20 +21534,20 @@
2143221534 label = 18446744073709551586LLU; // reportid
2143321535 break;
2143421536 }
21435- case 1865LLU: // copy-back deleter (reportid to ProcCall)
21537+ case 1877LLU: // copy-back deleter (reportid to ProcCall)
2143621538 {
2143721539 // copy mutable arguments back from call to reportid
21438- label = 1854LLU; // continue to roll stack
21540+ label = 1866LLU; // continue to roll stack
2143921541 break;
2144021542 }
21441- case 1866LLU: // return from reportid to ProcCall
21543+ case 1878LLU: // return from reportid to ProcCall
2144221544 {
2144321545 // copy mutable arguments back from call to reportid
2144421546 fprintf(stderr, "%s", " at position ");
2144521547 // call reportnr from ProcCall
21446- stack[base + 44LLU] = 1867LLU/*throw to this address*/;
21548+ stack[base + 44LLU] = 1879LLU/*throw to this address*/;
2144721549 stack[base + 45LLU] = base;
21448- stack[base + 46LLU] = 1868LLU;
21550+ stack[base + 46LLU] = 1880LLU;
2144921551 // arguments for call to reportnr
2145021552 stack[base + 47LLU] = stack[base + 32]/*index*/;
2145121553 // set stack-base & callee-address
@@ -21453,13 +21555,13 @@
2145321555 label = 18446744073709551589LLU; // reportnr
2145421556 break;
2145521557 }
21456- case 1867LLU: // copy-back deleter (reportnr to ProcCall)
21558+ case 1879LLU: // copy-back deleter (reportnr to ProcCall)
2145721559 {
2145821560 // copy mutable arguments back from call to reportnr
21459- label = 1854LLU; // continue to roll stack
21561+ label = 1866LLU; // continue to roll stack
2146021562 break;
2146121563 }
21462- case 1868LLU: // return from reportnr to ProcCall
21564+ case 1880LLU: // return from reportnr to ProcCall
2146321565 {
2146421566 // copy mutable arguments back from call to reportnr
2146521567 fprintf(stderr, "%s", " expected parameter of type ");
@@ -21466,7 +21568,7 @@
2146621568 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2146721569 if(!newstack)
2146821570 {
21469- label = 1854LLU; // throw: begin to unroll stack
21571+ label = 1866LLU; // throw: begin to unroll stack
2147021572 break;
2147121573 }
2147221574
@@ -21473,9 +21575,9 @@
2147321575 newstack[10LLU] = 9876543210LLU; // overflow-marker
2147421576 // call reporttype from ProcCall
2147521577 newstack[0] = (uint64_t)stack; // backup stack location
21476- newstack[1] = 1869LLU;
21578+ newstack[1] = 1881LLU;
2147721579 newstack[2] = base;
21478- newstack[3] = 1870LLU;
21580+ newstack[3] = 1882LLU;
2147921581 // arguments for call to reporttype
2148021582 newstack[4LLU] = stack[base + 41]/*expected*/;
2148121583 stack = newstack;
@@ -21484,7 +21586,7 @@
2148421586 label = 330LLU; // reporttype
2148521587 break;
2148621588 }
21487- case 1869LLU: // copy-back deleter (reporttype to ProcCall)
21589+ case 1881LLU: // copy-back deleter (reporttype to ProcCall)
2148821590 {
2148921591 uint64_t *oldstack = (uint64_t *)stack[0];
2149021592 // copy mutable arguments back from call to reporttype
@@ -21495,10 +21597,10 @@
2149521597 }
2149621598 Free(10LLU + 1, sizeof(uint64_t), stack);
2149721599 stack = oldstack;
21498- label = 1854LLU; // continue to unroll stack
21600+ label = 1866LLU; // continue to unroll stack
2149921601 break;
2150021602 }
21501- case 1870LLU: // return from reporttype to ProcCall
21603+ case 1882LLU: // return from reporttype to ProcCall
2150221604 {
2150321605 uint64_t *oldstack = (uint64_t *)stack[0];
2150421606 // copy mutable arguments back from call to reporttype
@@ -21512,18 +21614,18 @@
2151221614 fprintf(stderr, "%s", " but found constant-argument of type u64");
2151321615 fprintf(stderr, "%s", "\n");
2151421616 {
21515- label = 1854LLU; // throw: begin to unroll stack
21617+ label = 1866LLU; // throw: begin to unroll stack
2151621618 break;
2151721619 }
2151821620
21519- label = 1862LLU; // alternative complete
21621+ label = 1874LLU; // alternative complete
2152021622 break;
2152121623 }
21522- case 1862LLU: // completed if-then-else
21624+ case 1874LLU: // completed if-then-else
2152321625 {
2152421626 if(!stack[base + 40]/*mutable*/)
2152521627 {
21526- label = 1871LLU; // jump to alternative
21628+ label = 1883LLU; // jump to alternative
2152721629 break;
2152821630 }
2152921631
@@ -21530,9 +21632,9 @@
2153021632 // consequent
2153121633 fprintf(stderr, "%s", "in function ");
2153221634 // call reportid from ProcCall
21533- stack[base + 44LLU] = 1873LLU/*throw to this address*/;
21635+ stack[base + 44LLU] = 1885LLU/*throw to this address*/;
2153421636 stack[base + 45LLU] = base;
21535- stack[base + 46LLU] = 1874LLU;
21637+ stack[base + 46LLU] = 1886LLU;
2153621638 // arguments for call to reportid
2153721639 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2153821640 // set stack-base & callee-address
@@ -21540,20 +21642,20 @@
2154021642 label = 18446744073709551586LLU; // reportid
2154121643 break;
2154221644 }
21543- case 1873LLU: // copy-back deleter (reportid to ProcCall)
21645+ case 1885LLU: // copy-back deleter (reportid to ProcCall)
2154421646 {
2154521647 // copy mutable arguments back from call to reportid
21546- label = 1854LLU; // continue to roll stack
21648+ label = 1866LLU; // continue to roll stack
2154721649 break;
2154821650 }
21549- case 1874LLU: // return from reportid to ProcCall
21651+ case 1886LLU: // return from reportid to ProcCall
2155021652 {
2155121653 // copy mutable arguments back from call to reportid
2155221654 fprintf(stderr, "%s", ", calling ");
2155321655 // call reportid from ProcCall
21554- stack[base + 44LLU] = 1875LLU/*throw to this address*/;
21656+ stack[base + 44LLU] = 1887LLU/*throw to this address*/;
2155521657 stack[base + 45LLU] = base;
21556- stack[base + 46LLU] = 1876LLU;
21658+ stack[base + 46LLU] = 1888LLU;
2155721659 // arguments for call to reportid
2155821660 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2155921661 // set stack-base & callee-address
@@ -21561,21 +21663,21 @@
2156121663 label = 18446744073709551586LLU; // reportid
2156221664 break;
2156321665 }
21564- case 1875LLU: // copy-back deleter (reportid to ProcCall)
21666+ case 1887LLU: // copy-back deleter (reportid to ProcCall)
2156521667 {
2156621668 // copy mutable arguments back from call to reportid
21567- label = 1854LLU; // continue to roll stack
21669+ label = 1866LLU; // continue to roll stack
2156821670 break;
2156921671 }
21570- case 1876LLU: // return from reportid to ProcCall
21672+ case 1888LLU: // return from reportid to ProcCall
2157121673 {
2157221674 // copy mutable arguments back from call to reportid
2157321675 fprintf(stderr, "%s", ": ");
2157421676 fprintf(stderr, "%s", "can't use constant argument ");
2157521677 // call printnr from ProcCall
21576- stack[base + 44LLU] = 1877LLU/*throw to this address*/;
21678+ stack[base + 44LLU] = 1889LLU/*throw to this address*/;
2157721679 stack[base + 45LLU] = base;
21578- stack[base + 46LLU] = 1878LLU;
21680+ stack[base + 46LLU] = 1890LLU;
2157921681 // arguments for call to printnr
2158021682 stack[base + 47LLU] = stack[base + 16]/*content*/;
2158121683 // set stack-base & callee-address
@@ -21583,20 +21685,20 @@
2158321685 label = 18446744073709551590LLU; // printnr
2158421686 break;
2158521687 }
21586- case 1877LLU: // copy-back deleter (printnr to ProcCall)
21688+ case 1889LLU: // copy-back deleter (printnr to ProcCall)
2158721689 {
2158821690 // copy mutable arguments back from call to printnr
21589- label = 1854LLU; // continue to roll stack
21691+ label = 1866LLU; // continue to roll stack
2159021692 break;
2159121693 }
21592- case 1878LLU: // return from printnr to ProcCall
21694+ case 1890LLU: // return from printnr to ProcCall
2159321695 {
2159421696 // copy mutable arguments back from call to printnr
2159521697 printf("%s", " for mutable parameter ");
2159621698 // call reportti from ProcCall
21597- stack[base + 44LLU] = 1879LLU/*throw to this address*/;
21699+ stack[base + 44LLU] = 1891LLU/*throw to this address*/;
2159821700 stack[base + 45LLU] = base;
21599- stack[base + 46LLU] = 1880LLU;
21701+ stack[base + 46LLU] = 1892LLU;
2160021702 // arguments for call to reportti
2160121703 stack[base + 47LLU] = stack[base + 39]/*typeid*/;
2160221704 // set stack-base & callee-address
@@ -21604,36 +21706,36 @@
2160421706 label = 390LLU; // reportti
2160521707 break;
2160621708 }
21607- case 1879LLU: // copy-back deleter (reportti to ProcCall)
21709+ case 1891LLU: // copy-back deleter (reportti to ProcCall)
2160821710 {
2160921711 // copy mutable arguments back from call to reportti
21610- label = 1854LLU; // continue to roll stack
21712+ label = 1866LLU; // continue to roll stack
2161121713 break;
2161221714 }
21613- case 1880LLU: // return from reportti to ProcCall
21715+ case 1892LLU: // return from reportti to ProcCall
2161421716 {
2161521717 // copy mutable arguments back from call to reportti
2161621718 fprintf(stderr, "%s", "\n");
2161721719 {
21618- label = 1854LLU; // throw: begin to unroll stack
21720+ label = 1866LLU; // throw: begin to unroll stack
2161921721 break;
2162021722 }
2162121723
21622- label = 1872LLU; // consequent complete
21724+ label = 1884LLU; // consequent complete
2162321725 break;
2162421726 }
21625- case 1871LLU: // alternative
21727+ case 1883LLU: // alternative
2162621728 {
21627- label = 1872LLU; // alternative complete
21729+ label = 1884LLU; // alternative complete
2162821730 break;
2162921731 }
21630- case 1872LLU: // completed if-then-else
21732+ case 1884LLU: // completed if-then-else
2163121733 {
2163221734 printf("%s", "\n newstack[");
2163321735 // call printnr from ProcCall
21634- stack[base + 44LLU] = 1881LLU/*throw to this address*/;
21736+ stack[base + 44LLU] = 1893LLU/*throw to this address*/;
2163521737 stack[base + 45LLU] = base;
21636- stack[base + 46LLU] = 1882LLU;
21738+ stack[base + 46LLU] = 1894LLU;
2163721739 // arguments for call to printnr
2163821740 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2163921741 // set stack-base & callee-address
@@ -21641,20 +21743,20 @@
2164121743 label = 18446744073709551590LLU; // printnr
2164221744 break;
2164321745 }
21644- case 1881LLU: // copy-back deleter (printnr to ProcCall)
21746+ case 1893LLU: // copy-back deleter (printnr to ProcCall)
2164521747 {
2164621748 // copy mutable arguments back from call to printnr
21647- label = 1854LLU; // continue to roll stack
21749+ label = 1866LLU; // continue to roll stack
2164821750 break;
2164921751 }
21650- case 1882LLU: // return from printnr to ProcCall
21752+ case 1894LLU: // return from printnr to ProcCall
2165121753 {
2165221754 // copy mutable arguments back from call to printnr
2165321755 printf("%s", "LLU] = ");
2165421756 // call printnr from ProcCall
21655- stack[base + 44LLU] = 1883LLU/*throw to this address*/;
21757+ stack[base + 44LLU] = 1895LLU/*throw to this address*/;
2165621758 stack[base + 45LLU] = base;
21657- stack[base + 46LLU] = 1884LLU;
21759+ stack[base + 46LLU] = 1896LLU;
2165821760 // arguments for call to printnr
2165921761 stack[base + 47LLU] = stack[base + 16]/*content*/;
2166021762 // set stack-base & callee-address
@@ -21662,20 +21764,20 @@
2166221764 label = 18446744073709551590LLU; // printnr
2166321765 break;
2166421766 }
21665- case 1883LLU: // copy-back deleter (printnr to ProcCall)
21767+ case 1895LLU: // copy-back deleter (printnr to ProcCall)
2166621768 {
2166721769 // copy mutable arguments back from call to printnr
21668- label = 1854LLU; // continue to roll stack
21770+ label = 1866LLU; // continue to roll stack
2166921771 break;
2167021772 }
21671- case 1884LLU: // return from printnr to ProcCall
21773+ case 1896LLU: // return from printnr to ProcCall
2167221774 {
2167321775 // copy mutable arguments back from call to printnr
2167421776 printf("%s", "LLU; // ");
2167521777 // call printid from ProcCall
21676- stack[base + 44LLU] = 1885LLU/*throw to this address*/;
21778+ stack[base + 44LLU] = 1897LLU/*throw to this address*/;
2167721779 stack[base + 45LLU] = base;
21678- stack[base + 46LLU] = 1886LLU;
21780+ stack[base + 46LLU] = 1898LLU;
2167921781 // arguments for call to printid
2168021782 stack[base + 47LLU] = stack[base + 16]/*content*/;
2168121783 // set stack-base & callee-address
@@ -21683,13 +21785,13 @@
2168321785 label = 18446744073709551587LLU; // printid
2168421786 break;
2168521787 }
21686- case 1885LLU: // copy-back deleter (printid to ProcCall)
21788+ case 1897LLU: // copy-back deleter (printid to ProcCall)
2168721789 {
2168821790 // copy mutable arguments back from call to printid
21689- label = 1854LLU; // continue to roll stack
21791+ label = 1866LLU; // continue to roll stack
2169021792 break;
2169121793 }
21692- case 1886LLU: // return from printid to ProcCall
21794+ case 1898LLU: // return from printid to ProcCall
2169321795 {
2169421796 // copy mutable arguments back from call to printid
2169521797
@@ -21698,7 +21800,7 @@
2169821800 newstack[0] = (uint64_t)stack; // backup stack location
2169921801 newstack[1] = 1234567890;
2170021802 newstack[2] = base;
21701- newstack[3] = 1887LLU;
21803+ newstack[3] = 1899LLU;
2170221804 stack = newstack;
2170321805 // set stack-base & callee-address
2170421806 base = 4/*deloffset*/;
@@ -21705,21 +21807,21 @@
2170521807 label = 310LLU; // ~type
2170621808 break;
2170721809 }
21708- case 1887LLU: // return from ~type to ProcCall
21810+ case 1899LLU: // return from ~type to ProcCall
2170921811 {
2171021812 stack = (uint64_t *)stack[0];
2171121813 // releasing toplevel container
2171221814 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2171321815
21714- label = 1853LLU; // consequent complete
21816+ label = 1865LLU; // consequent complete
2171521817 break;
2171621818 }
21717- case 1852LLU: // alternative
21819+ case 1864LLU: // alternative
2171821820 {
2171921821 // call equ from ProcCall
21720- stack[base + 43LLU] = 1888LLU/*throw to this address*/;
21822+ stack[base + 43LLU] = 1900LLU/*throw to this address*/;
2172121823 stack[base + 44LLU] = base;
21722- stack[base + 45LLU] = 1889LLU;
21824+ stack[base + 45LLU] = 1901LLU;
2172321825 // arguments for call to equ
2172421826 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2172521827 stack[base + 48LLU] = 4LLU;
@@ -21728,13 +21830,13 @@
2172821830 label = 18446744073709551600LLU; // equ
2172921831 break;
2173021832 }
21731- case 1888LLU: // copy-back deleter (equ to ProcCall)
21833+ case 1900LLU: // copy-back deleter (equ to ProcCall)
2173221834 {
2173321835 // copy mutable arguments back from call to equ
21734- label = 1847LLU; // continue to roll stack
21836+ label = 1859LLU; // continue to roll stack
2173521837 break;
2173621838 }
21737- case 1889LLU: // return from equ to ProcCall
21839+ case 1901LLU: // return from equ to ProcCall
2173821840 {
2173921841 // copy mutable arguments back from call to equ
2174021842 // copy back results provided by call to equ
@@ -21741,15 +21843,15 @@
2174121843 stack[base + 18] = stack[base + 46LLU];
2174221844 if(!stack[base + 18]/*isequal*/)
2174321845 {
21744- label = 1890LLU; // jump to alternative
21846+ label = 1902LLU; // jump to alternative
2174521847 break;
2174621848 }
2174721849
2174821850 // consequent
2174921851 // call equ from ProcCall
21750- stack[base + 43LLU] = 1892LLU/*throw to this address*/;
21852+ stack[base + 43LLU] = 1904LLU/*throw to this address*/;
2175121853 stack[base + 44LLU] = base;
21752- stack[base + 45LLU] = 1893LLU;
21854+ stack[base + 45LLU] = 1905LLU;
2175321855 // arguments for call to equ
2175421856 stack[base + 47LLU] = stack[base + 16]/*content*/;
2175521857 stack[base + 48LLU] = 621705506259468288LLU;
@@ -21758,13 +21860,13 @@
2175821860 label = 18446744073709551600LLU; // equ
2175921861 break;
2176021862 }
21761- case 1892LLU: // copy-back deleter (equ to ProcCall)
21863+ case 1904LLU: // copy-back deleter (equ to ProcCall)
2176221864 {
2176321865 // copy mutable arguments back from call to equ
21764- label = 1847LLU; // continue to roll stack
21866+ label = 1859LLU; // continue to roll stack
2176521867 break;
2176621868 }
21767- case 1893LLU: // return from equ to ProcCall
21869+ case 1905LLU: // return from equ to ProcCall
2176821870 {
2176921871 // copy mutable arguments back from call to equ
2177021872 // copy back results provided by call to equ
@@ -21771,15 +21873,15 @@
2177121873 stack[base + 18] = stack[base + 46LLU];
2177221874 if(!stack[base + 18]/*isequal*/)
2177321875 {
21774- label = 1894LLU; // jump to alternative
21876+ label = 1906LLU; // jump to alternative
2177521877 break;
2177621878 }
2177721879
2177821880 // consequent
2177921881 // call matchsym from ProcCall
21780- stack[base + 43LLU] = 1896LLU/*throw to this address*/;
21882+ stack[base + 43LLU] = 1908LLU/*throw to this address*/;
2178121883 stack[base + 44LLU] = base;
21782- stack[base + 45LLU] = 1897LLU;
21884+ stack[base + 45LLU] = 1909LLU;
2178321885 // arguments for call to matchsym
2178421886 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2178521887 stack[base + 47LLU] = 40LLU;
@@ -21789,21 +21891,21 @@
2178921891 label = 246LLU; // matchsym
2179021892 break;
2179121893 }
21792- case 1896LLU: // copy-back deleter (matchsym to ProcCall)
21894+ case 1908LLU: // copy-back deleter (matchsym to ProcCall)
2179321895 {
2179421896 // copy mutable arguments back from call to matchsym
2179521897 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21796- label = 1847LLU; // continue to roll stack
21898+ label = 1859LLU; // continue to roll stack
2179721899 break;
2179821900 }
21799- case 1897LLU: // return from matchsym to ProcCall
21901+ case 1909LLU: // return from matchsym to ProcCall
2180021902 {
2180121903 // copy mutable arguments back from call to matchsym
2180221904 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2180321905 // call matchsym from ProcCall
21804- stack[base + 43LLU] = 1898LLU/*throw to this address*/;
21906+ stack[base + 43LLU] = 1910LLU/*throw to this address*/;
2180521907 stack[base + 44LLU] = base;
21806- stack[base + 45LLU] = 1899LLU;
21908+ stack[base + 45LLU] = 1911LLU;
2180721909 // arguments for call to matchsym
2180821910 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2180921911 stack[base + 47LLU] = 41LLU;
@@ -21813,20 +21915,20 @@
2181321915 label = 246LLU; // matchsym
2181421916 break;
2181521917 }
21816- case 1898LLU: // copy-back deleter (matchsym to ProcCall)
21918+ case 1910LLU: // copy-back deleter (matchsym to ProcCall)
2181721919 {
2181821920 // copy mutable arguments back from call to matchsym
2181921921 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21820- label = 1847LLU; // continue to roll stack
21922+ label = 1859LLU; // continue to roll stack
2182121923 break;
2182221924 }
21823- case 1899LLU: // return from matchsym to ProcCall
21925+ case 1911LLU: // return from matchsym to ProcCall
2182421926 {
2182521927 // copy mutable arguments back from call to matchsym
2182621928 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2182721929 if(/*typedata*/0 != ((uint64_t *)(stack[base + 41]/*expected*/))[0])
2182821930 {
21829- label = 1901LLU; // jump to alternative
21931+ label = 1913LLU; // jump to alternative
2183021932 break;
2183121933 }
2183221934
@@ -21834,9 +21936,9 @@
2183421936
2183521937 // case
2183621938 // call equ from ProcCall
21837- stack[base + 44LLU] = 1903LLU/*throw to this address*/;
21939+ stack[base + 44LLU] = 1915LLU/*throw to this address*/;
2183821940 stack[base + 45LLU] = base;
21839- stack[base + 46LLU] = 1904LLU;
21941+ stack[base + 46LLU] = 1916LLU;
2184021942 // arguments for call to equ
2184121943 stack[base + 48LLU] = stack[base + 43]/*name*/;
2184221944 stack[base + 49LLU] = 881834713755418624LLU;
@@ -21845,13 +21947,13 @@
2184521947 label = 18446744073709551600LLU; // equ
2184621948 break;
2184721949 }
21848- case 1903LLU: // copy-back deleter (equ to ProcCall)
21950+ case 1915LLU: // copy-back deleter (equ to ProcCall)
2184921951 {
2185021952 // copy mutable arguments back from call to equ
21851- label = 1902LLU; // continue to roll stack
21953+ label = 1914LLU; // continue to roll stack
2185221954 break;
2185321955 }
21854- case 1904LLU: // return from equ to ProcCall
21956+ case 1916LLU: // return from equ to ProcCall
2185521957 {
2185621958 // copy mutable arguments back from call to equ
2185721959 // copy back results provided by call to equ
@@ -21858,7 +21960,7 @@
2185821960 stack[base + 18] = stack[base + 47LLU];
2185921961 if(!stack[base + 18]/*isequal*/)
2186021962 {
21861- label = 1905LLU; // jump to alternative
21963+ label = 1917LLU; // jump to alternative
2186221964 break;
2186321965 }
2186421966
@@ -21865,7 +21967,7 @@
2186521967 // consequent
2186621968 if(!stack[base + 40]/*mutable*/)
2186721969 {
21868- label = 1907LLU; // jump to alternative
21970+ label = 1919LLU; // jump to alternative
2186921971 break;
2187021972 }
2187121973
@@ -21872,9 +21974,9 @@
2187221974 // consequent
2187321975 fprintf(stderr, "%s", "in function ");
2187421976 // call reportid from ProcCall
21875- stack[base + 44LLU] = 1909LLU/*throw to this address*/;
21977+ stack[base + 44LLU] = 1921LLU/*throw to this address*/;
2187621978 stack[base + 45LLU] = base;
21877- stack[base + 46LLU] = 1910LLU;
21979+ stack[base + 46LLU] = 1922LLU;
2187821980 // arguments for call to reportid
2187921981 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2188021982 // set stack-base & callee-address
@@ -21882,20 +21984,20 @@
2188221984 label = 18446744073709551586LLU; // reportid
2188321985 break;
2188421986 }
21885- case 1909LLU: // copy-back deleter (reportid to ProcCall)
21987+ case 1921LLU: // copy-back deleter (reportid to ProcCall)
2188621988 {
2188721989 // copy mutable arguments back from call to reportid
21888- label = 1902LLU; // continue to roll stack
21990+ label = 1914LLU; // continue to roll stack
2188921991 break;
2189021992 }
21891- case 1910LLU: // return from reportid to ProcCall
21993+ case 1922LLU: // return from reportid to ProcCall
2189221994 {
2189321995 // copy mutable arguments back from call to reportid
2189421996 fprintf(stderr, "%s", ", call to ");
2189521997 // call reportid from ProcCall
21896- stack[base + 44LLU] = 1911LLU/*throw to this address*/;
21998+ stack[base + 44LLU] = 1923LLU/*throw to this address*/;
2189721999 stack[base + 45LLU] = base;
21898- stack[base + 46LLU] = 1912LLU;
22000+ stack[base + 46LLU] = 1924LLU;
2189922001 // arguments for call to reportid
2190022002 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2190122003 // set stack-base & callee-address
@@ -21903,13 +22005,13 @@
2190322005 label = 18446744073709551586LLU; // reportid
2190422006 break;
2190522007 }
21906- case 1911LLU: // copy-back deleter (reportid to ProcCall)
22008+ case 1923LLU: // copy-back deleter (reportid to ProcCall)
2190722009 {
2190822010 // copy mutable arguments back from call to reportid
21909- label = 1902LLU; // continue to roll stack
22011+ label = 1914LLU; // continue to roll stack
2191022012 break;
2191122013 }
21912- case 1912LLU: // return from reportid to ProcCall
22014+ case 1924LLU: // return from reportid to ProcCall
2191322015 {
2191422016 // copy mutable arguments back from call to reportid
2191522017 fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
@@ -21916,7 +22018,7 @@
2191622018 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2191722019 if(!newstack)
2191822020 {
21919- label = 1902LLU; // throw: begin to unroll stack
22021+ label = 1914LLU; // throw: begin to unroll stack
2192022022 break;
2192122023 }
2192222024
@@ -21923,9 +22025,9 @@
2192322025 newstack[10LLU] = 9876543210LLU; // overflow-marker
2192422026 // call reporttype from ProcCall
2192522027 newstack[0] = (uint64_t)stack; // backup stack location
21926- newstack[1] = 1913LLU;
22028+ newstack[1] = 1925LLU;
2192722029 newstack[2] = base;
21928- newstack[3] = 1914LLU;
22030+ newstack[3] = 1926LLU;
2192922031 // arguments for call to reporttype
2193022032 newstack[4LLU] = stack[base + 41]/*expected*/;
2193122033 stack = newstack;
@@ -21934,7 +22036,7 @@
2193422036 label = 330LLU; // reporttype
2193522037 break;
2193622038 }
21937- case 1913LLU: // copy-back deleter (reporttype to ProcCall)
22039+ case 1925LLU: // copy-back deleter (reporttype to ProcCall)
2193822040 {
2193922041 uint64_t *oldstack = (uint64_t *)stack[0];
2194022042 // copy mutable arguments back from call to reporttype
@@ -21945,10 +22047,10 @@
2194522047 }
2194622048 Free(10LLU + 1, sizeof(uint64_t), stack);
2194722049 stack = oldstack;
21948- label = 1902LLU; // continue to unroll stack
22050+ label = 1914LLU; // continue to unroll stack
2194922051 break;
2195022052 }
21951- case 1914LLU: // return from reporttype to ProcCall
22053+ case 1926LLU: // return from reporttype to ProcCall
2195222054 {
2195322055 uint64_t *oldstack = (uint64_t *)stack[0];
2195422056 // copy mutable arguments back from call to reporttype
@@ -21960,9 +22062,9 @@
2196022062 Free(10LLU + 1, sizeof(uint64_t), stack);
2196122063 stack = oldstack;
2196222064 // call reportid from ProcCall
21963- stack[base + 44LLU] = 1915LLU/*throw to this address*/;
22065+ stack[base + 44LLU] = 1927LLU/*throw to this address*/;
2196422066 stack[base + 45LLU] = base;
21965- stack[base + 46LLU] = 1916LLU;
22067+ stack[base + 46LLU] = 1928LLU;
2196622068 // arguments for call to reportid
2196722069 stack[base + 47LLU] = stack[base + 42]/*paramname*/;
2196822070 // set stack-base & callee-address
@@ -21970,32 +22072,32 @@
2197022072 label = 18446744073709551586LLU; // reportid
2197122073 break;
2197222074 }
21973- case 1915LLU: // copy-back deleter (reportid to ProcCall)
22075+ case 1927LLU: // copy-back deleter (reportid to ProcCall)
2197422076 {
2197522077 // copy mutable arguments back from call to reportid
21976- label = 1902LLU; // continue to roll stack
22078+ label = 1914LLU; // continue to roll stack
2197722079 break;
2197822080 }
21979- case 1916LLU: // return from reportid to ProcCall
22081+ case 1928LLU: // return from reportid to ProcCall
2198022082 {
2198122083 // copy mutable arguments back from call to reportid
2198222084 fprintf(stderr, "%s", "\n");
2198322085 {
21984- label = 1902LLU; // throw: begin to unroll stack
22086+ label = 1914LLU; // throw: begin to unroll stack
2198522087 break;
2198622088 }
2198722089
21988- label = 1908LLU; // consequent complete
22090+ label = 1920LLU; // consequent complete
2198922091 break;
2199022092 }
21991- case 1907LLU: // alternative
22093+ case 1919LLU: // alternative
2199222094 {
2199322095 stack[base + 35]/*csubstruct*/ = 1;
2199422096 printf("%s", "\n newstack[");
2199522097 // call printnr from ProcCall
21996- stack[base + 44LLU] = 1917LLU/*throw to this address*/;
22098+ stack[base + 44LLU] = 1929LLU/*throw to this address*/;
2199722099 stack[base + 45LLU] = base;
21998- stack[base + 46LLU] = 1918LLU;
22100+ stack[base + 46LLU] = 1930LLU;
2199922101 // arguments for call to printnr
2200022102 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2200122103 // set stack-base & callee-address
@@ -22003,31 +22105,31 @@
2200322105 label = 18446744073709551590LLU; // printnr
2200422106 break;
2200522107 }
22006- case 1917LLU: // copy-back deleter (printnr to ProcCall)
22108+ case 1929LLU: // copy-back deleter (printnr to ProcCall)
2200722109 {
2200822110 // copy mutable arguments back from call to printnr
22009- label = 1902LLU; // continue to roll stack
22111+ label = 1914LLU; // continue to roll stack
2201022112 break;
2201122113 }
22012- case 1918LLU: // return from printnr to ProcCall
22114+ case 1930LLU: // return from printnr to ProcCall
2201322115 {
2201422116 // copy mutable arguments back from call to printnr
2201522117 printf("%s", "LLU] = getchar();");
22016- label = 1908LLU; // alternative complete
22118+ label = 1920LLU; // alternative complete
2201722119 break;
2201822120 }
22019- case 1908LLU: // completed if-then-else
22121+ case 1920LLU: // completed if-then-else
2202022122 {
22021- label = 1906LLU; // consequent complete
22123+ label = 1918LLU; // consequent complete
2202222124 break;
2202322125 }
22024- case 1905LLU: // alternative
22126+ case 1917LLU: // alternative
2202522127 {
2202622128 fprintf(stderr, "%s", "in function ");
2202722129 // call reportid from ProcCall
22028- stack[base + 44LLU] = 1919LLU/*throw to this address*/;
22130+ stack[base + 44LLU] = 1931LLU/*throw to this address*/;
2202922131 stack[base + 45LLU] = base;
22030- stack[base + 46LLU] = 1920LLU;
22132+ stack[base + 46LLU] = 1932LLU;
2203122133 // arguments for call to reportid
2203222134 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2203322135 // set stack-base & callee-address
@@ -22035,20 +22137,20 @@
2203522137 label = 18446744073709551586LLU; // reportid
2203622138 break;
2203722139 }
22038- case 1919LLU: // copy-back deleter (reportid to ProcCall)
22140+ case 1931LLU: // copy-back deleter (reportid to ProcCall)
2203922141 {
2204022142 // copy mutable arguments back from call to reportid
22041- label = 1902LLU; // continue to roll stack
22143+ label = 1914LLU; // continue to roll stack
2204222144 break;
2204322145 }
22044- case 1920LLU: // return from reportid to ProcCall
22146+ case 1932LLU: // return from reportid to ProcCall
2204522147 {
2204622148 // copy mutable arguments back from call to reportid
2204722149 fprintf(stderr, "%s", " recursive call to ");
2204822150 // call reportid from ProcCall
22049- stack[base + 44LLU] = 1921LLU/*throw to this address*/;
22151+ stack[base + 44LLU] = 1933LLU/*throw to this address*/;
2205022152 stack[base + 45LLU] = base;
22051- stack[base + 46LLU] = 1922LLU;
22153+ stack[base + 46LLU] = 1934LLU;
2205222154 // arguments for call to reportid
2205322155 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2205422156 // set stack-base & callee-address
@@ -22056,20 +22158,20 @@
2205622158 label = 18446744073709551586LLU; // reportid
2205722159 break;
2205822160 }
22059- case 1921LLU: // copy-back deleter (reportid to ProcCall)
22161+ case 1933LLU: // copy-back deleter (reportid to ProcCall)
2206022162 {
2206122163 // copy mutable arguments back from call to reportid
22062- label = 1902LLU; // continue to roll stack
22164+ label = 1914LLU; // continue to roll stack
2206322165 break;
2206422166 }
22065- case 1922LLU: // return from reportid to ProcCall
22167+ case 1934LLU: // return from reportid to ProcCall
2206622168 {
2206722169 // copy mutable arguments back from call to reportid
2206822170 fprintf(stderr, "%s", " at position ");
2206922171 // call reportnr from ProcCall
22070- stack[base + 44LLU] = 1923LLU/*throw to this address*/;
22172+ stack[base + 44LLU] = 1935LLU/*throw to this address*/;
2207122173 stack[base + 45LLU] = base;
22072- stack[base + 46LLU] = 1924LLU;
22174+ stack[base + 46LLU] = 1936LLU;
2207322175 // arguments for call to reportnr
2207422176 stack[base + 47LLU] = stack[base + 32]/*index*/;
2207522177 // set stack-base & callee-address
@@ -22077,13 +22179,13 @@
2207722179 label = 18446744073709551589LLU; // reportnr
2207822180 break;
2207922181 }
22080- case 1923LLU: // copy-back deleter (reportnr to ProcCall)
22182+ case 1935LLU: // copy-back deleter (reportnr to ProcCall)
2208122183 {
2208222184 // copy mutable arguments back from call to reportnr
22083- label = 1902LLU; // continue to roll stack
22185+ label = 1914LLU; // continue to roll stack
2208422186 break;
2208522187 }
22086- case 1924LLU: // return from reportnr to ProcCall
22188+ case 1936LLU: // return from reportnr to ProcCall
2208722189 {
2208822190 // copy mutable arguments back from call to reportnr
2208922191 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -22091,7 +22193,7 @@
2209122193 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2209222194 if(!newstack)
2209322195 {
22094- label = 1902LLU; // throw: begin to unroll stack
22196+ label = 1914LLU; // throw: begin to unroll stack
2209522197 break;
2209622198 }
2209722199
@@ -22098,9 +22200,9 @@
2209822200 newstack[10LLU] = 9876543210LLU; // overflow-marker
2209922201 // call reporttype from ProcCall
2210022202 newstack[0] = (uint64_t)stack; // backup stack location
22101- newstack[1] = 1925LLU;
22203+ newstack[1] = 1937LLU;
2210222204 newstack[2] = base;
22103- newstack[3] = 1926LLU;
22205+ newstack[3] = 1938LLU;
2210422206 // arguments for call to reporttype
2210522207 newstack[4LLU] = stack[base + 41]/*expected*/;
2210622208 stack = newstack;
@@ -22109,7 +22211,7 @@
2210922211 label = 330LLU; // reporttype
2211022212 break;
2211122213 }
22112- case 1925LLU: // copy-back deleter (reporttype to ProcCall)
22214+ case 1937LLU: // copy-back deleter (reporttype to ProcCall)
2211322215 {
2211422216 uint64_t *oldstack = (uint64_t *)stack[0];
2211522217 // copy mutable arguments back from call to reporttype
@@ -22120,10 +22222,10 @@
2212022222 }
2212122223 Free(10LLU + 1, sizeof(uint64_t), stack);
2212222224 stack = oldstack;
22123- label = 1902LLU; // continue to unroll stack
22225+ label = 1914LLU; // continue to unroll stack
2212422226 break;
2212522227 }
22126- case 1926LLU: // return from reporttype to ProcCall
22228+ case 1938LLU: // return from reporttype to ProcCall
2212722229 {
2212822230 uint64_t *oldstack = (uint64_t *)stack[0];
2212922231 // copy mutable arguments back from call to reporttype
@@ -22136,33 +22238,33 @@
2213622238 stack = oldstack;
2213722239 fprintf(stderr, "%s", "\n");
2213822240 {
22139- label = 1902LLU; // throw: begin to unroll stack
22241+ label = 1914LLU; // throw: begin to unroll stack
2214022242 break;
2214122243 }
2214222244
22143- label = 1906LLU; // alternative complete
22245+ label = 1918LLU; // alternative complete
2214422246 break;
2214522247 }
22146- case 1906LLU: // completed if-then-else
22248+ case 1918LLU: // completed if-then-else
2214722249 {
2214822250 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
22149- label = 1900LLU; // case complete
22251+ label = 1912LLU; // case complete
2215022252 break;
2215122253 }
22152- case 1902LLU: // copy-back deleter (switch)
22254+ case 1914LLU: // copy-back deleter (switch)
2215322255 {
2215422256 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
22155- label = 1847LLU; // continue to unroll stack
22257+ label = 1859LLU; // continue to unroll stack
2215622258 break;
2215722259 }
22158- case 1901LLU: // try next case
22260+ case 1913LLU: // try next case
2215922261 {
2216022262 // default
2216122263 fprintf(stderr, "%s", "in function ");
2216222264 // call reportid from ProcCall
22163- stack[base + 43LLU] = 1927LLU/*throw to this address*/;
22265+ stack[base + 43LLU] = 1939LLU/*throw to this address*/;
2216422266 stack[base + 44LLU] = base;
22165- stack[base + 45LLU] = 1928LLU;
22267+ stack[base + 45LLU] = 1940LLU;
2216622268 // arguments for call to reportid
2216722269 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2216822270 // set stack-base & callee-address
@@ -22170,20 +22272,20 @@
2217022272 label = 18446744073709551586LLU; // reportid
2217122273 break;
2217222274 }
22173- case 1927LLU: // copy-back deleter (reportid to ProcCall)
22275+ case 1939LLU: // copy-back deleter (reportid to ProcCall)
2217422276 {
2217522277 // copy mutable arguments back from call to reportid
22176- label = 1847LLU; // continue to roll stack
22278+ label = 1859LLU; // continue to roll stack
2217722279 break;
2217822280 }
22179- case 1928LLU: // return from reportid to ProcCall
22281+ case 1940LLU: // return from reportid to ProcCall
2218022282 {
2218122283 // copy mutable arguments back from call to reportid
2218222284 fprintf(stderr, "%s", " recursive call to ");
2218322285 // call reportid from ProcCall
22184- stack[base + 43LLU] = 1929LLU/*throw to this address*/;
22286+ stack[base + 43LLU] = 1941LLU/*throw to this address*/;
2218522287 stack[base + 44LLU] = base;
22186- stack[base + 45LLU] = 1930LLU;
22288+ stack[base + 45LLU] = 1942LLU;
2218722289 // arguments for call to reportid
2218822290 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2218922291 // set stack-base & callee-address
@@ -22191,20 +22293,20 @@
2219122293 label = 18446744073709551586LLU; // reportid
2219222294 break;
2219322295 }
22194- case 1929LLU: // copy-back deleter (reportid to ProcCall)
22296+ case 1941LLU: // copy-back deleter (reportid to ProcCall)
2219522297 {
2219622298 // copy mutable arguments back from call to reportid
22197- label = 1847LLU; // continue to roll stack
22299+ label = 1859LLU; // continue to roll stack
2219822300 break;
2219922301 }
22200- case 1930LLU: // return from reportid to ProcCall
22302+ case 1942LLU: // return from reportid to ProcCall
2220122303 {
2220222304 // copy mutable arguments back from call to reportid
2220322305 fprintf(stderr, "%s", " at position ");
2220422306 // call reportnr from ProcCall
22205- stack[base + 43LLU] = 1931LLU/*throw to this address*/;
22307+ stack[base + 43LLU] = 1943LLU/*throw to this address*/;
2220622308 stack[base + 44LLU] = base;
22207- stack[base + 45LLU] = 1932LLU;
22309+ stack[base + 45LLU] = 1944LLU;
2220822310 // arguments for call to reportnr
2220922311 stack[base + 46LLU] = stack[base + 32]/*index*/;
2221022312 // set stack-base & callee-address
@@ -22212,13 +22314,13 @@
2221222314 label = 18446744073709551589LLU; // reportnr
2221322315 break;
2221422316 }
22215- case 1931LLU: // copy-back deleter (reportnr to ProcCall)
22317+ case 1943LLU: // copy-back deleter (reportnr to ProcCall)
2221622318 {
2221722319 // copy mutable arguments back from call to reportnr
22218- label = 1847LLU; // continue to roll stack
22320+ label = 1859LLU; // continue to roll stack
2221922321 break;
2222022322 }
22221- case 1932LLU: // return from reportnr to ProcCall
22323+ case 1944LLU: // return from reportnr to ProcCall
2222222324 {
2222322325 // copy mutable arguments back from call to reportnr
2222422326 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -22226,7 +22328,7 @@
2222622328 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2222722329 if(!newstack)
2222822330 {
22229- label = 1847LLU; // throw: begin to unroll stack
22331+ label = 1859LLU; // throw: begin to unroll stack
2223022332 break;
2223122333 }
2223222334
@@ -22233,9 +22335,9 @@
2223322335 newstack[10LLU] = 9876543210LLU; // overflow-marker
2223422336 // call reporttype from ProcCall
2223522337 newstack[0] = (uint64_t)stack; // backup stack location
22236- newstack[1] = 1933LLU;
22338+ newstack[1] = 1945LLU;
2223722339 newstack[2] = base;
22238- newstack[3] = 1934LLU;
22340+ newstack[3] = 1946LLU;
2223922341 // arguments for call to reporttype
2224022342 newstack[4LLU] = stack[base + 41]/*expected*/;
2224122343 stack = newstack;
@@ -22244,7 +22346,7 @@
2224422346 label = 330LLU; // reporttype
2224522347 break;
2224622348 }
22247- case 1933LLU: // copy-back deleter (reporttype to ProcCall)
22349+ case 1945LLU: // copy-back deleter (reporttype to ProcCall)
2224822350 {
2224922351 uint64_t *oldstack = (uint64_t *)stack[0];
2225022352 // copy mutable arguments back from call to reporttype
@@ -22255,10 +22357,10 @@
2225522357 }
2225622358 Free(10LLU + 1, sizeof(uint64_t), stack);
2225722359 stack = oldstack;
22258- label = 1847LLU; // continue to unroll stack
22360+ label = 1859LLU; // continue to unroll stack
2225922361 break;
2226022362 }
22261- case 1934LLU: // return from reporttype to ProcCall
22363+ case 1946LLU: // return from reporttype to ProcCall
2226222364 {
2226322365 uint64_t *oldstack = (uint64_t *)stack[0];
2226422366 // copy mutable arguments back from call to reporttype
@@ -22271,32 +22373,32 @@
2227122373 stack = oldstack;
2227222374 fprintf(stderr, "%s", "\n");
2227322375 {
22274- label = 1847LLU; // throw: begin to unroll stack
22376+ label = 1859LLU; // throw: begin to unroll stack
2227522377 break;
2227622378 }
2227722379
22278- label = 1900LLU; // default complete
22380+ label = 1912LLU; // default complete
2227922381 break;
2228022382 }
22281- case 1900LLU: // completed switch
22383+ case 1912LLU: // completed switch
2228222384 {
2228322385 if(!stack[base + 7]/*fnIO*/)
2228422386 {
22285- label = 1935LLU; // jump to alternative
22387+ label = 1947LLU; // jump to alternative
2228622388 break;
2228722389 }
2228822390
2228922391 // consequent
22290- label = 1936LLU; // consequent complete
22392+ label = 1948LLU; // consequent complete
2229122393 break;
2229222394 }
22293- case 1935LLU: // alternative
22395+ case 1947LLU: // alternative
2229422396 {
2229522397 fprintf(stderr, "%s", "in function ");
2229622398 // call reportid from ProcCall
22297- stack[base + 43LLU] = 1937LLU/*throw to this address*/;
22399+ stack[base + 43LLU] = 1949LLU/*throw to this address*/;
2229822400 stack[base + 44LLU] = base;
22299- stack[base + 45LLU] = 1938LLU;
22401+ stack[base + 45LLU] = 1950LLU;
2230022402 // arguments for call to reportid
2230122403 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2230222404 // set stack-base & callee-address
@@ -22304,41 +22406,41 @@
2230422406 label = 18446744073709551586LLU; // reportid
2230522407 break;
2230622408 }
22307- case 1937LLU: // copy-back deleter (reportid to ProcCall)
22409+ case 1949LLU: // copy-back deleter (reportid to ProcCall)
2230822410 {
2230922411 // copy mutable arguments back from call to reportid
22310- label = 1847LLU; // continue to roll stack
22412+ label = 1859LLU; // continue to roll stack
2231122413 break;
2231222414 }
22313- case 1938LLU: // return from reportid to ProcCall
22415+ case 1950LLU: // return from reportid to ProcCall
2231422416 {
2231522417 // copy mutable arguments back from call to reportid
2231622418 fprintf(stderr, "%s", ": ");
2231722419 fprintf(stderr, "%s", "getbyte() used in non-IO environment\n");
2231822420 {
22319- label = 1847LLU; // throw: begin to unroll stack
22421+ label = 1859LLU; // throw: begin to unroll stack
2232022422 break;
2232122423 }
2232222424
22323- label = 1936LLU; // alternative complete
22425+ label = 1948LLU; // alternative complete
2232422426 break;
2232522427 }
22326- case 1936LLU: // completed if-then-else
22428+ case 1948LLU: // completed if-then-else
2232722429 {
22328- label = 1895LLU; // consequent complete
22430+ label = 1907LLU; // consequent complete
2232922431 break;
2233022432 }
22331- case 1894LLU: // alternative
22433+ case 1906LLU: // alternative
2233222434 {
22333- label = 1940LLU; // skip deleter
22435+ label = 1952LLU; // skip deleter
2233422436 break;
2233522437 }
22336- case 1939LLU: // deleter
22438+ case 1951LLU: // deleter
2233722439 {
2233822440 // throw from ProcCall
2233922441 if(!stack[base + 43])
2234022442 {
22341- label = 1847LLU; // skip, variable already deleted/unscoped
22443+ label = 1859LLU; // skip, variable already deleted/unscoped
2234222444 break;
2234322445 }
2234422446
@@ -22347,7 +22449,7 @@
2234722449 newstack[0] = (uint64_t)stack; // backup stack location
2234822450 newstack[1] = 1234567890;
2234922451 newstack[2] = base;
22350- newstack[3] = 1941LLU;
22452+ newstack[3] = 1953LLU;
2235122453 stack = newstack;
2235222454 // set stack-base & callee-address
2235322455 base = 4/*deloffset*/;
@@ -22354,21 +22456,21 @@
2235422456 label = 486LLU; // ~letdef
2235522457 break;
2235622458 }
22357- case 1941LLU: // return from ~letdef to ProcCall
22459+ case 1953LLU: // return from ~letdef to ProcCall
2235822460 {
2235922461 stack = (uint64_t *)stack[0];
2236022462 // releasing toplevel container
2236122463 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2236222464
22363- label = 1847LLU; // continue unrolling stack, delete next variable
22465+ label = 1859LLU; // continue unrolling stack, delete next variable
2236422466 break;
2236522467 }
22366- case 1940LLU: // skipped deleter
22468+ case 1952LLU: // skipped deleter
2236722469 {
2236822470 // call FindLet from ProcCall
22369- stack[base + 44LLU] = 1942LLU/*throw to this address*/;
22471+ stack[base + 44LLU] = 1954LLU/*throw to this address*/;
2237022472 stack[base + 45LLU] = base;
22371- stack[base + 46LLU] = 1943LLU;
22473+ stack[base + 46LLU] = 1955LLU;
2237222474 // arguments for call to FindLet
2237322475 stack[base + 48LLU] = stack[base + 8]/*fnid*/;
2237422476 stack[base + 49LLU] = stack[base + 16]/*content*/;
@@ -22379,13 +22481,13 @@
2237922481 label = 619LLU; // FindLet
2238022482 break;
2238122483 }
22382- case 1942LLU: // copy-back deleter (FindLet to ProcCall)
22484+ case 1954LLU: // copy-back deleter (FindLet to ProcCall)
2238322485 {
2238422486 // copy mutable arguments back from call to FindLet
22385- label = 1847LLU; // continue to roll stack
22487+ label = 1859LLU; // continue to roll stack
2238622488 break;
2238722489 }
22388- case 1943LLU: // return from FindLet to ProcCall
22490+ case 1955LLU: // return from FindLet to ProcCall
2238922491 {
2239022492 // copy mutable arguments back from call to FindLet
2239122493 // copy back results provided by call to FindLet
@@ -22392,7 +22494,7 @@
2239222494 stack[base + 43] = stack[base + 47LLU];
2239322495 if(/*letdef*/0 != ((uint64_t *)(stack[base + 43]/*letdef*/))[0])
2239422496 {
22395- label = 1945LLU; // jump to alternative
22497+ label = 1957LLU; // jump to alternative
2239622498 break;
2239722499 }
2239822500
@@ -22404,9 +22506,9 @@
2240422506
2240522507 // case
2240622508 // call or from ProcCall
22407- stack[base + 49LLU] = 1947LLU/*throw to this address*/;
22509+ stack[base + 49LLU] = 1959LLU/*throw to this address*/;
2240822510 stack[base + 50LLU] = base;
22409- stack[base + 51LLU] = 1948LLU;
22511+ stack[base + 51LLU] = 1960LLU;
2241022512 // arguments for call to or
2241122513 stack[base + 53LLU] = stack[base + 35]/*csubstruct*/;
2241222514 stack[base + 54LLU] = stack[base + 48]/*substruct*/;
@@ -22415,13 +22517,13 @@
2241522517 label = 18446744073709551611LLU; // or
2241622518 break;
2241722519 }
22418- case 1947LLU: // copy-back deleter (or to ProcCall)
22520+ case 1959LLU: // copy-back deleter (or to ProcCall)
2241922521 {
2242022522 // copy mutable arguments back from call to or
22421- label = 1946LLU; // continue to roll stack
22523+ label = 1958LLU; // continue to roll stack
2242222524 break;
2242322525 }
22424- case 1948LLU: // return from or to ProcCall
22526+ case 1960LLU: // return from or to ProcCall
2242522527 {
2242622528 // copy mutable arguments back from call to or
2242722529 // copy back results provided by call to or
@@ -22429,7 +22531,7 @@
2242922531 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2243022532 if(!newstack)
2243122533 {
22432- label = 1946LLU; // throw: begin to unroll stack
22534+ label = 1958LLU; // throw: begin to unroll stack
2243322535 break;
2243422536 }
2243522537
@@ -22436,9 +22538,9 @@
2243622538 newstack[15LLU] = 9876543210LLU; // overflow-marker
2243722539 // call equtype from ProcCall
2243822540 newstack[0] = (uint64_t)stack; // backup stack location
22439- newstack[1] = 1949LLU;
22541+ newstack[1] = 1961LLU;
2244022542 newstack[2] = base;
22441- newstack[3] = 1950LLU;
22543+ newstack[3] = 1962LLU;
2244222544 // arguments for call to equtype
2244322545 newstack[5LLU] = stack[base + 44]/*type*/;
2244422546 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -22448,7 +22550,7 @@
2244822550 label = 359LLU; // equtype
2244922551 break;
2245022552 }
22451- case 1949LLU: // copy-back deleter (equtype to ProcCall)
22553+ case 1961LLU: // copy-back deleter (equtype to ProcCall)
2245222554 {
2245322555 uint64_t *oldstack = (uint64_t *)stack[0];
2245422556 // copy mutable arguments back from call to equtype
@@ -22459,10 +22561,10 @@
2245922561 }
2246022562 Free(15LLU + 1, sizeof(uint64_t), stack);
2246122563 stack = oldstack;
22462- label = 1946LLU; // continue to unroll stack
22564+ label = 1958LLU; // continue to unroll stack
2246322565 break;
2246422566 }
22465- case 1950LLU: // return from equtype to ProcCall
22567+ case 1962LLU: // return from equtype to ProcCall
2246622568 {
2246722569 uint64_t *oldstack = (uint64_t *)stack[0];
2246822570 // copy mutable arguments back from call to equtype
@@ -22477,21 +22579,21 @@
2247722579 stack = oldstack;
2247822580 if(!stack[base + 18]/*isequal*/)
2247922581 {
22480- label = 1951LLU; // jump to alternative
22582+ label = 1963LLU; // jump to alternative
2248122583 break;
2248222584 }
2248322585
2248422586 // consequent
22485- label = 1952LLU; // consequent complete
22587+ label = 1964LLU; // consequent complete
2248622588 break;
2248722589 }
22488- case 1951LLU: // alternative
22590+ case 1963LLU: // alternative
2248922591 {
2249022592 fprintf(stderr, "%s", "in function ");
2249122593 // call reportid from ProcCall
22492- stack[base + 49LLU] = 1953LLU/*throw to this address*/;
22594+ stack[base + 49LLU] = 1965LLU/*throw to this address*/;
2249322595 stack[base + 50LLU] = base;
22494- stack[base + 51LLU] = 1954LLU;
22596+ stack[base + 51LLU] = 1966LLU;
2249522597 // arguments for call to reportid
2249622598 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2249722599 // set stack-base & callee-address
@@ -22499,20 +22601,20 @@
2249922601 label = 18446744073709551586LLU; // reportid
2250022602 break;
2250122603 }
22502- case 1953LLU: // copy-back deleter (reportid to ProcCall)
22604+ case 1965LLU: // copy-back deleter (reportid to ProcCall)
2250322605 {
2250422606 // copy mutable arguments back from call to reportid
22505- label = 1946LLU; // continue to roll stack
22607+ label = 1958LLU; // continue to roll stack
2250622608 break;
2250722609 }
22508- case 1954LLU: // return from reportid to ProcCall
22610+ case 1966LLU: // return from reportid to ProcCall
2250922611 {
2251022612 // copy mutable arguments back from call to reportid
2251122613 fprintf(stderr, "%s", " call to ");
2251222614 // call reportid from ProcCall
22513- stack[base + 49LLU] = 1955LLU/*throw to this address*/;
22615+ stack[base + 49LLU] = 1967LLU/*throw to this address*/;
2251422616 stack[base + 50LLU] = base;
22515- stack[base + 51LLU] = 1956LLU;
22617+ stack[base + 51LLU] = 1968LLU;
2251622618 // arguments for call to reportid
2251722619 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2251822620 // set stack-base & callee-address
@@ -22520,20 +22622,20 @@
2252022622 label = 18446744073709551586LLU; // reportid
2252122623 break;
2252222624 }
22523- case 1955LLU: // copy-back deleter (reportid to ProcCall)
22625+ case 1967LLU: // copy-back deleter (reportid to ProcCall)
2252422626 {
2252522627 // copy mutable arguments back from call to reportid
22526- label = 1946LLU; // continue to roll stack
22628+ label = 1958LLU; // continue to roll stack
2252722629 break;
2252822630 }
22529- case 1956LLU: // return from reportid to ProcCall
22631+ case 1968LLU: // return from reportid to ProcCall
2253022632 {
2253122633 // copy mutable arguments back from call to reportid
2253222634 fprintf(stderr, "%s", " at position ");
2253322635 // call reportnr from ProcCall
22534- stack[base + 49LLU] = 1957LLU/*throw to this address*/;
22636+ stack[base + 49LLU] = 1969LLU/*throw to this address*/;
2253522637 stack[base + 50LLU] = base;
22536- stack[base + 51LLU] = 1958LLU;
22638+ stack[base + 51LLU] = 1970LLU;
2253722639 // arguments for call to reportnr
2253822640 stack[base + 52LLU] = stack[base + 32]/*index*/;
2253922641 // set stack-base & callee-address
@@ -22541,13 +22643,13 @@
2254122643 label = 18446744073709551589LLU; // reportnr
2254222644 break;
2254322645 }
22544- case 1957LLU: // copy-back deleter (reportnr to ProcCall)
22646+ case 1969LLU: // copy-back deleter (reportnr to ProcCall)
2254522647 {
2254622648 // copy mutable arguments back from call to reportnr
22547- label = 1946LLU; // continue to roll stack
22649+ label = 1958LLU; // continue to roll stack
2254822650 break;
2254922651 }
22550- case 1958LLU: // return from reportnr to ProcCall
22652+ case 1970LLU: // return from reportnr to ProcCall
2255122653 {
2255222654 // copy mutable arguments back from call to reportnr
2255322655 fprintf(stderr, "%s", " parameter type ");
@@ -22554,7 +22656,7 @@
2255422656 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2255522657 if(!newstack)
2255622658 {
22557- label = 1946LLU; // throw: begin to unroll stack
22659+ label = 1958LLU; // throw: begin to unroll stack
2255822660 break;
2255922661 }
2256022662
@@ -22561,9 +22663,9 @@
2256122663 newstack[10LLU] = 9876543210LLU; // overflow-marker
2256222664 // call reporttype from ProcCall
2256322665 newstack[0] = (uint64_t)stack; // backup stack location
22564- newstack[1] = 1959LLU;
22666+ newstack[1] = 1971LLU;
2256522667 newstack[2] = base;
22566- newstack[3] = 1960LLU;
22668+ newstack[3] = 1972LLU;
2256722669 // arguments for call to reporttype
2256822670 newstack[4LLU] = stack[base + 41]/*expected*/;
2256922671 stack = newstack;
@@ -22572,7 +22674,7 @@
2257222674 label = 330LLU; // reporttype
2257322675 break;
2257422676 }
22575- case 1959LLU: // copy-back deleter (reporttype to ProcCall)
22677+ case 1971LLU: // copy-back deleter (reporttype to ProcCall)
2257622678 {
2257722679 uint64_t *oldstack = (uint64_t *)stack[0];
2257822680 // copy mutable arguments back from call to reporttype
@@ -22583,10 +22685,10 @@
2258322685 }
2258422686 Free(10LLU + 1, sizeof(uint64_t), stack);
2258522687 stack = oldstack;
22586- label = 1946LLU; // continue to unroll stack
22688+ label = 1958LLU; // continue to unroll stack
2258722689 break;
2258822690 }
22589- case 1960LLU: // return from reporttype to ProcCall
22691+ case 1972LLU: // return from reporttype to ProcCall
2259022692 {
2259122693 uint64_t *oldstack = (uint64_t *)stack[0];
2259222694 // copy mutable arguments back from call to reporttype
@@ -22601,7 +22703,7 @@
2260122703 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2260222704 if(!newstack)
2260322705 {
22604- label = 1946LLU; // throw: begin to unroll stack
22706+ label = 1958LLU; // throw: begin to unroll stack
2260522707 break;
2260622708 }
2260722709
@@ -22608,9 +22710,9 @@
2260822710 newstack[10LLU] = 9876543210LLU; // overflow-marker
2260922711 // call reporttype from ProcCall
2261022712 newstack[0] = (uint64_t)stack; // backup stack location
22611- newstack[1] = 1961LLU;
22713+ newstack[1] = 1973LLU;
2261222714 newstack[2] = base;
22613- newstack[3] = 1962LLU;
22715+ newstack[3] = 1974LLU;
2261422716 // arguments for call to reporttype
2261522717 newstack[4LLU] = stack[base + 44]/*type*/;
2261622718 stack = newstack;
@@ -22619,7 +22721,7 @@
2261922721 label = 330LLU; // reporttype
2262022722 break;
2262122723 }
22622- case 1961LLU: // copy-back deleter (reporttype to ProcCall)
22724+ case 1973LLU: // copy-back deleter (reporttype to ProcCall)
2262322725 {
2262422726 uint64_t *oldstack = (uint64_t *)stack[0];
2262522727 // copy mutable arguments back from call to reporttype
@@ -22630,10 +22732,10 @@
2263022732 }
2263122733 Free(10LLU + 1, sizeof(uint64_t), stack);
2263222734 stack = oldstack;
22633- label = 1946LLU; // continue to unroll stack
22735+ label = 1958LLU; // continue to unroll stack
2263422736 break;
2263522737 }
22636- case 1962LLU: // return from reporttype to ProcCall
22738+ case 1974LLU: // return from reporttype to ProcCall
2263722739 {
2263822740 uint64_t *oldstack = (uint64_t *)stack[0];
2263922741 // copy mutable arguments back from call to reporttype
@@ -22646,18 +22748,18 @@
2264622748 stack = oldstack;
2264722749 fprintf(stderr, "%s", "\n");
2264822750 {
22649- label = 1946LLU; // throw: begin to unroll stack
22751+ label = 1958LLU; // throw: begin to unroll stack
2265022752 break;
2265122753 }
2265222754
22653- label = 1952LLU; // alternative complete
22755+ label = 1964LLU; // alternative complete
2265422756 break;
2265522757 }
22656- case 1952LLU: // completed if-then-else
22758+ case 1964LLU: // completed if-then-else
2265722759 {
2265822760 if(!stack[base + 40]/*mutable*/)
2265922761 {
22660- label = 1963LLU; // jump to alternative
22762+ label = 1975LLU; // jump to alternative
2266122763 break;
2266222764 }
2266322765
@@ -22664,31 +22766,31 @@
2266422766 // consequent
2266522767 if(!stack[base + 47]/*mutarg*/)
2266622768 {
22667- label = 1965LLU; // jump to alternative
22769+ label = 1977LLU; // jump to alternative
2266822770 break;
2266922771 }
2267022772
2267122773 // consequent
22672- label = 1968LLU; // skip deleter
22774+ label = 1980LLU; // skip deleter
2267322775 break;
2267422776 }
22675- case 1967LLU: // deleter
22777+ case 1979LLU: // deleter
2267622778 {
2267722779 // throw from ProcCall
2267822780 if(!stack[base + 49])
2267922781 {
22680- label = 1946LLU; // skip, variable already deleted/unscoped
22782+ label = 1958LLU; // skip, variable already deleted/unscoped
2268122783 break;
2268222784 }
22683- label = 1946LLU; // continue unrolling stack, delete next variable
22785+ label = 1958LLU; // continue unrolling stack, delete next variable
2268422786 break;
2268522787 }
22686- case 1968LLU: // skipped deleter
22788+ case 1980LLU: // skipped deleter
2268722789 {
2268822790 // call lookidnr from ProcCall
22689- stack[base + 50LLU] = 1969LLU/*throw to this address*/;
22791+ stack[base + 50LLU] = 1981LLU/*throw to this address*/;
2269022792 stack[base + 51LLU] = base;
22691- stack[base + 52LLU] = 1970LLU;
22793+ stack[base + 52LLU] = 1982LLU;
2269222794 // arguments for call to lookidnr
2269322795 stack[base + 54LLU] = stack[base + 19]/*copyback*/;
2269422796 stack[base + 55LLU] = stack[base + 16]/*content*/;
@@ -22697,13 +22799,13 @@
2269722799 label = 835LLU; // lookidnr
2269822800 break;
2269922801 }
22700- case 1969LLU: // copy-back deleter (lookidnr to ProcCall)
22802+ case 1981LLU: // copy-back deleter (lookidnr to ProcCall)
2270122803 {
2270222804 // copy mutable arguments back from call to lookidnr
22703- label = 1946LLU; // continue to roll stack
22805+ label = 1958LLU; // continue to roll stack
2270422806 break;
2270522807 }
22706- case 1970LLU: // return from lookidnr to ProcCall
22808+ case 1982LLU: // return from lookidnr to ProcCall
2270722809 {
2270822810 // copy mutable arguments back from call to lookidnr
2270922811 // copy back results provided by call to lookidnr
@@ -22710,7 +22812,7 @@
2271022812 stack[base + 49] = stack[base + 53LLU];
2271122813 if(!stack[base + 49]/*found*/)
2271222814 {
22713- label = 1971LLU; // jump to alternative
22815+ label = 1983LLU; // jump to alternative
2271422816 break;
2271522817 }
2271622818
@@ -22717,9 +22819,9 @@
2271722819 // consequent
2271822820 fprintf(stderr, "%s", "in function ");
2271922821 // call reportid from ProcCall
22720- stack[base + 50LLU] = 1973LLU/*throw to this address*/;
22822+ stack[base + 50LLU] = 1985LLU/*throw to this address*/;
2272122823 stack[base + 51LLU] = base;
22722- stack[base + 52LLU] = 1974LLU;
22824+ stack[base + 52LLU] = 1986LLU;
2272322825 // arguments for call to reportid
2272422826 stack[base + 53LLU] = stack[base + 8]/*fnid*/;
2272522827 // set stack-base & callee-address
@@ -22727,20 +22829,20 @@
2272722829 label = 18446744073709551586LLU; // reportid
2272822830 break;
2272922831 }
22730- case 1973LLU: // copy-back deleter (reportid to ProcCall)
22832+ case 1985LLU: // copy-back deleter (reportid to ProcCall)
2273122833 {
2273222834 // copy mutable arguments back from call to reportid
22733- label = 1967LLU; // continue to roll stack
22835+ label = 1979LLU; // continue to roll stack
2273422836 break;
2273522837 }
22736- case 1974LLU: // return from reportid to ProcCall
22838+ case 1986LLU: // return from reportid to ProcCall
2273722839 {
2273822840 // copy mutable arguments back from call to reportid
2273922841 fprintf(stderr, "%s", " call to ");
2274022842 // call reportid from ProcCall
22741- stack[base + 50LLU] = 1975LLU/*throw to this address*/;
22843+ stack[base + 50LLU] = 1987LLU/*throw to this address*/;
2274222844 stack[base + 51LLU] = base;
22743- stack[base + 52LLU] = 1976LLU;
22845+ stack[base + 52LLU] = 1988LLU;
2274422846 // arguments for call to reportid
2274522847 stack[base + 53LLU] = stack[base + 24]/*ceid*/;
2274622848 // set stack-base & callee-address
@@ -22748,20 +22850,20 @@
2274822850 label = 18446744073709551586LLU; // reportid
2274922851 break;
2275022852 }
22751- case 1975LLU: // copy-back deleter (reportid to ProcCall)
22853+ case 1987LLU: // copy-back deleter (reportid to ProcCall)
2275222854 {
2275322855 // copy mutable arguments back from call to reportid
22754- label = 1967LLU; // continue to roll stack
22856+ label = 1979LLU; // continue to roll stack
2275522857 break;
2275622858 }
22757- case 1976LLU: // return from reportid to ProcCall
22859+ case 1988LLU: // return from reportid to ProcCall
2275822860 {
2275922861 // copy mutable arguments back from call to reportid
2276022862 fprintf(stderr, "%s", " - duplicate mutable argument ");
2276122863 // call reportid from ProcCall
22762- stack[base + 50LLU] = 1977LLU/*throw to this address*/;
22864+ stack[base + 50LLU] = 1989LLU/*throw to this address*/;
2276322865 stack[base + 51LLU] = base;
22764- stack[base + 52LLU] = 1978LLU;
22866+ stack[base + 52LLU] = 1990LLU;
2276522867 // arguments for call to reportid
2276622868 stack[base + 53LLU] = stack[base + 16]/*content*/;
2276722869 // set stack-base & callee-address
@@ -22769,40 +22871,40 @@
2276922871 label = 18446744073709551586LLU; // reportid
2277022872 break;
2277122873 }
22772- case 1977LLU: // copy-back deleter (reportid to ProcCall)
22874+ case 1989LLU: // copy-back deleter (reportid to ProcCall)
2277322875 {
2277422876 // copy mutable arguments back from call to reportid
22775- label = 1967LLU; // continue to roll stack
22877+ label = 1979LLU; // continue to roll stack
2277622878 break;
2277722879 }
22778- case 1978LLU: // return from reportid to ProcCall
22880+ case 1990LLU: // return from reportid to ProcCall
2277922881 {
2278022882 // copy mutable arguments back from call to reportid
2278122883 fprintf(stderr, "%s", "\n");
2278222884 {
22783- label = 1967LLU; // throw: begin to unroll stack
22885+ label = 1979LLU; // throw: begin to unroll stack
2278422886 break;
2278522887 }
2278622888
22787- label = 1972LLU; // consequent complete
22889+ label = 1984LLU; // consequent complete
2278822890 break;
2278922891 }
22790- case 1971LLU: // alternative
22892+ case 1983LLU: // alternative
2279122893 {
22792- label = 1972LLU; // alternative complete
22894+ label = 1984LLU; // alternative complete
2279322895 break;
2279422896 }
22795- case 1972LLU: // completed if-then-else
22897+ case 1984LLU: // completed if-then-else
2279622898 {
22797- label = 1980LLU; // skip deleter
22899+ label = 1992LLU; // skip deleter
2279822900 break;
2279922901 }
22800- case 1979LLU: // deleter
22902+ case 1991LLU: // deleter
2280122903 {
2280222904 // throw from ProcCall
2280322905 if(!stack[base + 49])
2280422906 {
22805- label = 1946LLU; // skip, variable already deleted/unscoped
22907+ label = 1958LLU; // skip, variable already deleted/unscoped
2280622908 break;
2280722909 }
2280822910
@@ -22811,7 +22913,7 @@
2281122913 newstack[0] = (uint64_t)stack; // backup stack location
2281222914 newstack[1] = 1234567890;
2281322915 newstack[2] = base;
22814- newstack[3] = 1981LLU;
22916+ newstack[3] = 1993LLU;
2281522917 stack = newstack;
2281622918 // set stack-base & callee-address
2281722919 base = 4/*deloffset*/;
@@ -22818,21 +22920,21 @@
2281822920 label = 833LLU; // ~idnr
2281922921 break;
2282022922 }
22821- case 1981LLU: // return from ~idnr to ProcCall
22923+ case 1993LLU: // return from ~idnr to ProcCall
2282222924 {
2282322925 stack = (uint64_t *)stack[0];
2282422926 // releasing toplevel container
2282522927 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4));
2282622928
22827- label = 1946LLU; // continue unrolling stack, delete next variable
22929+ label = 1958LLU; // continue unrolling stack, delete next variable
2282822930 break;
2282922931 }
22830- case 1980LLU: // skipped deleter
22932+ case 1992LLU: // skipped deleter
2283122933 {
2283222934 // construct idnr.idnr
2283322935 if(!(stack[base + 49] = construct(2)))
2283422936 {
22835- label = 1946LLU; // throw: begin to unroll stack
22937+ label = 1958LLU; // throw: begin to unroll stack
2283622938 break;
2283722939 }
2283822940
@@ -22853,16 +22955,16 @@
2285322955 /*copyback*/stack[base + 19] = (uint64_t)list;
2285422956 MOVE(&list->data, &stack[base + 49]/*idnr*/);
2285522957 }
22856- label = 1966LLU; // consequent complete
22958+ label = 1978LLU; // consequent complete
2285722959 break;
2285822960 }
22859- case 1965LLU: // alternative
22961+ case 1977LLU: // alternative
2286022962 {
2286122963 fprintf(stderr, "%s", "in function ");
2286222964 // call reportid from ProcCall
22863- stack[base + 49LLU] = 1982LLU/*throw to this address*/;
22965+ stack[base + 49LLU] = 1994LLU/*throw to this address*/;
2286422966 stack[base + 50LLU] = base;
22865- stack[base + 51LLU] = 1983LLU;
22967+ stack[base + 51LLU] = 1995LLU;
2286622968 // arguments for call to reportid
2286722969 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2286822970 // set stack-base & callee-address
@@ -22870,20 +22972,20 @@
2287022972 label = 18446744073709551586LLU; // reportid
2287122973 break;
2287222974 }
22873- case 1982LLU: // copy-back deleter (reportid to ProcCall)
22975+ case 1994LLU: // copy-back deleter (reportid to ProcCall)
2287422976 {
2287522977 // copy mutable arguments back from call to reportid
22876- label = 1946LLU; // continue to roll stack
22978+ label = 1958LLU; // continue to roll stack
2287722979 break;
2287822980 }
22879- case 1983LLU: // return from reportid to ProcCall
22981+ case 1995LLU: // return from reportid to ProcCall
2288022982 {
2288122983 // copy mutable arguments back from call to reportid
2288222984 fprintf(stderr, "%s", ", call to ");
2288322985 // call reportid from ProcCall
22884- stack[base + 49LLU] = 1984LLU/*throw to this address*/;
22986+ stack[base + 49LLU] = 1996LLU/*throw to this address*/;
2288522987 stack[base + 50LLU] = base;
22886- stack[base + 51LLU] = 1985LLU;
22988+ stack[base + 51LLU] = 1997LLU;
2288722989 // arguments for call to reportid
2288822990 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2288922991 // set stack-base & callee-address
@@ -22891,13 +22993,13 @@
2289122993 label = 18446744073709551586LLU; // reportid
2289222994 break;
2289322995 }
22894- case 1984LLU: // copy-back deleter (reportid to ProcCall)
22996+ case 1996LLU: // copy-back deleter (reportid to ProcCall)
2289522997 {
2289622998 // copy mutable arguments back from call to reportid
22897- label = 1946LLU; // continue to roll stack
22999+ label = 1958LLU; // continue to roll stack
2289823000 break;
2289923001 }
22900- case 1985LLU: // return from reportid to ProcCall
23002+ case 1997LLU: // return from reportid to ProcCall
2290123003 {
2290223004 // copy mutable arguments back from call to reportid
2290323005 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -22904,7 +23006,7 @@
2290423006 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2290523007 if(!newstack)
2290623008 {
22907- label = 1946LLU; // throw: begin to unroll stack
23009+ label = 1958LLU; // throw: begin to unroll stack
2290823010 break;
2290923011 }
2291023012
@@ -22911,9 +23013,9 @@
2291123013 newstack[10LLU] = 9876543210LLU; // overflow-marker
2291223014 // call reporttype from ProcCall
2291323015 newstack[0] = (uint64_t)stack; // backup stack location
22914- newstack[1] = 1986LLU;
23016+ newstack[1] = 1998LLU;
2291523017 newstack[2] = base;
22916- newstack[3] = 1987LLU;
23018+ newstack[3] = 1999LLU;
2291723019 // arguments for call to reporttype
2291823020 newstack[4LLU] = stack[base + 44]/*type*/;
2291923021 stack = newstack;
@@ -22922,7 +23024,7 @@
2292223024 label = 330LLU; // reporttype
2292323025 break;
2292423026 }
22925- case 1986LLU: // copy-back deleter (reporttype to ProcCall)
23027+ case 1998LLU: // copy-back deleter (reporttype to ProcCall)
2292623028 {
2292723029 uint64_t *oldstack = (uint64_t *)stack[0];
2292823030 // copy mutable arguments back from call to reporttype
@@ -22933,10 +23035,10 @@
2293323035 }
2293423036 Free(10LLU + 1, sizeof(uint64_t), stack);
2293523037 stack = oldstack;
22936- label = 1946LLU; // continue to unroll stack
23038+ label = 1958LLU; // continue to unroll stack
2293723039 break;
2293823040 }
22939- case 1987LLU: // return from reporttype to ProcCall
23041+ case 1999LLU: // return from reporttype to ProcCall
2294023042 {
2294123043 uint64_t *oldstack = (uint64_t *)stack[0];
2294223044 // copy mutable arguments back from call to reporttype
@@ -22949,9 +23051,9 @@
2294923051 stack = oldstack;
2295023052 fprintf(stderr, "%s", " ");
2295123053 // call reportid from ProcCall
22952- stack[base + 49LLU] = 1988LLU/*throw to this address*/;
23054+ stack[base + 49LLU] = 2000LLU/*throw to this address*/;
2295323055 stack[base + 50LLU] = base;
22954- stack[base + 51LLU] = 1989LLU;
23056+ stack[base + 51LLU] = 2001LLU;
2295523057 // arguments for call to reportid
2295623058 stack[base + 52LLU] = stack[base + 16]/*content*/;
2295723059 // set stack-base & callee-address
@@ -22959,13 +23061,13 @@
2295923061 label = 18446744073709551586LLU; // reportid
2296023062 break;
2296123063 }
22962- case 1988LLU: // copy-back deleter (reportid to ProcCall)
23064+ case 2000LLU: // copy-back deleter (reportid to ProcCall)
2296323065 {
2296423066 // copy mutable arguments back from call to reportid
22965- label = 1946LLU; // continue to roll stack
23067+ label = 1958LLU; // continue to roll stack
2296623068 break;
2296723069 }
22968- case 1989LLU: // return from reportid to ProcCall
23070+ case 2001LLU: // return from reportid to ProcCall
2296923071 {
2297023072 // copy mutable arguments back from call to reportid
2297123073 fprintf(stderr, "%s", " into mutable parameter ");
@@ -22972,7 +23074,7 @@
2297223074 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2297323075 if(!newstack)
2297423076 {
22975- label = 1946LLU; // throw: begin to unroll stack
23077+ label = 1958LLU; // throw: begin to unroll stack
2297623078 break;
2297723079 }
2297823080
@@ -22979,9 +23081,9 @@
2297923081 newstack[10LLU] = 9876543210LLU; // overflow-marker
2298023082 // call reporttype from ProcCall
2298123083 newstack[0] = (uint64_t)stack; // backup stack location
22982- newstack[1] = 1990LLU;
23084+ newstack[1] = 2002LLU;
2298323085 newstack[2] = base;
22984- newstack[3] = 1991LLU;
23086+ newstack[3] = 2003LLU;
2298523087 // arguments for call to reporttype
2298623088 newstack[4LLU] = stack[base + 41]/*expected*/;
2298723089 stack = newstack;
@@ -22990,7 +23092,7 @@
2299023092 label = 330LLU; // reporttype
2299123093 break;
2299223094 }
22993- case 1990LLU: // copy-back deleter (reporttype to ProcCall)
23095+ case 2002LLU: // copy-back deleter (reporttype to ProcCall)
2299423096 {
2299523097 uint64_t *oldstack = (uint64_t *)stack[0];
2299623098 // copy mutable arguments back from call to reporttype
@@ -23001,10 +23103,10 @@
2300123103 }
2300223104 Free(10LLU + 1, sizeof(uint64_t), stack);
2300323105 stack = oldstack;
23004- label = 1946LLU; // continue to unroll stack
23106+ label = 1958LLU; // continue to unroll stack
2300523107 break;
2300623108 }
23007- case 1991LLU: // return from reporttype to ProcCall
23109+ case 2003LLU: // return from reporttype to ProcCall
2300823110 {
2300923111 uint64_t *oldstack = (uint64_t *)stack[0];
2301023112 // copy mutable arguments back from call to reporttype
@@ -23016,9 +23118,9 @@
2301623118 Free(10LLU + 1, sizeof(uint64_t), stack);
2301723119 stack = oldstack;
2301823120 // call reportid from ProcCall
23019- stack[base + 49LLU] = 1992LLU/*throw to this address*/;
23121+ stack[base + 49LLU] = 2004LLU/*throw to this address*/;
2302023122 stack[base + 50LLU] = base;
23021- stack[base + 51LLU] = 1993LLU;
23123+ stack[base + 51LLU] = 2005LLU;
2302223124 // arguments for call to reportid
2302323125 stack[base + 52LLU] = stack[base + 42]/*paramname*/;
2302423126 // set stack-base & callee-address
@@ -23026,35 +23128,35 @@
2302623128 label = 18446744073709551586LLU; // reportid
2302723129 break;
2302823130 }
23029- case 1992LLU: // copy-back deleter (reportid to ProcCall)
23131+ case 2004LLU: // copy-back deleter (reportid to ProcCall)
2303023132 {
2303123133 // copy mutable arguments back from call to reportid
23032- label = 1946LLU; // continue to roll stack
23134+ label = 1958LLU; // continue to roll stack
2303323135 break;
2303423136 }
23035- case 1993LLU: // return from reportid to ProcCall
23137+ case 2005LLU: // return from reportid to ProcCall
2303623138 {
2303723139 // copy mutable arguments back from call to reportid
2303823140 fprintf(stderr, "%s", "\n");
2303923141 {
23040- label = 1946LLU; // throw: begin to unroll stack
23142+ label = 1958LLU; // throw: begin to unroll stack
2304123143 break;
2304223144 }
2304323145
23044- label = 1966LLU; // alternative complete
23146+ label = 1978LLU; // alternative complete
2304523147 break;
2304623148 }
23047- case 1966LLU: // completed if-then-else
23149+ case 1978LLU: // completed if-then-else
2304823150 {
23049- label = 1964LLU; // consequent complete
23151+ label = 1976LLU; // consequent complete
2305023152 break;
2305123153 }
23052- case 1963LLU: // alternative
23154+ case 1975LLU: // alternative
2305323155 {
23054- label = 1964LLU; // alternative complete
23156+ label = 1976LLU; // alternative complete
2305523157 break;
2305623158 }
23057- case 1964LLU: // completed if-then-else
23159+ case 1976LLU: // completed if-then-else
2305823160 {
2305923161 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2306023162 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -23061,10 +23163,10 @@
2306123163 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2306223164 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2306323165 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
23064- label = 1944LLU; // case complete
23166+ label = 1956LLU; // case complete
2306523167 break;
2306623168 }
23067- case 1946LLU: // copy-back deleter (switch)
23169+ case 1958LLU: // copy-back deleter (switch)
2306823170 {
2306923171 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2307023172 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -23071,21 +23173,21 @@
2307123173 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2307223174 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2307323175 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
23074- label = 1939LLU; // continue to unroll stack
23176+ label = 1951LLU; // continue to unroll stack
2307523177 break;
2307623178 }
23077- case 1945LLU: // try next case
23179+ case 1957LLU: // try next case
2307823180 {
2307923181 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2308023182 exit(-1);
2308123183 }
23082- case 1944LLU: // completed switch
23184+ case 1956LLU: // completed switch
2308323185 {
2308423186 printf("%s", "\n newstack[");
2308523187 // call printnr from ProcCall
23086- stack[base + 44LLU] = 1994LLU/*throw to this address*/;
23188+ stack[base + 44LLU] = 2006LLU/*throw to this address*/;
2308723189 stack[base + 45LLU] = base;
23088- stack[base + 46LLU] = 1995LLU;
23190+ stack[base + 46LLU] = 2007LLU;
2308923191 // arguments for call to printnr
2309023192 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2309123193 // set stack-base & callee-address
@@ -23093,20 +23195,20 @@
2309323195 label = 18446744073709551590LLU; // printnr
2309423196 break;
2309523197 }
23096- case 1994LLU: // copy-back deleter (printnr to ProcCall)
23198+ case 2006LLU: // copy-back deleter (printnr to ProcCall)
2309723199 {
2309823200 // copy mutable arguments back from call to printnr
23099- label = 1939LLU; // continue to roll stack
23201+ label = 1951LLU; // continue to roll stack
2310023202 break;
2310123203 }
23102- case 1995LLU: // return from printnr to ProcCall
23204+ case 2007LLU: // return from printnr to ProcCall
2310323205 {
2310423206 // copy mutable arguments back from call to printnr
2310523207 printf("%s", "LLU] = ");
2310623208 // call emitvar from ProcCall
23107- stack[base + 44LLU] = 1996LLU/*throw to this address*/;
23209+ stack[base + 44LLU] = 2008LLU/*throw to this address*/;
2310823210 stack[base + 45LLU] = base;
23109- stack[base + 46LLU] = 1997LLU;
23211+ stack[base + 46LLU] = 2009LLU;
2311023212 // arguments for call to emitvar
2311123213 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2311223214 stack[base + 48LLU] = stack[base + 16]/*content*/;
@@ -23117,13 +23219,13 @@
2311723219 label = 749LLU; // emitvar
2311823220 break;
2311923221 }
23120- case 1996LLU: // copy-back deleter (emitvar to ProcCall)
23222+ case 2008LLU: // copy-back deleter (emitvar to ProcCall)
2312123223 {
2312223224 // copy mutable arguments back from call to emitvar
23123- label = 1939LLU; // continue to roll stack
23225+ label = 1951LLU; // continue to roll stack
2312423226 break;
2312523227 }
23126- case 1997LLU: // return from emitvar to ProcCall
23228+ case 2009LLU: // return from emitvar to ProcCall
2312723229 {
2312823230 // copy mutable arguments back from call to emitvar
2312923231 printf("%s", ";");
@@ -23133,7 +23235,7 @@
2313323235 newstack[0] = (uint64_t)stack; // backup stack location
2313423236 newstack[1] = 1234567890;
2313523237 newstack[2] = base;
23136- newstack[3] = 1998LLU;
23238+ newstack[3] = 2010LLU;
2313723239 stack = newstack;
2313823240 // set stack-base & callee-address
2313923241 base = 4/*deloffset*/;
@@ -23140,27 +23242,27 @@
2314023242 label = 486LLU; // ~letdef
2314123243 break;
2314223244 }
23143- case 1998LLU: // return from ~letdef to ProcCall
23245+ case 2010LLU: // return from ~letdef to ProcCall
2314423246 {
2314523247 stack = (uint64_t *)stack[0];
2314623248 // releasing toplevel container
2314723249 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2314823250
23149- label = 1895LLU; // alternative complete
23251+ label = 1907LLU; // alternative complete
2315023252 break;
2315123253 }
23152- case 1895LLU: // completed if-then-else
23254+ case 1907LLU: // completed if-then-else
2315323255 {
23154- label = 1891LLU; // consequent complete
23256+ label = 1903LLU; // consequent complete
2315523257 break;
2315623258 }
23157- case 1890LLU: // alternative
23259+ case 1902LLU: // alternative
2315823260 {
2315923261 fprintf(stderr, "%s", "in function ");
2316023262 // call reportid from ProcCall
23161- stack[base + 43LLU] = 1999LLU/*throw to this address*/;
23263+ stack[base + 43LLU] = 2011LLU/*throw to this address*/;
2316223264 stack[base + 44LLU] = base;
23163- stack[base + 45LLU] = 2000LLU;
23265+ stack[base + 45LLU] = 2012LLU;
2316423266 // arguments for call to reportid
2316523267 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2316623268 // set stack-base & callee-address
@@ -23168,20 +23270,20 @@
2316823270 label = 18446744073709551586LLU; // reportid
2316923271 break;
2317023272 }
23171- case 1999LLU: // copy-back deleter (reportid to ProcCall)
23273+ case 2011LLU: // copy-back deleter (reportid to ProcCall)
2317223274 {
2317323275 // copy mutable arguments back from call to reportid
23174- label = 1847LLU; // continue to roll stack
23276+ label = 1859LLU; // continue to roll stack
2317523277 break;
2317623278 }
23177- case 2000LLU: // return from reportid to ProcCall
23279+ case 2012LLU: // return from reportid to ProcCall
2317823280 {
2317923281 // copy mutable arguments back from call to reportid
2318023282 fprintf(stderr, "%s", " call to ");
2318123283 // call reportid from ProcCall
23182- stack[base + 43LLU] = 2001LLU/*throw to this address*/;
23284+ stack[base + 43LLU] = 2013LLU/*throw to this address*/;
2318323285 stack[base + 44LLU] = base;
23184- stack[base + 45LLU] = 2002LLU;
23286+ stack[base + 45LLU] = 2014LLU;
2318523287 // arguments for call to reportid
2318623288 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2318723289 // set stack-base & callee-address
@@ -23189,20 +23291,20 @@
2318923291 label = 18446744073709551586LLU; // reportid
2319023292 break;
2319123293 }
23192- case 2001LLU: // copy-back deleter (reportid to ProcCall)
23294+ case 2013LLU: // copy-back deleter (reportid to ProcCall)
2319323295 {
2319423296 // copy mutable arguments back from call to reportid
23195- label = 1847LLU; // continue to roll stack
23297+ label = 1859LLU; // continue to roll stack
2319623298 break;
2319723299 }
23198- case 2002LLU: // return from reportid to ProcCall
23300+ case 2014LLU: // return from reportid to ProcCall
2319923301 {
2320023302 // copy mutable arguments back from call to reportid
2320123303 fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
2320223304 // call printtoken from ProcCall
23203- stack[base + 43LLU] = 2003LLU/*throw to this address*/;
23305+ stack[base + 43LLU] = 2015LLU/*throw to this address*/;
2320423306 stack[base + 44LLU] = base;
23205- stack[base + 45LLU] = 2004LLU;
23307+ stack[base + 45LLU] = 2016LLU;
2320623308 // arguments for call to printtoken
2320723309 stack[base + 46LLU] = stack[base + 15]/*variant*/;
2320823310 stack[base + 47LLU] = stack[base + 16]/*content*/;
@@ -23211,85 +23313,85 @@
2321123313 label = 18446744073709551583LLU; // printtoken
2321223314 break;
2321323315 }
23214- case 2003LLU: // copy-back deleter (printtoken to ProcCall)
23316+ case 2015LLU: // copy-back deleter (printtoken to ProcCall)
2321523317 {
2321623318 // copy mutable arguments back from call to printtoken
23217- label = 1847LLU; // continue to roll stack
23319+ label = 1859LLU; // continue to roll stack
2321823320 break;
2321923321 }
23220- case 2004LLU: // return from printtoken to ProcCall
23322+ case 2016LLU: // return from printtoken to ProcCall
2322123323 {
2322223324 // copy mutable arguments back from call to printtoken
2322323325 fprintf(stderr, "%s", "\n");
2322423326 {
23225- label = 1847LLU; // throw: begin to unroll stack
23327+ label = 1859LLU; // throw: begin to unroll stack
2322623328 break;
2322723329 }
2322823330
23229- label = 1891LLU; // alternative complete
23331+ label = 1903LLU; // alternative complete
2323023332 break;
2323123333 }
23232- case 1891LLU: // completed if-then-else
23334+ case 1903LLU: // completed if-then-else
2323323335 {
23234- label = 1853LLU; // alternative complete
23336+ label = 1865LLU; // alternative complete
2323523337 break;
2323623338 }
23237- case 1853LLU: // completed if-then-else
23339+ case 1865LLU: // completed if-then-else
2323823340 {
2323923341 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2324023342 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23241- label = 1845LLU; // case complete
23343+ label = 1857LLU; // case complete
2324223344 break;
2324323345 }
23244- case 1847LLU: // copy-back deleter (switch)
23346+ case 1859LLU: // copy-back deleter (switch)
2324523347 {
2324623348 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2324723349 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23248- label = 1844LLU; // continue to unroll stack
23350+ label = 1856LLU; // continue to unroll stack
2324923351 break;
2325023352 }
23251- case 1846LLU: // try next case
23353+ case 1858LLU: // try next case
2325223354 {
2325323355 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2325423356 exit(-1);
2325523357 }
23256- case 1845LLU: // completed switch
23358+ case 1857LLU: // completed switch
2325723359 {
2325823360 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2325923361 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23260- label = 1842LLU; // case complete
23362+ label = 1854LLU; // case complete
2326123363 break;
2326223364 }
23263- case 1844LLU: // copy-back deleter (switch)
23365+ case 1856LLU: // copy-back deleter (switch)
2326423366 {
2326523367 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2326623368 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23267- label = 1827LLU; // continue to unroll stack
23369+ label = 1839LLU; // continue to unroll stack
2326823370 break;
2326923371 }
23270- case 1843LLU: // try next case
23372+ case 1855LLU: // try next case
2327123373 {
2327223374 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2327323375 exit(-1);
2327423376 }
23275- case 1842LLU: // completed switch
23377+ case 1854LLU: // completed switch
2327623378 {
2327723379 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23278- label = 1825LLU; // repeat
23380+ label = 1837LLU; // repeat
2327923381 break;
2328023382 }
23281- case 1827LLU: // copy-back deleter for while next
23383+ case 1839LLU: // copy-back deleter for while next
2328223384 {
2328323385 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23284- label = 1823LLU; // continue to unroll stack
23386+ label = 1835LLU; // continue to unroll stack
2328523387 break;
2328623388 }
23287- case 1826LLU: // loop finished
23389+ case 1838LLU: // loop finished
2328823390 {
2328923391 // call equ from ProcCall
23290- stack[base + 39LLU] = 2005LLU/*throw to this address*/;
23392+ stack[base + 39LLU] = 2017LLU/*throw to this address*/;
2329123393 stack[base + 40LLU] = base;
23292- stack[base + 41LLU] = 2006LLU;
23394+ stack[base + 41LLU] = 2018LLU;
2329323395 // arguments for call to equ
2329423396 stack[base + 43LLU] = stack[base + 8]/*fnid*/;
2329523397 stack[base + 44LLU] = stack[base + 24]/*ceid*/;
@@ -23298,13 +23400,13 @@
2329823400 label = 18446744073709551600LLU; // equ
2329923401 break;
2330023402 }
23301- case 2005LLU: // copy-back deleter (equ to ProcCall)
23403+ case 2017LLU: // copy-back deleter (equ to ProcCall)
2330223404 {
2330323405 // copy mutable arguments back from call to equ
23304- label = 1823LLU; // continue to roll stack
23406+ label = 1835LLU; // continue to roll stack
2330523407 break;
2330623408 }
23307- case 2006LLU: // return from equ to ProcCall
23409+ case 2018LLU: // return from equ to ProcCall
2330823410 {
2330923411 // copy mutable arguments back from call to equ
2331023412 // copy back results provided by call to equ
@@ -23311,7 +23413,7 @@
2331123413 stack[base + 18] = stack[base + 42LLU];
2331223414 if(!stack[base + 18]/*isequal*/)
2331323415 {
23314- label = 2007LLU; // jump to alternative
23416+ label = 2019LLU; // jump to alternative
2331523417 break;
2331623418 }
2331723419
@@ -23318,21 +23420,21 @@
2331823420 // consequent
2331923421 if(!stack[base + 35]/*csubstruct*/)
2332023422 {
23321- label = 2009LLU; // jump to alternative
23423+ label = 2021LLU; // jump to alternative
2332223424 break;
2332323425 }
2332423426
2332523427 // consequent
23326- label = 2010LLU; // consequent complete
23428+ label = 2022LLU; // consequent complete
2332723429 break;
2332823430 }
23329- case 2009LLU: // alternative
23431+ case 2021LLU: // alternative
2333023432 {
2333123433 fprintf(stderr, "%s", "in function ");
2333223434 // call reportid from ProcCall
23333- stack[base + 39LLU] = 2011LLU/*throw to this address*/;
23435+ stack[base + 39LLU] = 2023LLU/*throw to this address*/;
2333423436 stack[base + 40LLU] = base;
23335- stack[base + 41LLU] = 2012LLU;
23437+ stack[base + 41LLU] = 2024LLU;
2333623438 // arguments for call to reportid
2333723439 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2333823440 // set stack-base & callee-address
@@ -23340,20 +23442,20 @@
2334023442 label = 18446744073709551586LLU; // reportid
2334123443 break;
2334223444 }
23343- case 2011LLU: // copy-back deleter (reportid to ProcCall)
23445+ case 2023LLU: // copy-back deleter (reportid to ProcCall)
2334423446 {
2334523447 // copy mutable arguments back from call to reportid
23346- label = 1823LLU; // continue to roll stack
23448+ label = 1835LLU; // continue to roll stack
2334723449 break;
2334823450 }
23349- case 2012LLU: // return from reportid to ProcCall
23451+ case 2024LLU: // return from reportid to ProcCall
2335023452 {
2335123453 // copy mutable arguments back from call to reportid
2335223454 fprintf(stderr, "%s", " recursive call to ");
2335323455 // call reportid from ProcCall
23354- stack[base + 39LLU] = 2013LLU/*throw to this address*/;
23456+ stack[base + 39LLU] = 2025LLU/*throw to this address*/;
2335523457 stack[base + 40LLU] = base;
23356- stack[base + 41LLU] = 2014LLU;
23458+ stack[base + 41LLU] = 2026LLU;
2335723459 // arguments for call to reportid
2335823460 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2335923461 // set stack-base & callee-address
@@ -23361,35 +23463,35 @@
2336123463 label = 18446744073709551586LLU; // reportid
2336223464 break;
2336323465 }
23364- case 2013LLU: // copy-back deleter (reportid to ProcCall)
23466+ case 2025LLU: // copy-back deleter (reportid to ProcCall)
2336523467 {
2336623468 // copy mutable arguments back from call to reportid
23367- label = 1823LLU; // continue to roll stack
23469+ label = 1835LLU; // continue to roll stack
2336823470 break;
2336923471 }
23370- case 2014LLU: // return from reportid to ProcCall
23472+ case 2026LLU: // return from reportid to ProcCall
2337123473 {
2337223474 // copy mutable arguments back from call to reportid
2337323475 fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of CONSTANT parameter, obtained by switch case / while next / if next / getbyte)\n");
2337423476 {
23375- label = 1823LLU; // throw: begin to unroll stack
23477+ label = 1835LLU; // throw: begin to unroll stack
2337623478 break;
2337723479 }
2337823480
23379- label = 2010LLU; // alternative complete
23481+ label = 2022LLU; // alternative complete
2338023482 break;
2338123483 }
23382- case 2010LLU: // completed if-then-else
23484+ case 2022LLU: // completed if-then-else
2338323485 {
23384- label = 2008LLU; // consequent complete
23486+ label = 2020LLU; // consequent complete
2338523487 break;
2338623488 }
23387- case 2007LLU: // alternative
23489+ case 2019LLU: // alternative
2338823490 {
23389- label = 2008LLU; // alternative complete
23491+ label = 2020LLU; // alternative complete
2339023492 break;
2339123493 }
23392- case 2008LLU: // completed if-then-else
23494+ case 2020LLU: // completed if-then-else
2339323495 {
2339423496 printf("%s", "\n stack = newstack;");
2339523497 printf("%s", "\n // set stack-base & callee-address");
@@ -23396,9 +23498,9 @@
2339623498 printf("%s", "\n base = 4/*deloffset*/;");
2339723499 printf("%s", "\n label = ");
2339823500 // call printnr from ProcCall
23399- stack[base + 35LLU] = 2015LLU/*throw to this address*/;
23501+ stack[base + 35LLU] = 2027LLU/*throw to this address*/;
2340023502 stack[base + 36LLU] = base;
23401- stack[base + 37LLU] = 2016LLU;
23503+ stack[base + 37LLU] = 2028LLU;
2340223504 // arguments for call to printnr
2340323505 stack[base + 38LLU] = stack[base + 20]/*celabel*/;
2340423506 // set stack-base & callee-address
@@ -23406,20 +23508,20 @@
2340623508 label = 18446744073709551590LLU; // printnr
2340723509 break;
2340823510 }
23409- case 2015LLU: // copy-back deleter (printnr to ProcCall)
23511+ case 2027LLU: // copy-back deleter (printnr to ProcCall)
2341023512 {
2341123513 // copy mutable arguments back from call to printnr
23412- label = 1795LLU; // continue to roll stack
23514+ label = 1807LLU; // continue to roll stack
2341323515 break;
2341423516 }
23415- case 2016LLU: // return from printnr to ProcCall
23517+ case 2028LLU: // return from printnr to ProcCall
2341623518 {
2341723519 // copy mutable arguments back from call to printnr
2341823520 printf("%s", "LLU; // ");
2341923521 // call printid from ProcCall
23420- stack[base + 35LLU] = 2017LLU/*throw to this address*/;
23522+ stack[base + 35LLU] = 2029LLU/*throw to this address*/;
2342123523 stack[base + 36LLU] = base;
23422- stack[base + 37LLU] = 2018LLU;
23524+ stack[base + 37LLU] = 2030LLU;
2342323525 // arguments for call to printid
2342423526 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2342523527 // set stack-base & callee-address
@@ -23427,13 +23529,13 @@
2342723529 label = 18446744073709551587LLU; // printid
2342823530 break;
2342923531 }
23430- case 2017LLU: // copy-back deleter (printid to ProcCall)
23532+ case 2029LLU: // copy-back deleter (printid to ProcCall)
2343123533 {
2343223534 // copy mutable arguments back from call to printid
23433- label = 1795LLU; // continue to roll stack
23535+ label = 1807LLU; // continue to roll stack
2343423536 break;
2343523537 }
23436- case 2018LLU: // return from printid to ProcCall
23538+ case 2030LLU: // return from printid to ProcCall
2343723539 {
2343823540 // copy mutable arguments back from call to printid
2343923541 printf("%s", "\n break;");
@@ -23440,7 +23542,7 @@
2344023542 printf("%s", "\n }");
2344123543 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2344223544 {
23443- label = 2020LLU; // jump to alternative
23545+ label = 2032LLU; // jump to alternative
2344423546 break;
2344523547 }
2344623548
@@ -23450,9 +23552,9 @@
2345023552 // case
2345123553 printf("%s", "\n case ");
2345223554 // call printnr from ProcCall
23453- stack[base + 37LLU] = 2022LLU/*throw to this address*/;
23555+ stack[base + 37LLU] = 2034LLU/*throw to this address*/;
2345423556 stack[base + 38LLU] = base;
23455- stack[base + 39LLU] = 2023LLU;
23557+ stack[base + 39LLU] = 2035LLU;
2345623558 // arguments for call to printnr
2345723559 stack[base + 40LLU] = stack[base + 33]/*labelfail*/;
2345823560 // set stack-base & callee-address
@@ -23460,20 +23562,20 @@
2346023562 label = 18446744073709551590LLU; // printnr
2346123563 break;
2346223564 }
23463- case 2022LLU: // copy-back deleter (printnr to ProcCall)
23565+ case 2034LLU: // copy-back deleter (printnr to ProcCall)
2346423566 {
2346523567 // copy mutable arguments back from call to printnr
23466- label = 2021LLU; // continue to roll stack
23568+ label = 2033LLU; // continue to roll stack
2346723569 break;
2346823570 }
23469- case 2023LLU: // return from printnr to ProcCall
23571+ case 2035LLU: // return from printnr to ProcCall
2347023572 {
2347123573 // copy mutable arguments back from call to printnr
2347223574 printf("%s", "LLU: // copy-back deleter (");
2347323575 // call printid from ProcCall
23474- stack[base + 37LLU] = 2024LLU/*throw to this address*/;
23576+ stack[base + 37LLU] = 2036LLU/*throw to this address*/;
2347523577 stack[base + 38LLU] = base;
23476- stack[base + 39LLU] = 2025LLU;
23578+ stack[base + 39LLU] = 2037LLU;
2347723579 // arguments for call to printid
2347823580 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2347923581 // set stack-base & callee-address
@@ -23481,20 +23583,20 @@
2348123583 label = 18446744073709551587LLU; // printid
2348223584 break;
2348323585 }
23484- case 2024LLU: // copy-back deleter (printid to ProcCall)
23586+ case 2036LLU: // copy-back deleter (printid to ProcCall)
2348523587 {
2348623588 // copy mutable arguments back from call to printid
23487- label = 2021LLU; // continue to roll stack
23589+ label = 2033LLU; // continue to roll stack
2348823590 break;
2348923591 }
23490- case 2025LLU: // return from printid to ProcCall
23592+ case 2037LLU: // return from printid to ProcCall
2349123593 {
2349223594 // copy mutable arguments back from call to printid
2349323595 printf("%s", " to ");
2349423596 // call printid from ProcCall
23495- stack[base + 37LLU] = 2026LLU/*throw to this address*/;
23597+ stack[base + 37LLU] = 2038LLU/*throw to this address*/;
2349623598 stack[base + 38LLU] = base;
23497- stack[base + 39LLU] = 2027LLU;
23599+ stack[base + 39LLU] = 2039LLU;
2349823600 // arguments for call to printid
2349923601 stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2350023602 // set stack-base & callee-address
@@ -23502,13 +23604,13 @@
2350223604 label = 18446744073709551587LLU; // printid
2350323605 break;
2350423606 }
23505- case 2026LLU: // copy-back deleter (printid to ProcCall)
23607+ case 2038LLU: // copy-back deleter (printid to ProcCall)
2350623608 {
2350723609 // copy mutable arguments back from call to printid
23508- label = 2021LLU; // continue to roll stack
23610+ label = 2033LLU; // continue to roll stack
2350923611 break;
2351023612 }
23511- case 2027LLU: // return from printid to ProcCall
23613+ case 2039LLU: // return from printid to ProcCall
2351223614 {
2351323615 // copy mutable arguments back from call to printid
2351423616 printf("%s", ")");
@@ -23516,9 +23618,9 @@
2351623618 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2351723619 printf("%s", "\n // copy mutable arguments back from call to ");
2351823620 // call printid from ProcCall
23519- stack[base + 37LLU] = 2028LLU/*throw to this address*/;
23621+ stack[base + 37LLU] = 2040LLU/*throw to this address*/;
2352023622 stack[base + 38LLU] = base;
23521- stack[base + 39LLU] = 2029LLU;
23623+ stack[base + 39LLU] = 2041LLU;
2352223624 // arguments for call to printid
2352323625 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2352423626 // set stack-base & callee-address
@@ -23526,24 +23628,24 @@
2352623628 label = 18446744073709551587LLU; // printid
2352723629 break;
2352823630 }
23529- case 2028LLU: // copy-back deleter (printid to ProcCall)
23631+ case 2040LLU: // copy-back deleter (printid to ProcCall)
2353023632 {
2353123633 // copy mutable arguments back from call to printid
23532- label = 2021LLU; // continue to roll stack
23634+ label = 2033LLU; // continue to roll stack
2353323635 break;
2353423636 }
23535- case 2029LLU: // return from printid to ProcCall
23637+ case 2041LLU: // return from printid to ProcCall
2353623638 {
2353723639 // copy mutable arguments back from call to printid
2353823640 flippedassign(stack[base + 19]/*copyback*/, &stack[base + 37]);
23539- label = 2030LLU; // start to repeat
23641+ label = 2042LLU; // start to repeat
2354023642 break;
2354123643 }
23542- case 2030LLU: // repeat from here
23644+ case 2042LLU: // repeat from here
2354323645 {
2354423646 if(!stack[base + 37])
2354523647 {
23546- label = 2031LLU; // break loop
23648+ label = 2043LLU; // break loop
2354723649 break;
2354823650 }
2354923651
@@ -23553,7 +23655,7 @@
2355323655 stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->next);
2355423656 if(/*idnr*/0 != ((uint64_t *)(stack[base + 38]/*idnr*/))[0])
2355523657 {
23556- label = 2034LLU; // jump to alternative
23658+ label = 2046LLU; // jump to alternative
2355723659 break;
2355823660 }
2355923661
@@ -23563,9 +23665,9 @@
2356323665 // case
2356423666 printf("%s", "\n old");
2356523667 // call emitvar from ProcCall
23566- stack[base + 42LLU] = 2036LLU/*throw to this address*/;
23668+ stack[base + 42LLU] = 2048LLU/*throw to this address*/;
2356723669 stack[base + 43LLU] = base;
23568- stack[base + 44LLU] = 2037LLU;
23670+ stack[base + 44LLU] = 2049LLU;
2356923671 // arguments for call to emitvar
2357023672 stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2357123673 stack[base + 46LLU] = stack[base + 40]/*content*/;
@@ -23576,20 +23678,20 @@
2357623678 label = 749LLU; // emitvar
2357723679 break;
2357823680 }
23579- case 2036LLU: // copy-back deleter (emitvar to ProcCall)
23681+ case 2048LLU: // copy-back deleter (emitvar to ProcCall)
2358023682 {
2358123683 // copy mutable arguments back from call to emitvar
23582- label = 2035LLU; // continue to roll stack
23684+ label = 2047LLU; // continue to roll stack
2358323685 break;
2358423686 }
23585- case 2037LLU: // return from emitvar to ProcCall
23687+ case 2049LLU: // return from emitvar to ProcCall
2358623688 {
2358723689 // copy mutable arguments back from call to emitvar
2358823690 printf("%s", " = stack[");
2358923691 // call printnr from ProcCall
23590- stack[base + 42LLU] = 2038LLU/*throw to this address*/;
23692+ stack[base + 42LLU] = 2050LLU/*throw to this address*/;
2359123693 stack[base + 43LLU] = base;
23592- stack[base + 44LLU] = 2039LLU;
23694+ stack[base + 44LLU] = 2051LLU;
2359323695 // arguments for call to printnr
2359423696 stack[base + 45LLU] = stack[base + 41]/*sum*/;
2359523697 // set stack-base & callee-address
@@ -23597,52 +23699,52 @@
2359723699 label = 18446744073709551590LLU; // printnr
2359823700 break;
2359923701 }
23600- case 2038LLU: // copy-back deleter (printnr to ProcCall)
23702+ case 2050LLU: // copy-back deleter (printnr to ProcCall)
2360123703 {
2360223704 // copy mutable arguments back from call to printnr
23603- label = 2035LLU; // continue to roll stack
23705+ label = 2047LLU; // continue to roll stack
2360423706 break;
2360523707 }
23606- case 2039LLU: // return from printnr to ProcCall
23708+ case 2051LLU: // return from printnr to ProcCall
2360723709 {
2360823710 // copy mutable arguments back from call to printnr
2360923711 printf("%s", "LLU];");
2361023712 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2361123713 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23612- label = 2033LLU; // case complete
23714+ label = 2045LLU; // case complete
2361323715 break;
2361423716 }
23615- case 2035LLU: // copy-back deleter (switch)
23717+ case 2047LLU: // copy-back deleter (switch)
2361623718 {
2361723719 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2361823720 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23619- label = 2032LLU; // continue to unroll stack
23721+ label = 2044LLU; // continue to unroll stack
2362023722 break;
2362123723 }
23622- case 2034LLU: // try next case
23724+ case 2046LLU: // try next case
2362323725 {
2362423726 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2362523727 exit(-1);
2362623728 }
23627- case 2033LLU: // completed switch
23729+ case 2045LLU: // completed switch
2362823730 {
2362923731 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23630- label = 2030LLU; // repeat
23732+ label = 2042LLU; // repeat
2363123733 break;
2363223734 }
23633- case 2032LLU: // copy-back deleter for while next
23735+ case 2044LLU: // copy-back deleter for while next
2363423736 {
2363523737 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23636- label = 2021LLU; // continue to unroll stack
23738+ label = 2033LLU; // continue to unroll stack
2363723739 break;
2363823740 }
23639- case 2031LLU: // loop finished
23741+ case 2043LLU: // loop finished
2364023742 {
2364123743 printf("%s", "\n if(stack[");
2364223744 // call printnr from ProcCall
23643- stack[base + 40LLU] = 2040LLU/*throw to this address*/;
23745+ stack[base + 40LLU] = 2052LLU/*throw to this address*/;
2364423746 stack[base + 41LLU] = base;
23645- stack[base + 42LLU] = 2041LLU;
23747+ stack[base + 42LLU] = 2053LLU;
2364623748 // arguments for call to printnr
2364723749 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2364823750 // set stack-base & callee-address
@@ -23650,13 +23752,13 @@
2365023752 label = 18446744073709551590LLU; // printnr
2365123753 break;
2365223754 }
23653- case 2040LLU: // copy-back deleter (printnr to ProcCall)
23755+ case 2052LLU: // copy-back deleter (printnr to ProcCall)
2365423756 {
2365523757 // copy mutable arguments back from call to printnr
23656- label = 2021LLU; // continue to roll stack
23758+ label = 2033LLU; // continue to roll stack
2365723759 break;
2365823760 }
23659- case 2041LLU: // return from printnr to ProcCall
23761+ case 2053LLU: // return from printnr to ProcCall
2366023762 {
2366123763 // copy mutable arguments back from call to printnr
2366223764 printf("%s", "LLU] != 9876543210LLU)");
@@ -23663,9 +23765,9 @@
2366323765 printf("%s", "\n {");
2366423766 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2366523767 // call printid from ProcCall
23666- stack[base + 40LLU] = 2042LLU/*throw to this address*/;
23768+ stack[base + 40LLU] = 2054LLU/*throw to this address*/;
2366723769 stack[base + 41LLU] = base;
23668- stack[base + 42LLU] = 2043LLU;
23770+ stack[base + 42LLU] = 2055LLU;
2366923771 // arguments for call to printid
2367023772 stack[base + 43LLU] = stack[base + 24]/*ceid*/;
2367123773 // set stack-base & callee-address
@@ -23673,13 +23775,13 @@
2367323775 label = 18446744073709551587LLU; // printid
2367423776 break;
2367523777 }
23676- case 2042LLU: // copy-back deleter (printid to ProcCall)
23778+ case 2054LLU: // copy-back deleter (printid to ProcCall)
2367723779 {
2367823780 // copy mutable arguments back from call to printid
23679- label = 2021LLU; // continue to roll stack
23781+ label = 2033LLU; // continue to roll stack
2368023782 break;
2368123783 }
23682- case 2043LLU: // return from printid to ProcCall
23784+ case 2055LLU: // return from printid to ProcCall
2368323785 {
2368423786 // copy mutable arguments back from call to printid
2368523787 printf("%s", ")!\\n\");");
@@ -23687,9 +23789,9 @@
2368723789 printf("%s", "\n }");
2368823790 printf("%s", "\n Free(");
2368923791 // call printnr from ProcCall
23690- stack[base + 40LLU] = 2044LLU/*throw to this address*/;
23792+ stack[base + 40LLU] = 2056LLU/*throw to this address*/;
2369123793 stack[base + 41LLU] = base;
23692- stack[base + 42LLU] = 2045LLU;
23794+ stack[base + 42LLU] = 2057LLU;
2369323795 // arguments for call to printnr
2369423796 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2369523797 // set stack-base & callee-address
@@ -23697,13 +23799,13 @@
2369723799 label = 18446744073709551590LLU; // printnr
2369823800 break;
2369923801 }
23700- case 2044LLU: // copy-back deleter (printnr to ProcCall)
23802+ case 2056LLU: // copy-back deleter (printnr to ProcCall)
2370123803 {
2370223804 // copy mutable arguments back from call to printnr
23703- label = 2021LLU; // continue to roll stack
23805+ label = 2033LLU; // continue to roll stack
2370423806 break;
2370523807 }
23706- case 2045LLU: // return from printnr to ProcCall
23808+ case 2057LLU: // return from printnr to ProcCall
2370723809 {
2370823810 // copy mutable arguments back from call to printnr
2370923811 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
@@ -23710,9 +23812,9 @@
2371023812 printf("%s", "\n stack = oldstack;");
2371123813 printf("%s", "\n label = ");
2371223814 // call printnr from ProcCall
23713- stack[base + 40LLU] = 2046LLU/*throw to this address*/;
23815+ stack[base + 40LLU] = 2058LLU/*throw to this address*/;
2371423816 stack[base + 41LLU] = base;
23715- stack[base + 42LLU] = 2047LLU;
23817+ stack[base + 42LLU] = 2059LLU;
2371623818 // arguments for call to printnr
2371723819 stack[base + 43LLU] = stack[base + 35]/*labelthrow*/;
2371823820 // set stack-base & callee-address
@@ -23720,13 +23822,13 @@
2372023822 label = 18446744073709551590LLU; // printnr
2372123823 break;
2372223824 }
23723- case 2046LLU: // copy-back deleter (printnr to ProcCall)
23825+ case 2058LLU: // copy-back deleter (printnr to ProcCall)
2372423826 {
2372523827 // copy mutable arguments back from call to printnr
23726- label = 2021LLU; // continue to roll stack
23828+ label = 2033LLU; // continue to roll stack
2372723829 break;
2372823830 }
23729- case 2047LLU: // return from printnr to ProcCall
23831+ case 2059LLU: // return from printnr to ProcCall
2373023832 {
2373123833 // copy mutable arguments back from call to printnr
2373223834 printf("%s", "LLU; // continue to unroll stack");
@@ -23734,28 +23836,28 @@
2373423836 printf("%s", "\n }");
2373523837 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2373623838 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23737- label = 2019LLU; // case complete
23839+ label = 2031LLU; // case complete
2373823840 break;
2373923841 }
23740- case 2021LLU: // copy-back deleter (switch)
23842+ case 2033LLU: // copy-back deleter (switch)
2374123843 {
2374223844 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2374323845 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23744- label = 1795LLU; // continue to unroll stack
23846+ label = 1807LLU; // continue to unroll stack
2374523847 break;
2374623848 }
23747- case 2020LLU: // try next case
23849+ case 2032LLU: // try next case
2374823850 {
2374923851 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2375023852 exit(-1);
2375123853 }
23752- case 2019LLU: // completed switch
23854+ case 2031LLU: // completed switch
2375323855 {
2375423856 printf("%s", "\n case ");
2375523857 // call printnr from ProcCall
23756- stack[base + 35LLU] = 2048LLU/*throw to this address*/;
23858+ stack[base + 35LLU] = 2060LLU/*throw to this address*/;
2375723859 stack[base + 36LLU] = base;
23758- stack[base + 37LLU] = 2049LLU;
23860+ stack[base + 37LLU] = 2061LLU;
2375923861 // arguments for call to printnr
2376023862 stack[base + 38LLU] = stack[base + 17]/*label*/;
2376123863 // set stack-base & callee-address
@@ -23763,20 +23865,20 @@
2376323865 label = 18446744073709551590LLU; // printnr
2376423866 break;
2376523867 }
23766- case 2048LLU: // copy-back deleter (printnr to ProcCall)
23868+ case 2060LLU: // copy-back deleter (printnr to ProcCall)
2376723869 {
2376823870 // copy mutable arguments back from call to printnr
23769- label = 1795LLU; // continue to roll stack
23871+ label = 1807LLU; // continue to roll stack
2377023872 break;
2377123873 }
23772- case 2049LLU: // return from printnr to ProcCall
23874+ case 2061LLU: // return from printnr to ProcCall
2377323875 {
2377423876 // copy mutable arguments back from call to printnr
2377523877 printf("%s", "LLU: // return from ");
2377623878 // call printid from ProcCall
23777- stack[base + 35LLU] = 2050LLU/*throw to this address*/;
23879+ stack[base + 35LLU] = 2062LLU/*throw to this address*/;
2377823880 stack[base + 36LLU] = base;
23779- stack[base + 37LLU] = 2051LLU;
23881+ stack[base + 37LLU] = 2063LLU;
2378023882 // arguments for call to printid
2378123883 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2378223884 // set stack-base & callee-address
@@ -23784,20 +23886,20 @@
2378423886 label = 18446744073709551587LLU; // printid
2378523887 break;
2378623888 }
23787- case 2050LLU: // copy-back deleter (printid to ProcCall)
23889+ case 2062LLU: // copy-back deleter (printid to ProcCall)
2378823890 {
2378923891 // copy mutable arguments back from call to printid
23790- label = 1795LLU; // continue to roll stack
23892+ label = 1807LLU; // continue to roll stack
2379123893 break;
2379223894 }
23793- case 2051LLU: // return from printid to ProcCall
23895+ case 2063LLU: // return from printid to ProcCall
2379423896 {
2379523897 // copy mutable arguments back from call to printid
2379623898 printf("%s", " to ");
2379723899 // call printid from ProcCall
23798- stack[base + 35LLU] = 2052LLU/*throw to this address*/;
23900+ stack[base + 35LLU] = 2064LLU/*throw to this address*/;
2379923901 stack[base + 36LLU] = base;
23800- stack[base + 37LLU] = 2053LLU;
23902+ stack[base + 37LLU] = 2065LLU;
2380123903 // arguments for call to printid
2380223904 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2380323905 // set stack-base & callee-address
@@ -23805,13 +23907,13 @@
2380523907 label = 18446744073709551587LLU; // printid
2380623908 break;
2380723909 }
23808- case 2052LLU: // copy-back deleter (printid to ProcCall)
23910+ case 2064LLU: // copy-back deleter (printid to ProcCall)
2380923911 {
2381023912 // copy mutable arguments back from call to printid
23811- label = 1795LLU; // continue to roll stack
23913+ label = 1807LLU; // continue to roll stack
2381223914 break;
2381323915 }
23814- case 2053LLU: // return from printid to ProcCall
23916+ case 2065LLU: // return from printid to ProcCall
2381523917 {
2381623918 // copy mutable arguments back from call to printid
2381723919 printf("%s", "\n {");
@@ -23818,9 +23920,9 @@
2381823920 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2381923921 printf("%s", "\n // copy mutable arguments back from call to ");
2382023922 // call printid from ProcCall
23821- stack[base + 35LLU] = 2054LLU/*throw to this address*/;
23923+ stack[base + 35LLU] = 2066LLU/*throw to this address*/;
2382223924 stack[base + 36LLU] = base;
23823- stack[base + 37LLU] = 2055LLU;
23925+ stack[base + 37LLU] = 2067LLU;
2382423926 // arguments for call to printid
2382523927 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2382623928 // set stack-base & callee-address
@@ -23828,23 +23930,23 @@
2382823930 label = 18446744073709551587LLU; // printid
2382923931 break;
2383023932 }
23831- case 2054LLU: // copy-back deleter (printid to ProcCall)
23933+ case 2066LLU: // copy-back deleter (printid to ProcCall)
2383223934 {
2383323935 // copy mutable arguments back from call to printid
23834- label = 1795LLU; // continue to roll stack
23936+ label = 1807LLU; // continue to roll stack
2383523937 break;
2383623938 }
23837- case 2055LLU: // return from printid to ProcCall
23939+ case 2067LLU: // return from printid to ProcCall
2383823940 {
2383923941 // copy mutable arguments back from call to printid
23840- label = 2056LLU; // start to repeat
23942+ label = 2068LLU; // start to repeat
2384123943 break;
2384223944 }
23843- case 2056LLU: // repeat from here
23945+ case 2068LLU: // repeat from here
2384423946 {
2384523947 if(!stack[base + 19])
2384623948 {
23847- label = 2057LLU; // break loop
23949+ label = 2069LLU; // break loop
2384823950 break;
2384923951 }
2385023952
@@ -23857,7 +23959,7 @@
2385723959 }
2385823960 if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0])
2385923961 {
23860- label = 2060LLU; // jump to alternative
23962+ label = 2072LLU; // jump to alternative
2386123963 break;
2386223964 }
2386323965
@@ -23867,9 +23969,9 @@
2386723969 // case
2386823970 printf("%s", "\n old");
2386923971 // call emitvar from ProcCall
23870- stack[base + 38LLU] = 2062LLU/*throw to this address*/;
23972+ stack[base + 38LLU] = 2074LLU/*throw to this address*/;
2387123973 stack[base + 39LLU] = base;
23872- stack[base + 40LLU] = 2063LLU;
23974+ stack[base + 40LLU] = 2075LLU;
2387323975 // arguments for call to emitvar
2387423976 stack[base + 41LLU] = stack[base + 8]/*fnid*/;
2387523977 stack[base + 42LLU] = stack[base + 36]/*content*/;
@@ -23880,20 +23982,20 @@
2388023982 label = 749LLU; // emitvar
2388123983 break;
2388223984 }
23883- case 2062LLU: // copy-back deleter (emitvar to ProcCall)
23985+ case 2074LLU: // copy-back deleter (emitvar to ProcCall)
2388423986 {
2388523987 // copy mutable arguments back from call to emitvar
23886- label = 2061LLU; // continue to roll stack
23988+ label = 2073LLU; // continue to roll stack
2388723989 break;
2388823990 }
23889- case 2063LLU: // return from emitvar to ProcCall
23991+ case 2075LLU: // return from emitvar to ProcCall
2389023992 {
2389123993 // copy mutable arguments back from call to emitvar
2389223994 printf("%s", " = stack[");
2389323995 // call printnr from ProcCall
23894- stack[base + 38LLU] = 2064LLU/*throw to this address*/;
23996+ stack[base + 38LLU] = 2076LLU/*throw to this address*/;
2389523997 stack[base + 39LLU] = base;
23896- stack[base + 40LLU] = 2065LLU;
23998+ stack[base + 40LLU] = 2077LLU;
2389723999 // arguments for call to printnr
2389824000 stack[base + 41LLU] = stack[base + 37]/*sum*/;
2389924001 // set stack-base & callee-address
@@ -23901,34 +24003,34 @@
2390124003 label = 18446744073709551590LLU; // printnr
2390224004 break;
2390324005 }
23904- case 2064LLU: // copy-back deleter (printnr to ProcCall)
24006+ case 2076LLU: // copy-back deleter (printnr to ProcCall)
2390524007 {
2390624008 // copy mutable arguments back from call to printnr
23907- label = 2061LLU; // continue to roll stack
24009+ label = 2073LLU; // continue to roll stack
2390824010 break;
2390924011 }
23910- case 2065LLU: // return from printnr to ProcCall
24012+ case 2077LLU: // return from printnr to ProcCall
2391124013 {
2391224014 // copy mutable arguments back from call to printnr
2391324015 printf("%s", "LLU];");
2391424016 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2391524017 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23916- label = 2059LLU; // case complete
24018+ label = 2071LLU; // case complete
2391724019 break;
2391824020 }
23919- case 2061LLU: // copy-back deleter (switch)
24021+ case 2073LLU: // copy-back deleter (switch)
2392024022 {
2392124023 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2392224024 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23923- label = 2058LLU; // continue to unroll stack
24025+ label = 2070LLU; // continue to unroll stack
2392424026 break;
2392524027 }
23926- case 2060LLU: // try next case
24028+ case 2072LLU: // try next case
2392724029 {
2392824030 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2392924031 exit(-1);
2393024032 }
23931- case 2059LLU: // completed switch
24033+ case 2071LLU: // completed switch
2393224034 {
2393324035
2393424036 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23936,7 +24038,7 @@
2393624038 newstack[0] = (uint64_t)stack; // backup stack location
2393724039 newstack[1] = 1234567890;
2393824040 newstack[2] = base;
23939- newstack[3] = 2066LLU;
24041+ newstack[3] = 2078LLU;
2394024042 stack = newstack;
2394124043 // set stack-base & callee-address
2394224044 base = 4/*deloffset*/;
@@ -23943,16 +24045,16 @@
2394324045 label = 833LLU; // ~idnr
2394424046 break;
2394524047 }
23946- case 2066LLU: // return from ~idnr to ProcCall
24048+ case 2078LLU: // return from ~idnr to ProcCall
2394724049 {
2394824050 stack = (uint64_t *)stack[0];
2394924051 // releasing toplevel container
2395024052 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2395124053
23952- label = 2056LLU; // repeat
24054+ label = 2068LLU; // repeat
2395324055 break;
2395424056 }
23955- case 2058LLU: // copy-back deleter for while next
24057+ case 2070LLU: // copy-back deleter for while next
2395624058 {
2395724059
2395824060 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23960,7 +24062,7 @@
2396024062 newstack[0] = (uint64_t)stack; // backup stack location
2396124063 newstack[1] = 1234567890;
2396224064 newstack[2] = base;
23963- newstack[3] = 2067LLU;
24065+ newstack[3] = 2079LLU;
2396424066 stack = newstack;
2396524067 // set stack-base & callee-address
2396624068 base = 4/*deloffset*/;
@@ -23967,20 +24069,20 @@
2396724069 label = 833LLU; // ~idnr
2396824070 break;
2396924071 }
23970- case 2067LLU: // return from ~idnr to ProcCall
24072+ case 2079LLU: // return from ~idnr to ProcCall
2397124073 {
2397224074 stack = (uint64_t *)stack[0];
2397324075 // releasing toplevel container
2397424076 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2397524077
23976- label = 1795LLU; // continue to unroll stack
24078+ label = 1807LLU; // continue to unroll stack
2397724079 break;
2397824080 }
23979- case 2057LLU: // loop finished
24081+ case 2069LLU: // loop finished
2398024082 {
2398124083 if(!stack[base + 28]/*cerescount*/)
2398224084 {
23983- label = 2068LLU; // jump to alternative
24085+ label = 2080LLU; // jump to alternative
2398424086 break;
2398524087 }
2398624088
@@ -23987,9 +24089,9 @@
2398724089 // consequent
2398824090 printf("%s", "\n // copy back results provided by call to ");
2398924091 // call printid from ProcCall
23990- stack[base + 35LLU] = 2070LLU/*throw to this address*/;
24092+ stack[base + 35LLU] = 2082LLU/*throw to this address*/;
2399124093 stack[base + 36LLU] = base;
23992- stack[base + 37LLU] = 2071LLU;
24094+ stack[base + 37LLU] = 2083LLU;
2399324095 // arguments for call to printid
2399424096 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2399524097 // set stack-base & callee-address
@@ -23997,25 +24099,25 @@
2399724099 label = 18446744073709551587LLU; // printid
2399824100 break;
2399924101 }
24000- case 2070LLU: // copy-back deleter (printid to ProcCall)
24102+ case 2082LLU: // copy-back deleter (printid to ProcCall)
2400124103 {
2400224104 // copy mutable arguments back from call to printid
24003- label = 1795LLU; // continue to roll stack
24105+ label = 1807LLU; // continue to roll stack
2400424106 break;
2400524107 }
24006- case 2071LLU: // return from printid to ProcCall
24108+ case 2083LLU: // return from printid to ProcCall
2400724109 {
2400824110 // copy mutable arguments back from call to printid
2400924111 stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/;
2401024112 flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 35]);
24011- label = 2072LLU; // start to repeat
24113+ label = 2084LLU; // start to repeat
2401224114 break;
2401324115 }
24014- case 2072LLU: // repeat from here
24116+ case 2084LLU: // repeat from here
2401524117 {
2401624118 if(!stack[base + 35])
2401724119 {
24018- label = 2073LLU; // break loop
24120+ label = 2085LLU; // break loop
2401924121 break;
2402024122 }
2402124123
@@ -24024,9 +24126,9 @@
2402424126 stack[base + 37]/*previous*/ = stack[base + 35];
2402524127 stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next);
2402624128 // call sub from ProcCall
24027- stack[base + 38LLU] = 2075LLU/*throw to this address*/;
24129+ stack[base + 38LLU] = 2087LLU/*throw to this address*/;
2402824130 stack[base + 39LLU] = base;
24029- stack[base + 40LLU] = 2076LLU;
24131+ stack[base + 40LLU] = 2088LLU;
2403024132 // arguments for call to sub
2403124133 stack[base + 42LLU] = stack[base + 28]/*cerescount*/;
2403224134 stack[base + 43LLU] = stack[base + 31]/*n*/;
@@ -24035,21 +24137,21 @@
2403524137 label = 18446744073709551604LLU; // sub
2403624138 break;
2403724139 }
24038- case 2075LLU: // copy-back deleter (sub to ProcCall)
24140+ case 2087LLU: // copy-back deleter (sub to ProcCall)
2403924141 {
2404024142 // copy mutable arguments back from call to sub
24041- label = 2074LLU; // continue to roll stack
24143+ label = 2086LLU; // continue to roll stack
2404224144 break;
2404324145 }
24044- case 2076LLU: // return from sub to ProcCall
24146+ case 2088LLU: // return from sub to ProcCall
2404524147 {
2404624148 // copy mutable arguments back from call to sub
2404724149 // copy back results provided by call to sub
2404824150 stack[base + 32] = stack[base + 41LLU];
2404924151 // call sub from ProcCall
24050- stack[base + 38LLU] = 2077LLU/*throw to this address*/;
24152+ stack[base + 38LLU] = 2089LLU/*throw to this address*/;
2405124153 stack[base + 39LLU] = base;
24052- stack[base + 40LLU] = 2078LLU;
24154+ stack[base + 40LLU] = 2090LLU;
2405324155 // arguments for call to sub
2405424156 stack[base + 42LLU] = stack[base + 31]/*n*/;
2405524157 stack[base + 43LLU] = 1LLU;
@@ -24058,13 +24160,13 @@
2405824160 label = 18446744073709551604LLU; // sub
2405924161 break;
2406024162 }
24061- case 2077LLU: // copy-back deleter (sub to ProcCall)
24163+ case 2089LLU: // copy-back deleter (sub to ProcCall)
2406224164 {
2406324165 // copy mutable arguments back from call to sub
24064- label = 2074LLU; // continue to roll stack
24166+ label = 2086LLU; // continue to roll stack
2406524167 break;
2406624168 }
24067- case 2078LLU: // return from sub to ProcCall
24169+ case 2090LLU: // return from sub to ProcCall
2406824170 {
2406924171 // copy mutable arguments back from call to sub
2407024172 // copy back results provided by call to sub
@@ -24073,7 +24175,7 @@
2407324175 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
2407424176 if(!list)
2407524177 {
24076- label = 2079LLU; // jump to alternative
24178+ label = 2091LLU; // jump to alternative
2407724179 break;
2407824180 }
2407924181
@@ -24085,7 +24187,7 @@
2408524187 }
2408624188 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0])
2408724189 {
24088- label = 2083LLU; // jump to alternative
24190+ label = 2095LLU; // jump to alternative
2408924191 break;
2409024192 }
2409124193
@@ -24095,7 +24197,7 @@
2409524197 // case
2409624198 if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0])
2409724199 {
24098- label = 2086LLU; // jump to alternative
24200+ label = 2098LLU; // jump to alternative
2409924201 break;
2410024202 }
2410124203
@@ -24106,7 +24208,7 @@
2410624208 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2410724209 if(!newstack)
2410824210 {
24109- label = 2087LLU; // throw: begin to unroll stack
24211+ label = 2099LLU; // throw: begin to unroll stack
2411024212 break;
2411124213 }
2411224214
@@ -24113,9 +24215,9 @@
2411324215 newstack[15LLU] = 9876543210LLU; // overflow-marker
2411424216 // call equtype from ProcCall
2411524217 newstack[0] = (uint64_t)stack; // backup stack location
24116- newstack[1] = 2088LLU;
24218+ newstack[1] = 2100LLU;
2411724219 newstack[2] = base;
24118- newstack[3] = 2089LLU;
24220+ newstack[3] = 2101LLU;
2411924221 // arguments for call to equtype
2412024222 newstack[5LLU] = stack[base + 39]/*dsttype*/;
2412124223 newstack[6LLU] = stack[base + 41]/*srctype*/;
@@ -24125,7 +24227,7 @@
2412524227 label = 359LLU; // equtype
2412624228 break;
2412724229 }
24128- case 2088LLU: // copy-back deleter (equtype to ProcCall)
24230+ case 2100LLU: // copy-back deleter (equtype to ProcCall)
2412924231 {
2413024232 uint64_t *oldstack = (uint64_t *)stack[0];
2413124233 // copy mutable arguments back from call to equtype
@@ -24136,10 +24238,10 @@
2413624238 }
2413724239 Free(15LLU + 1, sizeof(uint64_t), stack);
2413824240 stack = oldstack;
24139- label = 2087LLU; // continue to unroll stack
24241+ label = 2099LLU; // continue to unroll stack
2414024242 break;
2414124243 }
24142- case 2089LLU: // return from equtype to ProcCall
24244+ case 2101LLU: // return from equtype to ProcCall
2414324245 {
2414424246 uint64_t *oldstack = (uint64_t *)stack[0];
2414524247 // copy mutable arguments back from call to equtype
@@ -24154,21 +24256,21 @@
2415424256 stack = oldstack;
2415524257 if(!stack[base + 18]/*isequal*/)
2415624258 {
24157- label = 2090LLU; // jump to alternative
24259+ label = 2102LLU; // jump to alternative
2415824260 break;
2415924261 }
2416024262
2416124263 // consequent
24162- label = 2091LLU; // consequent complete
24264+ label = 2103LLU; // consequent complete
2416324265 break;
2416424266 }
24165- case 2090LLU: // alternative
24267+ case 2102LLU: // alternative
2416624268 {
2416724269 fprintf(stderr, "%s", "in function ");
2416824270 // call reportid from ProcCall
24169- stack[base + 43LLU] = 2092LLU/*throw to this address*/;
24271+ stack[base + 43LLU] = 2104LLU/*throw to this address*/;
2417024272 stack[base + 44LLU] = base;
24171- stack[base + 45LLU] = 2093LLU;
24273+ stack[base + 45LLU] = 2105LLU;
2417224274 // arguments for call to reportid
2417324275 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2417424276 // set stack-base & callee-address
@@ -24176,20 +24278,20 @@
2417624278 label = 18446744073709551586LLU; // reportid
2417724279 break;
2417824280 }
24179- case 2092LLU: // copy-back deleter (reportid to ProcCall)
24281+ case 2104LLU: // copy-back deleter (reportid to ProcCall)
2418024282 {
2418124283 // copy mutable arguments back from call to reportid
24182- label = 2087LLU; // continue to roll stack
24284+ label = 2099LLU; // continue to roll stack
2418324285 break;
2418424286 }
24185- case 2093LLU: // return from reportid to ProcCall
24287+ case 2105LLU: // return from reportid to ProcCall
2418624288 {
2418724289 // copy mutable arguments back from call to reportid
2418824290 fprintf(stderr, "%s", " call to ");
2418924291 // call reportid from ProcCall
24190- stack[base + 43LLU] = 2094LLU/*throw to this address*/;
24292+ stack[base + 43LLU] = 2106LLU/*throw to this address*/;
2419124293 stack[base + 44LLU] = base;
24192- stack[base + 45LLU] = 2095LLU;
24294+ stack[base + 45LLU] = 2107LLU;
2419324295 // arguments for call to reportid
2419424296 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2419524297 // set stack-base & callee-address
@@ -24197,20 +24299,20 @@
2419724299 label = 18446744073709551586LLU; // reportid
2419824300 break;
2419924301 }
24200- case 2094LLU: // copy-back deleter (reportid to ProcCall)
24302+ case 2106LLU: // copy-back deleter (reportid to ProcCall)
2420124303 {
2420224304 // copy mutable arguments back from call to reportid
24203- label = 2087LLU; // continue to roll stack
24305+ label = 2099LLU; // continue to roll stack
2420424306 break;
2420524307 }
24206- case 2095LLU: // return from reportid to ProcCall
24308+ case 2107LLU: // return from reportid to ProcCall
2420724309 {
2420824310 // copy mutable arguments back from call to reportid
2420924311 fprintf(stderr, "%s", " at position ");
2421024312 // call reportnr from ProcCall
24211- stack[base + 43LLU] = 2096LLU/*throw to this address*/;
24313+ stack[base + 43LLU] = 2108LLU/*throw to this address*/;
2421224314 stack[base + 44LLU] = base;
24213- stack[base + 45LLU] = 2097LLU;
24315+ stack[base + 45LLU] = 2109LLU;
2421424316 // arguments for call to reportnr
2421524317 stack[base + 46LLU] = stack[base + 32]/*index*/;
2421624318 // set stack-base & callee-address
@@ -24218,13 +24320,13 @@
2421824320 label = 18446744073709551589LLU; // reportnr
2421924321 break;
2422024322 }
24221- case 2096LLU: // copy-back deleter (reportnr to ProcCall)
24323+ case 2108LLU: // copy-back deleter (reportnr to ProcCall)
2422224324 {
2422324325 // copy mutable arguments back from call to reportnr
24224- label = 2087LLU; // continue to roll stack
24326+ label = 2099LLU; // continue to roll stack
2422524327 break;
2422624328 }
24227- case 2097LLU: // return from reportnr to ProcCall
24329+ case 2109LLU: // return from reportnr to ProcCall
2422824330 {
2422924331 // copy mutable arguments back from call to reportnr
2423024332 fprintf(stderr, "%s", " cannot return source of type ");
@@ -24231,7 +24333,7 @@
2423124333 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2423224334 if(!newstack)
2423324335 {
24234- label = 2087LLU; // throw: begin to unroll stack
24336+ label = 2099LLU; // throw: begin to unroll stack
2423524337 break;
2423624338 }
2423724339
@@ -24238,9 +24340,9 @@
2423824340 newstack[10LLU] = 9876543210LLU; // overflow-marker
2423924341 // call reporttype from ProcCall
2424024342 newstack[0] = (uint64_t)stack; // backup stack location
24241- newstack[1] = 2098LLU;
24343+ newstack[1] = 2110LLU;
2424224344 newstack[2] = base;
24243- newstack[3] = 2099LLU;
24345+ newstack[3] = 2111LLU;
2424424346 // arguments for call to reporttype
2424524347 newstack[4LLU] = stack[base + 41]/*srctype*/;
2424624348 stack = newstack;
@@ -24249,7 +24351,7 @@
2424924351 label = 330LLU; // reporttype
2425024352 break;
2425124353 }
24252- case 2098LLU: // copy-back deleter (reporttype to ProcCall)
24354+ case 2110LLU: // copy-back deleter (reporttype to ProcCall)
2425324355 {
2425424356 uint64_t *oldstack = (uint64_t *)stack[0];
2425524357 // copy mutable arguments back from call to reporttype
@@ -24260,10 +24362,10 @@
2426024362 }
2426124363 Free(10LLU + 1, sizeof(uint64_t), stack);
2426224364 stack = oldstack;
24263- label = 2087LLU; // continue to unroll stack
24365+ label = 2099LLU; // continue to unroll stack
2426424366 break;
2426524367 }
24266- case 2099LLU: // return from reporttype to ProcCall
24368+ case 2111LLU: // return from reporttype to ProcCall
2426724369 {
2426824370 uint64_t *oldstack = (uint64_t *)stack[0];
2426924371 // copy mutable arguments back from call to reporttype
@@ -24278,7 +24380,7 @@
2427824380 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2427924381 if(!newstack)
2428024382 {
24281- label = 2087LLU; // throw: begin to unroll stack
24383+ label = 2099LLU; // throw: begin to unroll stack
2428224384 break;
2428324385 }
2428424386
@@ -24285,9 +24387,9 @@
2428524387 newstack[10LLU] = 9876543210LLU; // overflow-marker
2428624388 // call reporttype from ProcCall
2428724389 newstack[0] = (uint64_t)stack; // backup stack location
24288- newstack[1] = 2100LLU;
24390+ newstack[1] = 2112LLU;
2428924391 newstack[2] = base;
24290- newstack[3] = 2101LLU;
24392+ newstack[3] = 2113LLU;
2429124393 // arguments for call to reporttype
2429224394 newstack[4LLU] = stack[base + 39]/*dsttype*/;
2429324395 stack = newstack;
@@ -24296,7 +24398,7 @@
2429624398 label = 330LLU; // reporttype
2429724399 break;
2429824400 }
24299- case 2100LLU: // copy-back deleter (reporttype to ProcCall)
24401+ case 2112LLU: // copy-back deleter (reporttype to ProcCall)
2430024402 {
2430124403 uint64_t *oldstack = (uint64_t *)stack[0];
2430224404 // copy mutable arguments back from call to reporttype
@@ -24307,10 +24409,10 @@
2430724409 }
2430824410 Free(10LLU + 1, sizeof(uint64_t), stack);
2430924411 stack = oldstack;
24310- label = 2087LLU; // continue to unroll stack
24412+ label = 2099LLU; // continue to unroll stack
2431124413 break;
2431224414 }
24313- case 2101LLU: // return from reporttype to ProcCall
24415+ case 2113LLU: // return from reporttype to ProcCall
2431424416 {
2431524417 uint64_t *oldstack = (uint64_t *)stack[0];
2431624418 // copy mutable arguments back from call to reporttype
@@ -24323,20 +24425,20 @@
2432324425 stack = oldstack;
2432424426 fprintf(stderr, "%s", "\n");
2432524427 {
24326- label = 2087LLU; // throw: begin to unroll stack
24428+ label = 2099LLU; // throw: begin to unroll stack
2432724429 break;
2432824430 }
2432924431
24330- label = 2091LLU; // alternative complete
24432+ label = 2103LLU; // alternative complete
2433124433 break;
2433224434 }
24333- case 2091LLU: // completed if-then-else
24435+ case 2103LLU: // completed if-then-else
2433424436 {
2433524437 stack[base + 30]/*sum*/ = 0;
2433624438 // call add from ProcCall
24337- stack[base + 43LLU] = 2102LLU/*throw to this address*/;
24439+ stack[base + 43LLU] = 2114LLU/*throw to this address*/;
2433824440 stack[base + 44LLU] = base;
24339- stack[base + 45LLU] = 2103LLU;
24441+ stack[base + 45LLU] = 2115LLU;
2434024442 // arguments for call to add
2434124443 stack[base + 47LLU] = 4LLU;
2434224444 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24345,21 +24447,21 @@
2434524447 label = 18446744073709551605LLU; // add
2434624448 break;
2434724449 }
24348- case 2102LLU: // copy-back deleter (add to ProcCall)
24450+ case 2114LLU: // copy-back deleter (add to ProcCall)
2434924451 {
2435024452 // copy mutable arguments back from call to add
24351- label = 2087LLU; // continue to roll stack
24453+ label = 2099LLU; // continue to roll stack
2435224454 break;
2435324455 }
24354- case 2103LLU: // return from add to ProcCall
24456+ case 2115LLU: // return from add to ProcCall
2435524457 {
2435624458 // copy mutable arguments back from call to add
2435724459 // copy back results provided by call to add
2435824460 stack[base + 30] = stack[base + 46LLU];
2435924461 // call add from ProcCall
24360- stack[base + 43LLU] = 2104LLU/*throw to this address*/;
24462+ stack[base + 43LLU] = 2116LLU/*throw to this address*/;
2436124463 stack[base + 44LLU] = base;
24362- stack[base + 45LLU] = 2105LLU;
24464+ stack[base + 45LLU] = 2117LLU;
2436324465 // arguments for call to add
2436424466 stack[base + 47LLU] = stack[base + 32]/*index*/;
2436524467 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24368,13 +24470,13 @@
2436824470 label = 18446744073709551605LLU; // add
2436924471 break;
2437024472 }
24371- case 2104LLU: // copy-back deleter (add to ProcCall)
24473+ case 2116LLU: // copy-back deleter (add to ProcCall)
2437224474 {
2437324475 // copy mutable arguments back from call to add
24374- label = 2087LLU; // continue to roll stack
24476+ label = 2099LLU; // continue to roll stack
2437524477 break;
2437624478 }
24377- case 2105LLU: // return from add to ProcCall
24479+ case 2117LLU: // return from add to ProcCall
2437824480 {
2437924481 // copy mutable arguments back from call to add
2438024482 // copy back results provided by call to add
@@ -24381,9 +24483,9 @@
2438124483 stack[base + 30] = stack[base + 46LLU];
2438224484 printf("%s", "\n old");
2438324485 // call emitvaridx from ProcCall
24384- stack[base + 43LLU] = 2106LLU/*throw to this address*/;
24486+ stack[base + 43LLU] = 2118LLU/*throw to this address*/;
2438524487 stack[base + 44LLU] = base;
24386- stack[base + 45LLU] = 2107LLU;
24488+ stack[base + 45LLU] = 2119LLU;
2438724489 // arguments for call to emitvaridx
2438824490 stack[base + 46LLU] = stack[base + 40]/*INDEX*/;
2438924491 // set stack-base & callee-address
@@ -24391,20 +24493,20 @@
2439124493 label = 745LLU; // emitvaridx
2439224494 break;
2439324495 }
24394- case 2106LLU: // copy-back deleter (emitvaridx to ProcCall)
24496+ case 2118LLU: // copy-back deleter (emitvaridx to ProcCall)
2439524497 {
2439624498 // copy mutable arguments back from call to emitvaridx
24397- label = 2087LLU; // continue to roll stack
24499+ label = 2099LLU; // continue to roll stack
2439824500 break;
2439924501 }
24400- case 2107LLU: // return from emitvaridx to ProcCall
24502+ case 2119LLU: // return from emitvaridx to ProcCall
2440124503 {
2440224504 // copy mutable arguments back from call to emitvaridx
2440324505 printf("%s", " = stack[");
2440424506 // call printnr from ProcCall
24405- stack[base + 43LLU] = 2108LLU/*throw to this address*/;
24507+ stack[base + 43LLU] = 2120LLU/*throw to this address*/;
2440624508 stack[base + 44LLU] = base;
24407- stack[base + 45LLU] = 2109LLU;
24509+ stack[base + 45LLU] = 2121LLU;
2440824510 // arguments for call to printnr
2440924511 stack[base + 46LLU] = stack[base + 30]/*sum*/;
2441024512 // set stack-base & callee-address
@@ -24412,53 +24514,53 @@
2441224514 label = 18446744073709551590LLU; // printnr
2441324515 break;
2441424516 }
24415- case 2108LLU: // copy-back deleter (printnr to ProcCall)
24517+ case 2120LLU: // copy-back deleter (printnr to ProcCall)
2441624518 {
2441724519 // copy mutable arguments back from call to printnr
24418- label = 2087LLU; // continue to roll stack
24520+ label = 2099LLU; // continue to roll stack
2441924521 break;
2442024522 }
24421- case 2109LLU: // return from printnr to ProcCall
24523+ case 2121LLU: // return from printnr to ProcCall
2442224524 {
2442324525 // copy mutable arguments back from call to printnr
2442424526 printf("%s", "LLU];");
2442524527 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2442624528 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24427- label = 2085LLU; // case complete
24529+ label = 2097LLU; // case complete
2442824530 break;
2442924531 }
24430- case 2087LLU: // copy-back deleter (switch)
24532+ case 2099LLU: // copy-back deleter (switch)
2443124533 {
2443224534 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2443324535 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24434- label = 2084LLU; // continue to unroll stack
24536+ label = 2096LLU; // continue to unroll stack
2443524537 break;
2443624538 }
24437- case 2086LLU: // try next case
24539+ case 2098LLU: // try next case
2443824540 {
2443924541 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2444024542 exit(-1);
2444124543 }
24442- case 2085LLU: // completed switch
24544+ case 2097LLU: // completed switch
2444324545 {
2444424546 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2444524547 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24446- label = 2082LLU; // case complete
24548+ label = 2094LLU; // case complete
2444724549 break;
2444824550 }
24449- case 2084LLU: // copy-back deleter (switch)
24551+ case 2096LLU: // copy-back deleter (switch)
2445024552 {
2445124553 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2445224554 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24453- label = 2081LLU; // continue to unroll stack
24555+ label = 2093LLU; // continue to unroll stack
2445424556 break;
2445524557 }
24456- case 2083LLU: // try next case
24558+ case 2095LLU: // try next case
2445724559 {
2445824560 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2445924561 exit(-1);
2446024562 }
24461- case 2082LLU: // completed switch
24563+ case 2094LLU: // completed switch
2446224564 {
2446324565
2446424566 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24466,7 +24568,7 @@
2446624568 newstack[0] = (uint64_t)stack; // backup stack location
2446724569 newstack[1] = 1234567890;
2446824570 newstack[2] = base;
24469- newstack[3] = 2110LLU;
24571+ newstack[3] = 2122LLU;
2447024572 stack = newstack;
2447124573 // set stack-base & callee-address
2447224574 base = 4/*deloffset*/;
@@ -24473,16 +24575,16 @@
2447324575 label = 399LLU; // ~typeidx
2447424576 break;
2447524577 }
24476- case 2110LLU: // return from ~typeidx to ProcCall
24578+ case 2122LLU: // return from ~typeidx to ProcCall
2447724579 {
2447824580 stack = (uint64_t *)stack[0];
2447924581 // releasing toplevel container
2448024582 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2448124583
24482- label = 2080LLU; // consequent complete
24584+ label = 2092LLU; // consequent complete
2448324585 break;
2448424586 }
24485- case 2081LLU: // copy-back deleter (if pop)
24587+ case 2093LLU: // copy-back deleter (if pop)
2448624588 {
2448724589
2448824590 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24490,7 +24592,7 @@
2449024592 newstack[0] = (uint64_t)stack; // backup stack location
2449124593 newstack[1] = 1234567890;
2449224594 newstack[2] = base;
24493- newstack[3] = 2111LLU;
24595+ newstack[3] = 2123LLU;
2449424596 stack = newstack;
2449524597 // set stack-base & callee-address
2449624598 base = 4/*deloffset*/;
@@ -24497,22 +24599,22 @@
2449724599 label = 399LLU; // ~typeidx
2449824600 break;
2449924601 }
24500- case 2111LLU: // return from ~typeidx to ProcCall
24602+ case 2123LLU: // return from ~typeidx to ProcCall
2450124603 {
2450224604 stack = (uint64_t *)stack[0];
2450324605 // releasing toplevel container
2450424606 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2450524607
24506- label = 2074LLU; // consequent complete
24608+ label = 2086LLU; // consequent complete
2450724609 break;
2450824610 }
24509- case 2079LLU: // alternative
24611+ case 2091LLU: // alternative
2451024612 {
2451124613 fprintf(stderr, "%s", "in function ");
2451224614 // call reportid from ProcCall
24513- stack[base + 39LLU] = 2112LLU/*throw to this address*/;
24615+ stack[base + 39LLU] = 2124LLU/*throw to this address*/;
2451424616 stack[base + 40LLU] = base;
24515- stack[base + 41LLU] = 2113LLU;
24617+ stack[base + 41LLU] = 2125LLU;
2451624618 // arguments for call to reportid
2451724619 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2451824620 // set stack-base & callee-address
@@ -24520,20 +24622,20 @@
2452024622 label = 18446744073709551586LLU; // reportid
2452124623 break;
2452224624 }
24523- case 2112LLU: // copy-back deleter (reportid to ProcCall)
24625+ case 2124LLU: // copy-back deleter (reportid to ProcCall)
2452424626 {
2452524627 // copy mutable arguments back from call to reportid
24526- label = 2074LLU; // continue to roll stack
24628+ label = 2086LLU; // continue to roll stack
2452724629 break;
2452824630 }
24529- case 2113LLU: // return from reportid to ProcCall
24631+ case 2125LLU: // return from reportid to ProcCall
2453024632 {
2453124633 // copy mutable arguments back from call to reportid
2453224634 fprintf(stderr, "%s", " call to ");
2453324635 // call reportid from ProcCall
24534- stack[base + 39LLU] = 2114LLU/*throw to this address*/;
24636+ stack[base + 39LLU] = 2126LLU/*throw to this address*/;
2453524637 stack[base + 40LLU] = base;
24536- stack[base + 41LLU] = 2115LLU;
24638+ stack[base + 41LLU] = 2127LLU;
2453724639 // arguments for call to reportid
2453824640 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2453924641 // set stack-base & callee-address
@@ -24541,20 +24643,20 @@
2454124643 label = 18446744073709551586LLU; // reportid
2454224644 break;
2454324645 }
24544- case 2114LLU: // copy-back deleter (reportid to ProcCall)
24646+ case 2126LLU: // copy-back deleter (reportid to ProcCall)
2454524647 {
2454624648 // copy mutable arguments back from call to reportid
24547- label = 2074LLU; // continue to roll stack
24649+ label = 2086LLU; // continue to roll stack
2454824650 break;
2454924651 }
24550- case 2115LLU: // return from reportid to ProcCall
24652+ case 2127LLU: // return from reportid to ProcCall
2455124653 {
2455224654 // copy mutable arguments back from call to reportid
2455324655 fprintf(stderr, "%s", " at position ");
2455424656 // call reportnr from ProcCall
24555- stack[base + 39LLU] = 2116LLU/*throw to this address*/;
24657+ stack[base + 39LLU] = 2128LLU/*throw to this address*/;
2455624658 stack[base + 40LLU] = base;
24557- stack[base + 41LLU] = 2117LLU;
24659+ stack[base + 41LLU] = 2129LLU;
2455824660 // arguments for call to reportnr
2455924661 stack[base + 42LLU] = stack[base + 32]/*index*/;
2456024662 // set stack-base & callee-address
@@ -24562,54 +24664,54 @@
2456224664 label = 18446744073709551589LLU; // reportnr
2456324665 break;
2456424666 }
24565- case 2116LLU: // copy-back deleter (reportnr to ProcCall)
24667+ case 2128LLU: // copy-back deleter (reportnr to ProcCall)
2456624668 {
2456724669 // copy mutable arguments back from call to reportnr
24568- label = 2074LLU; // continue to roll stack
24670+ label = 2086LLU; // continue to roll stack
2456924671 break;
2457024672 }
24571- case 2117LLU: // return from reportnr to ProcCall
24673+ case 2129LLU: // return from reportnr to ProcCall
2457224674 {
2457324675 // copy mutable arguments back from call to reportnr
2457424676 fprintf(stderr, "%s", " not enough destination-variables for results");
2457524677 fprintf(stderr, "%s", "\n");
2457624678 {
24577- label = 2074LLU; // throw: begin to unroll stack
24679+ label = 2086LLU; // throw: begin to unroll stack
2457824680 break;
2457924681 }
2458024682
24581- label = 2080LLU; // alternative complete
24683+ label = 2092LLU; // alternative complete
2458224684 break;
2458324685 }
24584- case 2080LLU: // completed if-then-else
24686+ case 2092LLU: // completed if-then-else
2458524687 {
2458624688 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24587- label = 2072LLU; // repeat
24689+ label = 2084LLU; // repeat
2458824690 break;
2458924691 }
24590- case 2074LLU: // copy-back deleter for while next
24692+ case 2086LLU: // copy-back deleter for while next
2459124693 {
2459224694 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24593- label = 1795LLU; // continue to unroll stack
24695+ label = 1807LLU; // continue to unroll stack
2459424696 break;
2459524697 }
24596- case 2073LLU: // loop finished
24698+ case 2085LLU: // loop finished
2459724699 {
24598- label = 2069LLU; // consequent complete
24700+ label = 2081LLU; // consequent complete
2459924701 break;
2460024702 }
24601- case 2068LLU: // alternative
24703+ case 2080LLU: // alternative
2460224704 {
24603- label = 2069LLU; // alternative complete
24705+ label = 2081LLU; // alternative complete
2460424706 break;
2460524707 }
24606- case 2069LLU: // completed if-then-else
24708+ case 2081LLU: // completed if-then-else
2460724709 {
2460824710 printf("%s", "\n if(stack[");
2460924711 // call printnr from ProcCall
24610- stack[base + 35LLU] = 2118LLU/*throw to this address*/;
24712+ stack[base + 35LLU] = 2130LLU/*throw to this address*/;
2461124713 stack[base + 36LLU] = base;
24612- stack[base + 37LLU] = 2119LLU;
24714+ stack[base + 37LLU] = 2131LLU;
2461324715 // arguments for call to printnr
2461424716 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2461524717 // set stack-base & callee-address
@@ -24617,13 +24719,13 @@
2461724719 label = 18446744073709551590LLU; // printnr
2461824720 break;
2461924721 }
24620- case 2118LLU: // copy-back deleter (printnr to ProcCall)
24722+ case 2130LLU: // copy-back deleter (printnr to ProcCall)
2462124723 {
2462224724 // copy mutable arguments back from call to printnr
24623- label = 1795LLU; // continue to roll stack
24725+ label = 1807LLU; // continue to roll stack
2462424726 break;
2462524727 }
24626- case 2119LLU: // return from printnr to ProcCall
24728+ case 2131LLU: // return from printnr to ProcCall
2462724729 {
2462824730 // copy mutable arguments back from call to printnr
2462924731 printf("%s", "LLU] != 9876543210LLU)");
@@ -24630,9 +24732,9 @@
2463024732 printf("%s", "\n {");
2463124733 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2463224734 // call printid from ProcCall
24633- stack[base + 35LLU] = 2120LLU/*throw to this address*/;
24735+ stack[base + 35LLU] = 2132LLU/*throw to this address*/;
2463424736 stack[base + 36LLU] = base;
24635- stack[base + 37LLU] = 2121LLU;
24737+ stack[base + 37LLU] = 2133LLU;
2463624738 // arguments for call to printid
2463724739 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2463824740 // set stack-base & callee-address
@@ -24640,13 +24742,13 @@
2464024742 label = 18446744073709551587LLU; // printid
2464124743 break;
2464224744 }
24643- case 2120LLU: // copy-back deleter (printid to ProcCall)
24745+ case 2132LLU: // copy-back deleter (printid to ProcCall)
2464424746 {
2464524747 // copy mutable arguments back from call to printid
24646- label = 1795LLU; // continue to roll stack
24748+ label = 1807LLU; // continue to roll stack
2464724749 break;
2464824750 }
24649- case 2121LLU: // return from printid to ProcCall
24751+ case 2133LLU: // return from printid to ProcCall
2465024752 {
2465124753 // copy mutable arguments back from call to printid
2465224754 printf("%s", ")!\\n\");");
@@ -24654,9 +24756,9 @@
2465424756 printf("%s", "\n }");
2465524757 printf("%s", "\n Free(");
2465624758 // call printnr from ProcCall
24657- stack[base + 35LLU] = 2122LLU/*throw to this address*/;
24759+ stack[base + 35LLU] = 2134LLU/*throw to this address*/;
2465824760 stack[base + 36LLU] = base;
24659- stack[base + 37LLU] = 2123LLU;
24761+ stack[base + 37LLU] = 2135LLU;
2466024762 // arguments for call to printnr
2466124763 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2466224764 // set stack-base & callee-address
@@ -24664,26 +24766,26 @@
2466424766 label = 18446744073709551590LLU; // printnr
2466524767 break;
2466624768 }
24667- case 2122LLU: // copy-back deleter (printnr to ProcCall)
24769+ case 2134LLU: // copy-back deleter (printnr to ProcCall)
2466824770 {
2466924771 // copy mutable arguments back from call to printnr
24670- label = 1795LLU; // continue to roll stack
24772+ label = 1807LLU; // continue to roll stack
2467124773 break;
2467224774 }
24673- case 2123LLU: // return from printnr to ProcCall
24775+ case 2135LLU: // return from printnr to ProcCall
2467424776 {
2467524777 // copy mutable arguments back from call to printnr
2467624778 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
2467724779 printf("%s", "\n stack = oldstack;");
24678- label = 1784LLU; // consequent complete
24780+ label = 1796LLU; // consequent complete
2467924781 break;
2468024782 }
24681- case 1783LLU: // alternative
24783+ case 1795LLU: // alternative
2468224784 {
2468324785 // call add from ProcCall
24684- stack[base + 33LLU] = 2124LLU/*throw to this address*/;
24786+ stack[base + 33LLU] = 2136LLU/*throw to this address*/;
2468524787 stack[base + 34LLU] = base;
24686- stack[base + 35LLU] = 2125LLU;
24788+ stack[base + 35LLU] = 2137LLU;
2468724789 // arguments for call to add
2468824790 stack[base + 37LLU] = 1LLU;
2468924791 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -24692,39 +24794,39 @@
2469224794 label = 18446744073709551605LLU; // add
2469324795 break;
2469424796 }
24695- case 2124LLU: // copy-back deleter (add to ProcCall)
24797+ case 2136LLU: // copy-back deleter (add to ProcCall)
2469624798 {
2469724799 // copy mutable arguments back from call to add
24698- label = 1781LLU; // continue to roll stack
24800+ label = 1793LLU; // continue to roll stack
2469924801 break;
2470024802 }
24701- case 2125LLU: // return from add to ProcCall
24803+ case 2137LLU: // return from add to ProcCall
2470224804 {
2470324805 // copy mutable arguments back from call to add
2470424806 // copy back results provided by call to add
2470524807 stack[base + 17] = stack[base + 36LLU];
24706- label = 2127LLU; // skip deleter
24808+ label = 2139LLU; // skip deleter
2470724809 break;
2470824810 }
24709- case 2126LLU: // deleter
24811+ case 2138LLU: // deleter
2471024812 {
2471124813 // throw from ProcCall
2471224814 if(!stack[base + 33])
2471324815 {
24714- label = 1781LLU; // skip, variable already deleted/unscoped
24816+ label = 1793LLU; // skip, variable already deleted/unscoped
2471524817 break;
2471624818 }
24717- label = 1781LLU; // continue unrolling stack, delete next variable
24819+ label = 1793LLU; // continue unrolling stack, delete next variable
2471824820 break;
2471924821 }
24720- case 2127LLU: // skipped deleter
24822+ case 2139LLU: // skipped deleter
2472124823 {
2472224824 stack[base + 33] = stack[base + 17]/*label*/;
2472324825 printf("%s", "\n // call ");
2472424826 // call printid from ProcCall
24725- stack[base + 34LLU] = 2128LLU/*throw to this address*/;
24827+ stack[base + 34LLU] = 2140LLU/*throw to this address*/;
2472624828 stack[base + 35LLU] = base;
24727- stack[base + 36LLU] = 2129LLU;
24829+ stack[base + 36LLU] = 2141LLU;
2472824830 // arguments for call to printid
2472924831 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2473024832 // set stack-base & callee-address
@@ -24732,20 +24834,20 @@
2473224834 label = 18446744073709551587LLU; // printid
2473324835 break;
2473424836 }
24735- case 2128LLU: // copy-back deleter (printid to ProcCall)
24837+ case 2140LLU: // copy-back deleter (printid to ProcCall)
2473624838 {
2473724839 // copy mutable arguments back from call to printid
24738- label = 2126LLU; // continue to roll stack
24840+ label = 2138LLU; // continue to roll stack
2473924841 break;
2474024842 }
24741- case 2129LLU: // return from printid to ProcCall
24843+ case 2141LLU: // return from printid to ProcCall
2474224844 {
2474324845 // copy mutable arguments back from call to printid
2474424846 printf("%s", " from ");
2474524847 // call printid from ProcCall
24746- stack[base + 34LLU] = 2130LLU/*throw to this address*/;
24848+ stack[base + 34LLU] = 2142LLU/*throw to this address*/;
2474724849 stack[base + 35LLU] = base;
24748- stack[base + 36LLU] = 2131LLU;
24850+ stack[base + 36LLU] = 2143LLU;
2474924851 // arguments for call to printid
2475024852 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2475124853 // set stack-base & callee-address
@@ -24753,20 +24855,20 @@
2475324855 label = 18446744073709551587LLU; // printid
2475424856 break;
2475524857 }
24756- case 2130LLU: // copy-back deleter (printid to ProcCall)
24858+ case 2142LLU: // copy-back deleter (printid to ProcCall)
2475724859 {
2475824860 // copy mutable arguments back from call to printid
24759- label = 2126LLU; // continue to roll stack
24861+ label = 2138LLU; // continue to roll stack
2476024862 break;
2476124863 }
24762- case 2131LLU: // return from printid to ProcCall
24864+ case 2143LLU: // return from printid to ProcCall
2476324865 {
2476424866 // copy mutable arguments back from call to printid
2476524867 stack[base + 30]/*sum*/ = 0;
2476624868 // call add from ProcCall
24767- stack[base + 34LLU] = 2132LLU/*throw to this address*/;
24869+ stack[base + 34LLU] = 2144LLU/*throw to this address*/;
2476824870 stack[base + 35LLU] = base;
24769- stack[base + 36LLU] = 2133LLU;
24871+ stack[base + 36LLU] = 2145LLU;
2477024872 // arguments for call to add
2477124873 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2477224874 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -24775,21 +24877,21 @@
2477524877 label = 18446744073709551605LLU; // add
2477624878 break;
2477724879 }
24778- case 2132LLU: // copy-back deleter (add to ProcCall)
24880+ case 2144LLU: // copy-back deleter (add to ProcCall)
2477924881 {
2478024882 // copy mutable arguments back from call to add
24781- label = 2126LLU; // continue to roll stack
24883+ label = 2138LLU; // continue to roll stack
2478224884 break;
2478324885 }
24784- case 2133LLU: // return from add to ProcCall
24886+ case 2145LLU: // return from add to ProcCall
2478524887 {
2478624888 // copy mutable arguments back from call to add
2478724889 // copy back results provided by call to add
2478824890 stack[base + 30] = stack[base + 37LLU];
2478924891 // call add from ProcCall
24790- stack[base + 34LLU] = 2134LLU/*throw to this address*/;
24892+ stack[base + 34LLU] = 2146LLU/*throw to this address*/;
2479124893 stack[base + 35LLU] = base;
24792- stack[base + 36LLU] = 2135LLU;
24894+ stack[base + 36LLU] = 2147LLU;
2479324895 // arguments for call to add
2479424896 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;