• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1212 (tree)
Time2021-03-29 06:38:04
Authorjakobthomsen

Log Message

reserve keywords

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1211)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1212)
@@ -17714,7 +17714,7 @@
1771417714 {
1771517715 //#define res0 0
1771617716 //#define arg0 1
17717- if(548522061983645696 != stack[base + 1]/*id*/)
17717+ if(512981598149279744 != stack[base + 1]/*id*/)
1771817718 {
1771917719 label = 1504LLU; // jump to alternative
1772017720 break;
@@ -17748,7 +17748,7 @@
1774817748 }
1774917749 case 1504LLU: // try next case
1775017750 {
17751- if(712900230996426752 != stack[base + 1]/*id*/)
17751+ if(548522061983645696 != stack[base + 1]/*id*/)
1775217752 {
1775317753 label = 1508LLU; // jump to alternative
1775417754 break;
@@ -17782,7 +17782,7 @@
1778217782 }
1778317783 case 1508LLU: // try next case
1778417784 {
17785- if(787446707498516480 != stack[base + 1]/*id*/)
17785+ if(587642785557905408 != stack[base + 1]/*id*/)
1778617786 {
1778717787 label = 1512LLU; // jump to alternative
1778817788 break;
@@ -17816,7 +17816,7 @@
1781617816 }
1781717817 case 1512LLU: // try next case
1781817818 {
17819- if(788334650111033344 != stack[base + 1]/*id*/)
17819+ if(657807020572803072 != stack[base + 1]/*id*/)
1782017820 {
1782117821 label = 1516LLU; // jump to alternative
1782217822 break;
@@ -17850,7 +17850,7 @@
1785017850 }
1785117851 case 1516LLU: // try next case
1785217852 {
17853- if(819847183506341888 != stack[base + 1]/*id*/)
17853+ if(712900230996426752 != stack[base + 1]/*id*/)
1785417854 {
1785517855 label = 1520LLU; // jump to alternative
1785617856 break;
@@ -17884,7 +17884,7 @@
1788417884 }
1788517885 case 1520LLU: // try next case
1788617886 {
17887- if(819872884582252544 != stack[base + 1]/*id*/)
17887+ if(787446707498516480 != stack[base + 1]/*id*/)
1788817888 {
1788917889 label = 1524LLU; // jump to alternative
1789017890 break;
@@ -17918,7 +17918,7 @@
1791817918 }
1791917919 case 1524LLU: // try next case
1792017920 {
17921- if(856729206128640000 != stack[base + 1]/*id*/)
17921+ if(788334650111033344 != 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(859571802316210176 != stack[base + 1]/*id*/)
17955+ if(819847183506341888 != 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(842862180511514624 != stack[base + 1]/*id*/)
17989+ if(819865187908583424 != stack[base + 1]/*id*/)
1799017990 {
1799117991 label = 1536LLU; // jump to alternative
1799217992 break;
@@ -18020,11 +18020,147 @@
1802018020 }
1802118021 case 1536LLU: // try next case
1802218022 {
18023+ if(819872884582252544 != stack[base + 1]/*id*/)
18024+ {
18025+ label = 1540LLU; // jump to alternative
18026+ break;
18027+ }
18028+
18029+ // case
18030+ label = 1543LLU; // skip deleter
18031+ break;
18032+ }
18033+ case 1542LLU: // deleter
18034+ {
18035+ // throw from reservedfn
18036+ if(!stack[base + 0])
18037+ {
18038+ label = 1541LLU; // skip, variable already deleted/unscoped
18039+ break;
18040+ }
18041+ label = 1541LLU; // continue unrolling stack, delete next variable
18042+ break;
18043+ }
18044+ case 1543LLU: // skipped deleter
18045+ {
18046+ stack[base + 0] = 1;
18047+ label = 1503LLU; // case complete
18048+ break;
18049+ }
18050+ case 1541LLU: // copy-back deleter (switch)
18051+ {
18052+ label = 1502LLU; // continue to unroll stack
18053+ break;
18054+ }
18055+ case 1540LLU: // try next case
18056+ {
18057+ if(856729206128640000 != stack[base + 1]/*id*/)
18058+ {
18059+ label = 1544LLU; // jump to alternative
18060+ break;
18061+ }
18062+
18063+ // case
18064+ label = 1547LLU; // skip deleter
18065+ break;
18066+ }
18067+ case 1546LLU: // deleter
18068+ {
18069+ // throw from reservedfn
18070+ if(!stack[base + 0])
18071+ {
18072+ label = 1545LLU; // skip, variable already deleted/unscoped
18073+ break;
18074+ }
18075+ label = 1545LLU; // continue unrolling stack, delete next variable
18076+ break;
18077+ }
18078+ case 1547LLU: // skipped deleter
18079+ {
18080+ stack[base + 0] = 1;
18081+ label = 1503LLU; // case complete
18082+ break;
18083+ }
18084+ case 1545LLU: // copy-back deleter (switch)
18085+ {
18086+ label = 1502LLU; // continue to unroll stack
18087+ break;
18088+ }
18089+ case 1544LLU: // try next case
18090+ {
18091+ if(859571802316210176 != stack[base + 1]/*id*/)
18092+ {
18093+ label = 1548LLU; // jump to alternative
18094+ break;
18095+ }
18096+
18097+ // case
18098+ label = 1551LLU; // skip deleter
18099+ break;
18100+ }
18101+ case 1550LLU: // deleter
18102+ {
18103+ // throw from reservedfn
18104+ if(!stack[base + 0])
18105+ {
18106+ label = 1549LLU; // skip, variable already deleted/unscoped
18107+ break;
18108+ }
18109+ label = 1549LLU; // continue unrolling stack, delete next variable
18110+ break;
18111+ }
18112+ case 1551LLU: // skipped deleter
18113+ {
18114+ stack[base + 0] = 1;
18115+ label = 1503LLU; // case complete
18116+ break;
18117+ }
18118+ case 1549LLU: // copy-back deleter (switch)
18119+ {
18120+ label = 1502LLU; // continue to unroll stack
18121+ break;
18122+ }
18123+ case 1548LLU: // try next case
18124+ {
18125+ if(842862180511514624 != stack[base + 1]/*id*/)
18126+ {
18127+ label = 1552LLU; // jump to alternative
18128+ break;
18129+ }
18130+
18131+ // case
18132+ label = 1555LLU; // skip deleter
18133+ break;
18134+ }
18135+ case 1554LLU: // deleter
18136+ {
18137+ // throw from reservedfn
18138+ if(!stack[base + 0])
18139+ {
18140+ label = 1553LLU; // skip, variable already deleted/unscoped
18141+ break;
18142+ }
18143+ label = 1553LLU; // continue unrolling stack, delete next variable
18144+ break;
18145+ }
18146+ case 1555LLU: // skipped deleter
18147+ {
18148+ stack[base + 0] = 1;
18149+ label = 1503LLU; // case complete
18150+ break;
18151+ }
18152+ case 1553LLU: // copy-back deleter (switch)
18153+ {
18154+ label = 1502LLU; // continue to unroll stack
18155+ break;
18156+ }
18157+ case 1552LLU: // try next case
18158+ {
1802318159 // default
18024- label = 1541LLU; // skip deleter
18160+ label = 1557LLU; // skip deleter
1802518161 break;
1802618162 }
18027- case 1540LLU: // deleter
18163+ case 1556LLU: // deleter
1802818164 {
1802918165 // throw from reservedfn
1803018166 if(!stack[base + 0])
@@ -18035,7 +18171,7 @@
1803518171 label = 1502LLU; // continue unrolling stack, delete next variable
1803618172 break;
1803718173 }
18038- case 1541LLU: // skipped deleter
18174+ case 1557LLU: // skipped deleter
1803918175 {
1804018176 stack[base + 0] = 0;
1804118177 label = 1503LLU; // default complete
@@ -18048,38 +18184,38 @@
1804818184 base = stack[base - 2];
1804918185 break;
1805018186 }
18051- case 1543LLU: // function FindFn failed
18187+ case 1559LLU: // function FindFn failed
1805218188 {
1805318189 label = stack[base - 3];
1805418190 base = stack[base - 2];
1805518191 break;
1805618192 }
18057- case 1542LLU: // FindFn
18193+ case 1558LLU: // FindFn
1805818194 {
1805918195 //#define res0 0
1806018196 //#define arg0 1
1806118197 //#define arg1 2
1806218198 //#define arg2 3
18063- label = 1545LLU; // skip deleter
18199+ label = 1561LLU; // skip deleter
1806418200 break;
1806518201 }
18066- case 1544LLU: // deleter
18202+ case 1560LLU: // deleter
1806718203 {
1806818204 // throw from FindFn
1806918205 if(!stack[base + 4])
1807018206 {
18071- label = 1543LLU; // skip, variable already deleted/unscoped
18207+ label = 1559LLU; // skip, variable already deleted/unscoped
1807218208 break;
1807318209 }
18074- label = 1543LLU; // continue unrolling stack, delete next variable
18210+ label = 1559LLU; // continue unrolling stack, delete next variable
1807518211 break;
1807618212 }
18077- case 1545LLU: // skipped deleter
18213+ case 1561LLU: // skipped deleter
1807818214 {
1807918215 // call reservedfn from FindFn
18080- stack[base + 5LLU] = 1546LLU/*throw to this address*/;
18216+ stack[base + 5LLU] = 1562LLU/*throw to this address*/;
1808118217 stack[base + 6LLU] = base;
18082- stack[base + 7LLU] = 1547LLU;
18218+ stack[base + 7LLU] = 1563LLU;
1808318219 // arguments for call to reservedfn
1808418220 stack[base + 9LLU] = stack[base + 3]/*id*/;
1808518221 // set stack-base & callee-address
@@ -18087,13 +18223,13 @@
1808718223 label = 1501LLU; // reservedfn
1808818224 break;
1808918225 }
18090- case 1546LLU: // copy-back deleter (reservedfn to FindFn)
18226+ case 1562LLU: // copy-back deleter (reservedfn to FindFn)
1809118227 {
1809218228 // copy mutable arguments back from call to reservedfn
18093- label = 1543LLU; // continue to roll stack
18229+ label = 1559LLU; // continue to roll stack
1809418230 break;
1809518231 }
18096- case 1547LLU: // return from reservedfn to FindFn
18232+ case 1563LLU: // return from reservedfn to FindFn
1809718233 {
1809818234 // copy mutable arguments back from call to reservedfn
1809918235 // copy back results provided by call to reservedfn
@@ -18100,7 +18236,7 @@
1810018236 stack[base + 4] = stack[base + 8LLU];
1810118237 if(!stack[base + 4]/*found*/)
1810218238 {
18103- label = 1548LLU; // jump to alternative
18239+ label = 1564LLU; // jump to alternative
1810418240 break;
1810518241 }
1810618242
@@ -18107,9 +18243,9 @@
1810718243 // consequent
1810818244 fprintf(stderr, "%s", "in function ");
1810918245 // call reportid from FindFn
18110- stack[base + 5LLU] = 1550LLU/*throw to this address*/;
18246+ stack[base + 5LLU] = 1566LLU/*throw to this address*/;
1811118247 stack[base + 6LLU] = base;
18112- stack[base + 7LLU] = 1551LLU;
18248+ stack[base + 7LLU] = 1567LLU;
1811318249 // arguments for call to reportid
1811418250 stack[base + 8LLU] = stack[base + 1]/*fnid*/;
1811518251 // set stack-base & callee-address
@@ -18117,21 +18253,21 @@
1811718253 label = 18446744073709551586LLU; // reportid
1811818254 break;
1811918255 }
18120- case 1550LLU: // copy-back deleter (reportid to FindFn)
18256+ case 1566LLU: // copy-back deleter (reportid to FindFn)
1812118257 {
1812218258 // copy mutable arguments back from call to reportid
18123- label = 1544LLU; // continue to roll stack
18259+ label = 1560LLU; // continue to roll stack
1812418260 break;
1812518261 }
18126- case 1551LLU: // return from reportid to FindFn
18262+ case 1567LLU: // return from reportid to FindFn
1812718263 {
1812818264 // copy mutable arguments back from call to reportid
1812918265 fprintf(stderr, "%s", ": ");
1813018266 fprintf(stderr, "%s", "reserved function ");
1813118267 // call reportid from FindFn
18132- stack[base + 5LLU] = 1552LLU/*throw to this address*/;
18268+ stack[base + 5LLU] = 1568LLU/*throw to this address*/;
1813318269 stack[base + 6LLU] = base;
18134- stack[base + 7LLU] = 1553LLU;
18270+ stack[base + 7LLU] = 1569LLU;
1813518271 // arguments for call to reportid
1813618272 stack[base + 8LLU] = stack[base + 3]/*id*/;
1813718273 // set stack-base & callee-address
@@ -18139,40 +18275,40 @@
1813918275 label = 18446744073709551586LLU; // reportid
1814018276 break;
1814118277 }
18142- case 1552LLU: // copy-back deleter (reportid to FindFn)
18278+ case 1568LLU: // copy-back deleter (reportid to FindFn)
1814318279 {
1814418280 // copy mutable arguments back from call to reportid
18145- label = 1544LLU; // continue to roll stack
18281+ label = 1560LLU; // continue to roll stack
1814618282 break;
1814718283 }
18148- case 1553LLU: // return from reportid to FindFn
18284+ case 1569LLU: // return from reportid to FindFn
1814918285 {
1815018286 // copy mutable arguments back from call to reportid
1815118287 fprintf(stderr, "%s", " not called properly - check result-types & parameter-types\n");
1815218288 {
18153- label = 1544LLU; // throw: begin to unroll stack
18289+ label = 1560LLU; // throw: begin to unroll stack
1815418290 break;
1815518291 }
1815618292
18157- label = 1549LLU; // consequent complete
18293+ label = 1565LLU; // consequent complete
1815818294 break;
1815918295 }
18160- case 1548LLU: // alternative
18296+ case 1564LLU: // alternative
1816118297 {
18162- label = 1549LLU; // alternative complete
18298+ label = 1565LLU; // alternative complete
1816318299 break;
1816418300 }
18165- case 1549LLU: // completed if-then-else
18301+ case 1565LLU: // completed if-then-else
1816618302 {
18167- label = 1555LLU; // skip deleter
18303+ label = 1571LLU; // skip deleter
1816818304 break;
1816918305 }
18170- case 1554LLU: // deleter
18306+ case 1570LLU: // deleter
1817118307 {
1817218308 // throw from FindFn
1817318309 if(!stack[base + 5])
1817418310 {
18175- label = 1544LLU; // skip, variable already deleted/unscoped
18311+ label = 1560LLU; // skip, variable already deleted/unscoped
1817618312 break;
1817718313 }
1817818314
@@ -18181,7 +18317,7 @@
1818118317 newstack[0] = (uint64_t)stack; // backup stack location
1818218318 newstack[1] = 1234567890;
1818318319 newstack[2] = base;
18184- newstack[3] = 1556LLU;
18320+ newstack[3] = 1572LLU;
1818518321 stack = newstack;
1818618322 // set stack-base & callee-address
1818718323 base = 4/*deloffset*/;
@@ -18188,21 +18324,21 @@
1818818324 label = 1420LLU; // ~fndef
1818918325 break;
1819018326 }
18191- case 1556LLU: // return from ~fndef to FindFn
18327+ case 1572LLU: // return from ~fndef to FindFn
1819218328 {
1819318329 stack = (uint64_t *)stack[0];
1819418330 // releasing toplevel container
1819518331 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4));
1819618332
18197- label = 1544LLU; // continue unrolling stack, delete next variable
18333+ label = 1560LLU; // continue unrolling stack, delete next variable
1819818334 break;
1819918335 }
18200- case 1555LLU: // skipped deleter
18336+ case 1571LLU: // skipped deleter
1820118337 {
1820218338 // call mkfndummy from FindFn
18203- stack[base + 6LLU] = 1557LLU/*throw to this address*/;
18339+ stack[base + 6LLU] = 1573LLU/*throw to this address*/;
1820418340 stack[base + 7LLU] = base;
18205- stack[base + 8LLU] = 1558LLU;
18341+ stack[base + 8LLU] = 1574LLU;
1820618342 // arguments for call to mkfndummy
1820718343 // set stack-base & callee-address
1820818344 base += 9LLU;
@@ -18209,26 +18345,26 @@
1820918345 label = 1428LLU; // mkfndummy
1821018346 break;
1821118347 }
18212- case 1557LLU: // copy-back deleter (mkfndummy to FindFn)
18348+ case 1573LLU: // copy-back deleter (mkfndummy to FindFn)
1821318349 {
1821418350 // copy mutable arguments back from call to mkfndummy
18215- label = 1544LLU; // continue to roll stack
18351+ label = 1560LLU; // continue to roll stack
1821618352 break;
1821718353 }
18218- case 1558LLU: // return from mkfndummy to FindFn
18354+ case 1574LLU: // return from mkfndummy to FindFn
1821918355 {
1822018356 // copy mutable arguments back from call to mkfndummy
1822118357 // copy back results provided by call to mkfndummy
1822218358 stack[base + 5] = stack[base + 9LLU];
1822318359 flippedassign(stack[base + 2]/*fndefs*/, &stack[base + 6]);
18224- label = 1559LLU; // start to repeat
18360+ label = 1575LLU; // start to repeat
1822518361 break;
1822618362 }
18227- case 1559LLU: // repeat from here
18363+ case 1575LLU: // repeat from here
1822818364 {
1822918365 if(!stack[base + 6])
1823018366 {
18231- label = 1560LLU; // break loop
18367+ label = 1576LLU; // break loop
1823218368 break;
1823318369 }
1823418370
@@ -18238,19 +18374,19 @@
1823818374 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
1823918375 if(!stack[base + 4]/*found*/)
1824018376 {
18241- label = 1562LLU; // jump to alternative
18377+ label = 1578LLU; // jump to alternative
1824218378 break;
1824318379 }
1824418380
1824518381 // consequent
18246- label = 1563LLU; // consequent complete
18382+ label = 1579LLU; // consequent complete
1824718383 break;
1824818384 }
18249- case 1562LLU: // alternative
18385+ case 1578LLU: // alternative
1825018386 {
1825118387 if(/*fndef*/0 != ((uint64_t *)(stack[base + 7]/*fndef*/))[0])
1825218388 {
18253- label = 1565LLU; // jump to alternative
18389+ label = 1581LLU; // jump to alternative
1825418390 break;
1825518391 }
1825618392
@@ -18264,27 +18400,27 @@
1826418400 /*IO*/stack[base + 16] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][7]/*IO*/;
1826518401
1826618402 // case
18267- label = 1568LLU; // skip deleter
18403+ label = 1584LLU; // skip deleter
1826818404 break;
1826918405 }
18270- case 1567LLU: // deleter
18406+ case 1583LLU: // deleter
1827118407 {
1827218408 // throw from FindFn
1827318409 if(!stack[base + 17])
1827418410 {
18275- label = 1566LLU; // skip, variable already deleted/unscoped
18411+ label = 1582LLU; // skip, variable already deleted/unscoped
1827618412 break;
1827718413 }
18278- label = 1566LLU; // continue unrolling stack, delete next variable
18414+ label = 1582LLU; // continue unrolling stack, delete next variable
1827918415 break;
1828018416 }
18281- case 1568LLU: // skipped deleter
18417+ case 1584LLU: // skipped deleter
1828218418 {
1828318419 stack[base + 17] = 0;
1828418420 // call equ from FindFn
18285- stack[base + 18LLU] = 1569LLU/*throw to this address*/;
18421+ stack[base + 18LLU] = 1585LLU/*throw to this address*/;
1828618422 stack[base + 19LLU] = base;
18287- stack[base + 20LLU] = 1570LLU;
18423+ stack[base + 20LLU] = 1586LLU;
1828818424 // arguments for call to equ
1828918425 stack[base + 22LLU] = stack[base + 3]/*id*/;
1829018426 stack[base + 23LLU] = stack[base + 13]/*defid*/;
@@ -18293,13 +18429,13 @@
1829318429 label = 18446744073709551600LLU; // equ
1829418430 break;
1829518431 }
18296- case 1569LLU: // copy-back deleter (equ to FindFn)
18432+ case 1585LLU: // copy-back deleter (equ to FindFn)
1829718433 {
1829818434 // copy mutable arguments back from call to equ
18299- label = 1567LLU; // continue to roll stack
18435+ label = 1583LLU; // continue to roll stack
1830018436 break;
1830118437 }
18302- case 1570LLU: // return from equ to FindFn
18438+ case 1586LLU: // return from equ to FindFn
1830318439 {
1830418440 // copy mutable arguments back from call to equ
1830518441 // copy back results provided by call to equ
@@ -18306,20 +18442,20 @@
1830618442 stack[base + 17] = stack[base + 21LLU];
1830718443 if(!stack[base + 17]/*isequal*/)
1830818444 {
18309- label = 1571LLU; // jump to alternative
18445+ label = 1587LLU; // jump to alternative
1831018446 break;
1831118447 }
1831218448
1831318449 // consequent
18314- label = 1574LLU; // skip deleter
18450+ label = 1590LLU; // skip deleter
1831518451 break;
1831618452 }
18317- case 1573LLU: // deleter
18453+ case 1589LLU: // deleter
1831818454 {
1831918455 // throw from FindFn
1832018456 if(!stack[base + 18])
1832118457 {
18322- label = 1567LLU; // skip, variable already deleted/unscoped
18458+ label = 1583LLU; // skip, variable already deleted/unscoped
1832318459 break;
1832418460 }
1832518461
@@ -18328,7 +18464,7 @@
1832818464 newstack[0] = (uint64_t)stack; // backup stack location
1832918465 newstack[1] = 1234567890;
1833018466 newstack[2] = base;
18331- newstack[3] = 1575LLU;
18467+ newstack[3] = 1591LLU;
1833218468 stack = newstack;
1833318469 // set stack-base & callee-address
1833418470 base = 4/*deloffset*/;
@@ -18335,21 +18471,21 @@
1833518471 label = 1420LLU; // ~fndef
1833618472 break;
1833718473 }
18338- case 1575LLU: // return from ~fndef to FindFn
18474+ case 1591LLU: // return from ~fndef to FindFn
1833918475 {
1834018476 stack = (uint64_t *)stack[0];
1834118477 // releasing toplevel container
1834218478 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1834318479
18344- label = 1567LLU; // continue unrolling stack, delete next variable
18480+ label = 1583LLU; // continue unrolling stack, delete next variable
1834518481 break;
1834618482 }
18347- case 1574LLU: // skipped deleter
18483+ case 1590LLU: // skipped deleter
1834818484 {
1834918485 // call copyfndef from FindFn
18350- stack[base + 19LLU] = 1576LLU/*throw to this address*/;
18486+ stack[base + 19LLU] = 1592LLU/*throw to this address*/;
1835118487 stack[base + 20LLU] = base;
18352- stack[base + 21LLU] = 1577LLU;
18488+ stack[base + 21LLU] = 1593LLU;
1835318489 // arguments for call to copyfndef
1835418490 stack[base + 23LLU] = stack[base + 7]/*fndef*/;
1835518491 // set stack-base & callee-address
@@ -18357,13 +18493,13 @@
1835718493 label = 1455LLU; // copyfndef
1835818494 break;
1835918495 }
18360- case 1576LLU: // copy-back deleter (copyfndef to FindFn)
18496+ case 1592LLU: // copy-back deleter (copyfndef to FindFn)
1836118497 {
1836218498 // copy mutable arguments back from call to copyfndef
18363- label = 1567LLU; // continue to roll stack
18499+ label = 1583LLU; // continue to roll stack
1836418500 break;
1836518501 }
18366- case 1577LLU: // return from copyfndef to FindFn
18502+ case 1593LLU: // return from copyfndef to FindFn
1836718503 {
1836818504 // copy mutable arguments back from call to copyfndef
1836918505 // copy back results provided by call to copyfndef
@@ -18376,7 +18512,7 @@
1837618512 newstack[0] = (uint64_t)stack; // backup stack location
1837718513 newstack[1] = 1234567890;
1837818514 newstack[2] = base;
18379- newstack[3] = 1578LLU;
18515+ newstack[3] = 1594LLU;
1838018516 stack = newstack;
1838118517 // set stack-base & callee-address
1838218518 base = 4/*deloffset*/;
@@ -18383,21 +18519,21 @@
1838318519 label = 1420LLU; // ~fndef
1838418520 break;
1838518521 }
18386- case 1578LLU: // return from ~fndef to FindFn
18522+ case 1594LLU: // return from ~fndef to FindFn
1838718523 {
1838818524 stack = (uint64_t *)stack[0];
1838918525 // releasing toplevel container
1839018526 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1839118527
18392- label = 1572LLU; // consequent complete
18528+ label = 1588LLU; // consequent complete
1839318529 break;
1839418530 }
18395- case 1571LLU: // alternative
18531+ case 1587LLU: // alternative
1839618532 {
18397- label = 1572LLU; // alternative complete
18533+ label = 1588LLU; // alternative complete
1839818534 break;
1839918535 }
18400- case 1572LLU: // completed if-then-else
18536+ case 1588LLU: // completed if-then-else
1840118537 {
1840218538 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1840318539 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18407,10 +18543,10 @@
1840718543 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1840818544 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1840918545 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18410- label = 1564LLU; // case complete
18546+ label = 1580LLU; // case complete
1841118547 break;
1841218548 }
18413- case 1566LLU: // copy-back deleter (switch)
18549+ case 1582LLU: // copy-back deleter (switch)
1841418550 {
1841518551 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1841618552 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18420,50 +18556,50 @@
1842018556 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1842118557 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1842218558 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18423- label = 1561LLU; // continue to unroll stack
18559+ label = 1577LLU; // continue to unroll stack
1842418560 break;
1842518561 }
18426- case 1565LLU: // try next case
18562+ case 1581LLU: // try next case
1842718563 {
1842818564 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1842918565 exit(-1);
1843018566 }
18431- case 1564LLU: // completed switch
18567+ case 1580LLU: // completed switch
1843218568 {
18433- label = 1563LLU; // alternative complete
18569+ label = 1579LLU; // alternative complete
1843418570 break;
1843518571 }
18436- case 1563LLU: // completed if-then-else
18572+ case 1579LLU: // completed if-then-else
1843718573 {
1843818574 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18439- label = 1559LLU; // repeat
18575+ label = 1575LLU; // repeat
1844018576 break;
1844118577 }
18442- case 1561LLU: // copy-back deleter for while next
18578+ case 1577LLU: // copy-back deleter for while next
1844318579 {
1844418580 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18445- label = 1554LLU; // continue to unroll stack
18581+ label = 1570LLU; // continue to unroll stack
1844618582 break;
1844718583 }
18448- case 1560LLU: // loop finished
18584+ case 1576LLU: // loop finished
1844918585 {
1845018586 if(!stack[base + 4]/*found*/)
1845118587 {
18452- label = 1579LLU; // jump to alternative
18588+ label = 1595LLU; // jump to alternative
1845318589 break;
1845418590 }
1845518591
1845618592 // consequent
18457- label = 1580LLU; // consequent complete
18593+ label = 1596LLU; // consequent complete
1845818594 break;
1845918595 }
18460- case 1579LLU: // alternative
18596+ case 1595LLU: // alternative
1846118597 {
1846218598 fprintf(stderr, "%s", "in function ");
1846318599 // call reportid from FindFn
18464- stack[base + 9LLU] = 1581LLU/*throw to this address*/;
18600+ stack[base + 9LLU] = 1597LLU/*throw to this address*/;
1846518601 stack[base + 10LLU] = base;
18466- stack[base + 11LLU] = 1582LLU;
18602+ stack[base + 11LLU] = 1598LLU;
1846718603 // arguments for call to reportid
1846818604 stack[base + 12LLU] = stack[base + 1]/*fnid*/;
1846918605 // set stack-base & callee-address
@@ -18471,21 +18607,21 @@
1847118607 label = 18446744073709551586LLU; // reportid
1847218608 break;
1847318609 }
18474- case 1581LLU: // copy-back deleter (reportid to FindFn)
18610+ case 1597LLU: // copy-back deleter (reportid to FindFn)
1847518611 {
1847618612 // copy mutable arguments back from call to reportid
18477- label = 1554LLU; // continue to roll stack
18613+ label = 1570LLU; // continue to roll stack
1847818614 break;
1847918615 }
18480- case 1582LLU: // return from reportid to FindFn
18616+ case 1598LLU: // return from reportid to FindFn
1848118617 {
1848218618 // copy mutable arguments back from call to reportid
1848318619 fprintf(stderr, "%s", ": ");
1848418620 fprintf(stderr, "%s", "function ");
1848518621 // call reportid from FindFn
18486- stack[base + 9LLU] = 1583LLU/*throw to this address*/;
18622+ stack[base + 9LLU] = 1599LLU/*throw to this address*/;
1848718623 stack[base + 10LLU] = base;
18488- stack[base + 11LLU] = 1584LLU;
18624+ stack[base + 11LLU] = 1600LLU;
1848918625 // arguments for call to reportid
1849018626 stack[base + 12LLU] = stack[base + 3]/*id*/;
1849118627 // set stack-base & callee-address
@@ -18493,35 +18629,35 @@
1849318629 label = 18446744073709551586LLU; // reportid
1849418630 break;
1849518631 }
18496- case 1583LLU: // copy-back deleter (reportid to FindFn)
18632+ case 1599LLU: // copy-back deleter (reportid to FindFn)
1849718633 {
1849818634 // copy mutable arguments back from call to reportid
18499- label = 1554LLU; // continue to roll stack
18635+ label = 1570LLU; // continue to roll stack
1850018636 break;
1850118637 }
18502- case 1584LLU: // return from reportid to FindFn
18638+ case 1600LLU: // return from reportid to FindFn
1850318639 {
1850418640 // copy mutable arguments back from call to reportid
1850518641 fprintf(stderr, "%s", " not defined\n");
1850618642 {
18507- label = 1554LLU; // throw: begin to unroll stack
18643+ label = 1570LLU; // throw: begin to unroll stack
1850818644 break;
1850918645 }
1851018646
18511- label = 1580LLU; // alternative complete
18647+ label = 1596LLU; // alternative complete
1851218648 break;
1851318649 }
18514- case 1580LLU: // completed if-then-else
18650+ case 1596LLU: // completed if-then-else
1851518651 {
18516- label = 1586LLU; // skip deleter
18652+ label = 1602LLU; // skip deleter
1851718653 break;
1851818654 }
18519- case 1585LLU: // deleter
18655+ case 1601LLU: // deleter
1852018656 {
1852118657 // throw from FindFn
1852218658 if(!stack[base + 0])
1852318659 {
18524- label = 1554LLU; // skip, variable already deleted/unscoped
18660+ label = 1570LLU; // skip, variable already deleted/unscoped
1852518661 break;
1852618662 }
1852718663
@@ -18530,7 +18666,7 @@
1853018666 newstack[0] = (uint64_t)stack; // backup stack location
1853118667 newstack[1] = 1234567890;
1853218668 newstack[2] = base;
18533- newstack[3] = 1587LLU;
18669+ newstack[3] = 1603LLU;
1853418670 stack = newstack;
1853518671 // set stack-base & callee-address
1853618672 base = 4/*deloffset*/;
@@ -18537,16 +18673,16 @@
1853718673 label = 1420LLU; // ~fndef
1853818674 break;
1853918675 }
18540- case 1587LLU: // return from ~fndef to FindFn
18676+ case 1603LLU: // return from ~fndef to FindFn
1854118677 {
1854218678 stack = (uint64_t *)stack[0];
1854318679 // releasing toplevel container
1854418680 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1854518681
18546- label = 1554LLU; // continue unrolling stack, delete next variable
18682+ label = 1570LLU; // continue unrolling stack, delete next variable
1854718683 break;
1854818684 }
18549- case 1586LLU: // skipped deleter
18685+ case 1602LLU: // skipped deleter
1855018686 {
1855118687 INIT(&stack[base + 0], &stack[base + 5]/*copy*/);
1855218688 // return from FindFn
@@ -18554,37 +18690,37 @@
1855418690 base = stack[base - 2];
1855518691 break;
1855618692 }
18557- case 1589LLU: // function existsfn failed
18693+ case 1605LLU: // function existsfn failed
1855818694 {
1855918695 label = stack[base - 3];
1856018696 base = stack[base - 2];
1856118697 break;
1856218698 }
18563- case 1588LLU: // existsfn
18699+ case 1604LLU: // existsfn
1856418700 {
1856518701 //#define res0 0
1856618702 //#define arg0 1
1856718703 //#define arg1 2
18568- label = 1591LLU; // skip deleter
18704+ label = 1607LLU; // skip deleter
1856918705 break;
1857018706 }
18571- case 1590LLU: // deleter
18707+ case 1606LLU: // deleter
1857218708 {
1857318709 // throw from existsfn
1857418710 if(!stack[base + 3])
1857518711 {
18576- label = 1589LLU; // skip, variable already deleted/unscoped
18712+ label = 1605LLU; // skip, variable already deleted/unscoped
1857718713 break;
1857818714 }
18579- label = 1589LLU; // continue unrolling stack, delete next variable
18715+ label = 1605LLU; // continue unrolling stack, delete next variable
1858018716 break;
1858118717 }
18582- case 1591LLU: // skipped deleter
18718+ case 1607LLU: // skipped deleter
1858318719 {
1858418720 // call reservedfn from existsfn
18585- stack[base + 4LLU] = 1592LLU/*throw to this address*/;
18721+ stack[base + 4LLU] = 1608LLU/*throw to this address*/;
1858618722 stack[base + 5LLU] = base;
18587- stack[base + 6LLU] = 1593LLU;
18723+ stack[base + 6LLU] = 1609LLU;
1858818724 // arguments for call to reservedfn
1858918725 stack[base + 8LLU] = stack[base + 2]/*id*/;
1859018726 // set stack-base & callee-address
@@ -18592,26 +18728,26 @@
1859218728 label = 1501LLU; // reservedfn
1859318729 break;
1859418730 }
18595- case 1592LLU: // copy-back deleter (reservedfn to existsfn)
18731+ case 1608LLU: // copy-back deleter (reservedfn to existsfn)
1859618732 {
1859718733 // copy mutable arguments back from call to reservedfn
18598- label = 1589LLU; // continue to roll stack
18734+ label = 1605LLU; // continue to roll stack
1859918735 break;
1860018736 }
18601- case 1593LLU: // return from reservedfn to existsfn
18737+ case 1609LLU: // return from reservedfn to existsfn
1860218738 {
1860318739 // copy mutable arguments back from call to reservedfn
1860418740 // copy back results provided by call to reservedfn
1860518741 stack[base + 3] = stack[base + 7LLU];
1860618742 flippedassign(stack[base + 1]/*fndefs*/, &stack[base + 4]);
18607- label = 1594LLU; // start to repeat
18743+ label = 1610LLU; // start to repeat
1860818744 break;
1860918745 }
18610- case 1594LLU: // repeat from here
18746+ case 1610LLU: // repeat from here
1861118747 {
1861218748 if(!stack[base + 4])
1861318749 {
18614- label = 1595LLU; // break loop
18750+ label = 1611LLU; // break loop
1861518751 break;
1861618752 }
1861718753
@@ -18621,19 +18757,19 @@
1862118757 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1862218758 if(!stack[base + 3]/*found*/)
1862318759 {
18624- label = 1597LLU; // jump to alternative
18760+ label = 1613LLU; // jump to alternative
1862518761 break;
1862618762 }
1862718763
1862818764 // consequent
18629- label = 1598LLU; // consequent complete
18765+ label = 1614LLU; // consequent complete
1863018766 break;
1863118767 }
18632- case 1597LLU: // alternative
18768+ case 1613LLU: // alternative
1863318769 {
1863418770 if(/*fndef*/0 != ((uint64_t *)(stack[base + 5]/*fndef*/))[0])
1863518771 {
18636- label = 1600LLU; // jump to alternative
18772+ label = 1616LLU; // jump to alternative
1863718773 break;
1863818774 }
1863918775
@@ -18647,27 +18783,27 @@
1864718783 /*IO*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][7]/*IO*/;
1864818784
1864918785 // case
18650- label = 1603LLU; // skip deleter
18786+ label = 1619LLU; // skip deleter
1865118787 break;
1865218788 }
18653- case 1602LLU: // deleter
18789+ case 1618LLU: // deleter
1865418790 {
1865518791 // throw from existsfn
1865618792 if(!stack[base + 15])
1865718793 {
18658- label = 1601LLU; // skip, variable already deleted/unscoped
18794+ label = 1617LLU; // skip, variable already deleted/unscoped
1865918795 break;
1866018796 }
18661- label = 1601LLU; // continue unrolling stack, delete next variable
18797+ label = 1617LLU; // continue unrolling stack, delete next variable
1866218798 break;
1866318799 }
18664- case 1603LLU: // skipped deleter
18800+ case 1619LLU: // skipped deleter
1866518801 {
1866618802 stack[base + 15] = 0;
1866718803 // call equ from existsfn
18668- stack[base + 16LLU] = 1604LLU/*throw to this address*/;
18804+ stack[base + 16LLU] = 1620LLU/*throw to this address*/;
1866918805 stack[base + 17LLU] = base;
18670- stack[base + 18LLU] = 1605LLU;
18806+ stack[base + 18LLU] = 1621LLU;
1867118807 // arguments for call to equ
1867218808 stack[base + 20LLU] = stack[base + 2]/*id*/;
1867318809 stack[base + 21LLU] = stack[base + 11]/*defid*/;
@@ -18676,13 +18812,13 @@
1867618812 label = 18446744073709551600LLU; // equ
1867718813 break;
1867818814 }
18679- case 1604LLU: // copy-back deleter (equ to existsfn)
18815+ case 1620LLU: // copy-back deleter (equ to existsfn)
1868018816 {
1868118817 // copy mutable arguments back from call to equ
18682- label = 1602LLU; // continue to roll stack
18818+ label = 1618LLU; // continue to roll stack
1868318819 break;
1868418820 }
18685- case 1605LLU: // return from equ to existsfn
18821+ case 1621LLU: // return from equ to existsfn
1868618822 {
1868718823 // copy mutable arguments back from call to equ
1868818824 // copy back results provided by call to equ
@@ -18689,21 +18825,21 @@
1868918825 stack[base + 15] = stack[base + 19LLU];
1869018826 if(!stack[base + 15]/*isequal*/)
1869118827 {
18692- label = 1606LLU; // jump to alternative
18828+ label = 1622LLU; // jump to alternative
1869318829 break;
1869418830 }
1869518831
1869618832 // consequent
1869718833 stack[base + 3]/*found*/ = 1;
18698- label = 1607LLU; // consequent complete
18834+ label = 1623LLU; // consequent complete
1869918835 break;
1870018836 }
18701- case 1606LLU: // alternative
18837+ case 1622LLU: // alternative
1870218838 {
18703- label = 1607LLU; // alternative complete
18839+ label = 1623LLU; // alternative complete
1870418840 break;
1870518841 }
18706- case 1607LLU: // completed if-then-else
18842+ case 1623LLU: // completed if-then-else
1870718843 {
1870818844 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1870918845 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18713,10 +18849,10 @@
1871318849 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1871418850 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1871518851 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18716- label = 1599LLU; // case complete
18852+ label = 1615LLU; // case complete
1871718853 break;
1871818854 }
18719- case 1601LLU: // copy-back deleter (switch)
18855+ case 1617LLU: // copy-back deleter (switch)
1872018856 {
1872118857 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1872218858 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18726,48 +18862,48 @@
1872618862 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1872718863 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1872818864 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18729- label = 1596LLU; // continue to unroll stack
18865+ label = 1612LLU; // continue to unroll stack
1873018866 break;
1873118867 }
18732- case 1600LLU: // try next case
18868+ case 1616LLU: // try next case
1873318869 {
1873418870 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1873518871 exit(-1);
1873618872 }
18737- case 1599LLU: // completed switch
18873+ case 1615LLU: // completed switch
1873818874 {
18739- label = 1598LLU; // alternative complete
18875+ label = 1614LLU; // alternative complete
1874018876 break;
1874118877 }
18742- case 1598LLU: // completed if-then-else
18878+ case 1614LLU: // completed if-then-else
1874318879 {
1874418880 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18745- label = 1594LLU; // repeat
18881+ label = 1610LLU; // repeat
1874618882 break;
1874718883 }
18748- case 1596LLU: // copy-back deleter for while next
18884+ case 1612LLU: // copy-back deleter for while next
1874918885 {
1875018886 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18751- label = 1590LLU; // continue to unroll stack
18887+ label = 1606LLU; // continue to unroll stack
1875218888 break;
1875318889 }
18754- case 1595LLU: // loop finished
18890+ case 1611LLU: // loop finished
1875518891 {
18756- label = 1609LLU; // skip deleter
18892+ label = 1625LLU; // skip deleter
1875718893 break;
1875818894 }
18759- case 1608LLU: // deleter
18895+ case 1624LLU: // deleter
1876018896 {
1876118897 // throw from existsfn
1876218898 if(!stack[base + 0])
1876318899 {
18764- label = 1590LLU; // skip, variable already deleted/unscoped
18900+ label = 1606LLU; // skip, variable already deleted/unscoped
1876518901 break;
1876618902 }
18767- label = 1590LLU; // continue unrolling stack, delete next variable
18903+ label = 1606LLU; // continue unrolling stack, delete next variable
1876818904 break;
1876918905 }
18770- case 1609LLU: // skipped deleter
18906+ case 1625LLU: // skipped deleter
1877118907 {
1877218908 stack[base + 0] = stack[base + 3]/*found*/;
1877318909 // return from existsfn
@@ -18775,7 +18911,7 @@
1877518911 base = stack[base - 2];
1877618912 break;
1877718913 }
18778- case 1610LLU: // ~idfndef
18914+ case 1626LLU: // ~idfndef
1877918915 {
1878018916 if(stack[base + 0]/*variant-nr*/ >= 1)
1878118917 {
@@ -18782,10 +18918,10 @@
1878218918 fprintf(stderr, "in ~idfndef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1878318919 exit(-1);
1878418920 }
18785- label = 1610LLU + 1LLU + stack[base + 0]/*variant-nr*/;
18921+ label = 1626LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1878618922 break;
1878718923 }
18788- case 1610LLU + 1LLU + 0LLU: // ~idfndef.idfndef
18924+ case 1626LLU + 1LLU + 0LLU: // ~idfndef.idfndef
1878918925 {
1879018926 // release element id
1879118927 // release element fndef
@@ -18796,7 +18932,7 @@
1879618932 newstack[0] = (uint64_t)stack; // backup stack location
1879718933 newstack[1] = 1234567890;
1879818934 newstack[2] = base;
18799- newstack[3] = 1612LLU;
18935+ newstack[3] = 1628LLU;
1880018936 stack = newstack;
1880118937 // set stack-base & callee-address
1880218938 base = 4/*deloffset*/;
@@ -18803,7 +18939,7 @@
1880318939 label = 1420LLU; // ~fndef
1880418940 break;
1880518941 }
18806- case 1612LLU: // return from ~fndef to idfndef
18942+ case 1628LLU: // return from ~fndef to idfndef
1880718943 {
1880818944 stack = (uint64_t *)stack[0];
1880918945 // releasing toplevel container
@@ -18815,43 +18951,43 @@
1881518951 base = stack[base - 2];
1881618952 break;
1881718953 }
18818- case 1614LLU: // function existsidfn failed
18954+ case 1630LLU: // function existsidfn failed
1881918955 {
1882018956 label = stack[base - 3];
1882118957 base = stack[base - 2];
1882218958 break;
1882318959 }
18824- case 1613LLU: // existsidfn
18960+ case 1629LLU: // existsidfn
1882518961 {
1882618962 //#define res0 0
1882718963 //#define arg0 1
1882818964 //#define arg1 2
18829- label = 1616LLU; // skip deleter
18965+ label = 1632LLU; // skip deleter
1883018966 break;
1883118967 }
18832- case 1615LLU: // deleter
18968+ case 1631LLU: // deleter
1883318969 {
1883418970 // throw from existsidfn
1883518971 if(!stack[base + 3])
1883618972 {
18837- label = 1614LLU; // skip, variable already deleted/unscoped
18973+ label = 1630LLU; // skip, variable already deleted/unscoped
1883818974 break;
1883918975 }
18840- label = 1614LLU; // continue unrolling stack, delete next variable
18976+ label = 1630LLU; // continue unrolling stack, delete next variable
1884118977 break;
1884218978 }
18843- case 1616LLU: // skipped deleter
18979+ case 1632LLU: // skipped deleter
1884418980 {
1884518981 stack[base + 3] = 0;
1884618982 flippedassign(stack[base + 1]/*idfndefs*/, &stack[base + 4]);
18847- label = 1617LLU; // start to repeat
18983+ label = 1633LLU; // start to repeat
1884818984 break;
1884918985 }
18850- case 1617LLU: // repeat from here
18986+ case 1633LLU: // repeat from here
1885118987 {
1885218988 if(!stack[base + 4])
1885318989 {
18854- label = 1618LLU; // break loop
18990+ label = 1634LLU; // break loop
1885518991 break;
1885618992 }
1885718993
@@ -18861,19 +18997,19 @@
1886118997 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1886218998 if(!stack[base + 3]/*found*/)
1886318999 {
18864- label = 1620LLU; // jump to alternative
19000+ label = 1636LLU; // jump to alternative
1886519001 break;
1886619002 }
1886719003
1886819004 // consequent
18869- label = 1621LLU; // consequent complete
19005+ label = 1637LLU; // consequent complete
1887019006 break;
1887119007 }
18872- case 1620LLU: // alternative
19008+ case 1636LLU: // alternative
1887319009 {
1887419010 if(/*idfndef*/0 != ((uint64_t *)(stack[base + 5]/*idfndef*/))[0])
1887519011 {
18876- label = 1623LLU; // jump to alternative
19012+ label = 1639LLU; // jump to alternative
1887719013 break;
1887819014 }
1887919015
@@ -18881,27 +19017,27 @@
1888119017 /*fndef*/stack[base + 8] = ((uint64_t **)(stack[base + 5]/*idfndef*/))[1][1]/*fndef*/;
1888219018
1888319019 // case
18884- label = 1626LLU; // skip deleter
19020+ label = 1642LLU; // skip deleter
1888519021 break;
1888619022 }
18887- case 1625LLU: // deleter
19023+ case 1641LLU: // deleter
1888819024 {
1888919025 // throw from existsidfn
1889019026 if(!stack[base + 9])
1889119027 {
18892- label = 1624LLU; // skip, variable already deleted/unscoped
19028+ label = 1640LLU; // skip, variable already deleted/unscoped
1889319029 break;
1889419030 }
18895- label = 1624LLU; // continue unrolling stack, delete next variable
19031+ label = 1640LLU; // continue unrolling stack, delete next variable
1889619032 break;
1889719033 }
18898- case 1626LLU: // skipped deleter
19034+ case 1642LLU: // skipped deleter
1889919035 {
1890019036 stack[base + 9] = 0;
1890119037 // call equ from existsidfn
18902- stack[base + 10LLU] = 1627LLU/*throw to this address*/;
19038+ stack[base + 10LLU] = 1643LLU/*throw to this address*/;
1890319039 stack[base + 11LLU] = base;
18904- stack[base + 12LLU] = 1628LLU;
19040+ stack[base + 12LLU] = 1644LLU;
1890519041 // arguments for call to equ
1890619042 stack[base + 14LLU] = stack[base + 7]/*id*/;
1890719043 stack[base + 15LLU] = stack[base + 2]/*searchid*/;
@@ -18910,13 +19046,13 @@
1891019046 label = 18446744073709551600LLU; // equ
1891119047 break;
1891219048 }
18913- case 1627LLU: // copy-back deleter (equ to existsidfn)
19049+ case 1643LLU: // copy-back deleter (equ to existsidfn)
1891419050 {
1891519051 // copy mutable arguments back from call to equ
18916- label = 1625LLU; // continue to roll stack
19052+ label = 1641LLU; // continue to roll stack
1891719053 break;
1891819054 }
18919- case 1628LLU: // return from equ to existsidfn
19055+ case 1644LLU: // return from equ to existsidfn
1892019056 {
1892119057 // copy mutable arguments back from call to equ
1892219058 // copy back results provided by call to equ
@@ -18923,73 +19059,73 @@
1892319059 stack[base + 9] = stack[base + 13LLU];
1892419060 if(!stack[base + 9]/*isequal*/)
1892519061 {
18926- label = 1629LLU; // jump to alternative
19062+ label = 1645LLU; // jump to alternative
1892719063 break;
1892819064 }
1892919065
1893019066 // consequent
1893119067 stack[base + 3]/*found*/ = 1;
18932- label = 1630LLU; // consequent complete
19068+ label = 1646LLU; // consequent complete
1893319069 break;
1893419070 }
18935- case 1629LLU: // alternative
19071+ case 1645LLU: // alternative
1893619072 {
18937- label = 1630LLU; // alternative complete
19073+ label = 1646LLU; // alternative complete
1893819074 break;
1893919075 }
18940- case 1630LLU: // completed if-then-else
19076+ case 1646LLU: // completed if-then-else
1894119077 {
1894219078 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1894319079 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18944- label = 1622LLU; // case complete
19080+ label = 1638LLU; // case complete
1894519081 break;
1894619082 }
18947- case 1624LLU: // copy-back deleter (switch)
19083+ case 1640LLU: // copy-back deleter (switch)
1894819084 {
1894919085 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1895019086 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18951- label = 1619LLU; // continue to unroll stack
19087+ label = 1635LLU; // continue to unroll stack
1895219088 break;
1895319089 }
18954- case 1623LLU: // try next case
19090+ case 1639LLU: // try next case
1895519091 {
1895619092 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1895719093 exit(-1);
1895819094 }
18959- case 1622LLU: // completed switch
19095+ case 1638LLU: // completed switch
1896019096 {
18961- label = 1621LLU; // alternative complete
19097+ label = 1637LLU; // alternative complete
1896219098 break;
1896319099 }
18964- case 1621LLU: // completed if-then-else
19100+ case 1637LLU: // completed if-then-else
1896519101 {
1896619102 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18967- label = 1617LLU; // repeat
19103+ label = 1633LLU; // repeat
1896819104 break;
1896919105 }
18970- case 1619LLU: // copy-back deleter for while next
19106+ case 1635LLU: // copy-back deleter for while next
1897119107 {
1897219108 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18973- label = 1615LLU; // continue to unroll stack
19109+ label = 1631LLU; // continue to unroll stack
1897419110 break;
1897519111 }
18976- case 1618LLU: // loop finished
19112+ case 1634LLU: // loop finished
1897719113 {
18978- label = 1632LLU; // skip deleter
19114+ label = 1648LLU; // skip deleter
1897919115 break;
1898019116 }
18981- case 1631LLU: // deleter
19117+ case 1647LLU: // deleter
1898219118 {
1898319119 // throw from existsidfn
1898419120 if(!stack[base + 0])
1898519121 {
18986- label = 1615LLU; // skip, variable already deleted/unscoped
19122+ label = 1631LLU; // skip, variable already deleted/unscoped
1898719123 break;
1898819124 }
18989- label = 1615LLU; // continue unrolling stack, delete next variable
19125+ label = 1631LLU; // continue unrolling stack, delete next variable
1899019126 break;
1899119127 }
18992- case 1632LLU: // skipped deleter
19128+ case 1648LLU: // skipped deleter
1899319129 {
1899419130 stack[base + 0] = stack[base + 3]/*found*/;
1899519131 // return from existsidfn
@@ -18997,21 +19133,21 @@
1899719133 base = stack[base - 2];
1899819134 break;
1899919135 }
19000- case 1634LLU: // function emitcase failed
19136+ case 1650LLU: // function emitcase failed
1900119137 {
1900219138 label = stack[base - 3];
1900319139 base = stack[base - 2];
1900419140 break;
1900519141 }
19006- case 1633LLU: // emitcase
19142+ case 1649LLU: // emitcase
1900719143 {
1900819144 //#define arg0 0
1900919145 //#define arg1 1
1901019146 printf("%s", "\n case -");
1901119147 // call printnr from emitcase
19012- stack[base + 2LLU] = 1635LLU/*throw to this address*/;
19148+ stack[base + 2LLU] = 1651LLU/*throw to this address*/;
1901319149 stack[base + 3LLU] = base;
19014- stack[base + 4LLU] = 1636LLU;
19150+ stack[base + 4LLU] = 1652LLU;
1901519151 // arguments for call to printnr
1901619152 stack[base + 5LLU] = stack[base + 0]/*label*/;
1901719153 // set stack-base & callee-address
@@ -19019,20 +19155,20 @@
1901919155 label = 18446744073709551590LLU; // printnr
1902019156 break;
1902119157 }
19022- case 1635LLU: // copy-back deleter (printnr to emitcase)
19158+ case 1651LLU: // copy-back deleter (printnr to emitcase)
1902319159 {
1902419160 // copy mutable arguments back from call to printnr
19025- label = 1634LLU; // continue to roll stack
19161+ label = 1650LLU; // continue to roll stack
1902619162 break;
1902719163 }
19028- case 1636LLU: // return from printnr to emitcase
19164+ case 1652LLU: // return from printnr to emitcase
1902919165 {
1903019166 // copy mutable arguments back from call to printnr
1903119167 printf("%s", ": // ");
1903219168 // call printid from emitcase
19033- stack[base + 2LLU] = 1637LLU/*throw to this address*/;
19169+ stack[base + 2LLU] = 1653LLU/*throw to this address*/;
1903419170 stack[base + 3LLU] = base;
19035- stack[base + 4LLU] = 1638LLU;
19171+ stack[base + 4LLU] = 1654LLU;
1903619172 // arguments for call to printid
1903719173 stack[base + 5LLU] = stack[base + 1]/*defid*/;
1903819174 // set stack-base & callee-address
@@ -19040,13 +19176,13 @@
1904019176 label = 18446744073709551587LLU; // printid
1904119177 break;
1904219178 }
19043- case 1637LLU: // copy-back deleter (printid to emitcase)
19179+ case 1653LLU: // copy-back deleter (printid to emitcase)
1904419180 {
1904519181 // copy mutable arguments back from call to printid
19046- label = 1634LLU; // continue to roll stack
19182+ label = 1650LLU; // continue to roll stack
1904719183 break;
1904819184 }
19049- case 1638LLU: // return from printid to emitcase
19185+ case 1654LLU: // return from printid to emitcase
1905019186 {
1905119187 // copy mutable arguments back from call to printid
1905219188 printf("%s", "\n {");
@@ -19055,13 +19191,13 @@
1905519191 base = stack[base - 2];
1905619192 break;
1905719193 }
19058- case 1640LLU: // function emitreturn failed
19194+ case 1656LLU: // function emitreturn failed
1905919195 {
1906019196 label = stack[base - 3];
1906119197 base = stack[base - 2];
1906219198 break;
1906319199 }
19064- case 1639LLU: // emitreturn
19200+ case 1655LLU: // emitreturn
1906519201 {
1906619202 printf("%s", "\n");
1906719203 printf("%s", "\n label = stack[base - 1];");
@@ -19073,13 +19209,13 @@
1907319209 base = stack[base - 2];
1907419210 break;
1907519211 }
19076- case 1642LLU: // function EMITTHROW failed
19212+ case 1658LLU: // function EMITTHROW failed
1907719213 {
1907819214 label = stack[base - 3];
1907919215 base = stack[base - 2];
1908019216 break;
1908119217 }
19082- case 1641LLU: // EMITTHROW
19218+ case 1657LLU: // EMITTHROW
1908319219 {
1908419220 printf("%s", "\n label = stack[base - 3];");
1908519221 printf("%s", "\n base = stack[base - 2];");
@@ -19090,38 +19226,38 @@
1909019226 base = stack[base - 2];
1909119227 break;
1909219228 }
19093- case 1644LLU: // function isparam failed
19229+ case 1660LLU: // function isparam failed
1909419230 {
1909519231 label = stack[base - 3];
1909619232 base = stack[base - 2];
1909719233 break;
1909819234 }
19099- case 1643LLU: // isparam
19235+ case 1659LLU: // isparam
1910019236 {
1910119237 //#define res0 0
1910219238 //#define arg0 1
1910319239 //#define arg1 2
1910419240 //#define arg2 3
19105- label = 1646LLU; // skip deleter
19241+ label = 1662LLU; // skip deleter
1910619242 break;
1910719243 }
19108- case 1645LLU: // deleter
19244+ case 1661LLU: // deleter
1910919245 {
1911019246 // throw from isparam
1911119247 if(!stack[base + 4])
1911219248 {
19113- label = 1644LLU; // skip, variable already deleted/unscoped
19249+ label = 1660LLU; // skip, variable already deleted/unscoped
1911419250 break;
1911519251 }
19116- label = 1644LLU; // continue unrolling stack, delete next variable
19252+ label = 1660LLU; // continue unrolling stack, delete next variable
1911719253 break;
1911819254 }
19119- case 1646LLU: // skipped deleter
19255+ case 1662LLU: // skipped deleter
1912019256 {
1912119257 // call add from isparam
19122- stack[base + 5LLU] = 1647LLU/*throw to this address*/;
19258+ stack[base + 5LLU] = 1663LLU/*throw to this address*/;
1912319259 stack[base + 6LLU] = base;
19124- stack[base + 7LLU] = 1648LLU;
19260+ stack[base + 7LLU] = 1664LLU;
1912519261 // arguments for call to add
1912619262 stack[base + 9LLU] = stack[base + 1]/*rescount*/;
1912719263 stack[base + 10LLU] = stack[base + 2]/*argcount*/;
@@ -19130,21 +19266,21 @@
1913019266 label = 18446744073709551605LLU; // add
1913119267 break;
1913219268 }
19133- case 1647LLU: // copy-back deleter (add to isparam)
19269+ case 1663LLU: // copy-back deleter (add to isparam)
1913419270 {
1913519271 // copy mutable arguments back from call to add
19136- label = 1644LLU; // continue to roll stack
19272+ label = 1660LLU; // continue to roll stack
1913719273 break;
1913819274 }
19139- case 1648LLU: // return from add to isparam
19275+ case 1664LLU: // return from add to isparam
1914019276 {
1914119277 // copy mutable arguments back from call to add
1914219278 // copy back results provided by call to add
1914319279 stack[base + 4] = stack[base + 8LLU];
1914419280 // call lss from isparam
19145- stack[base + 5LLU] = 1649LLU/*throw to this address*/;
19281+ stack[base + 5LLU] = 1665LLU/*throw to this address*/;
1914619282 stack[base + 6LLU] = base;
19147- stack[base + 7LLU] = 1650LLU;
19283+ stack[base + 7LLU] = 1666LLU;
1914819284 // arguments for call to lss
1914919285 stack[base + 9LLU] = stack[base + 3]/*index*/;
1915019286 stack[base + 10LLU] = stack[base + 4]/*varbase*/;
@@ -19153,13 +19289,13 @@
1915319289 label = 18446744073709551597LLU; // lss
1915419290 break;
1915519291 }
19156- case 1649LLU: // copy-back deleter (lss to isparam)
19292+ case 1665LLU: // copy-back deleter (lss to isparam)
1915719293 {
1915819294 // copy mutable arguments back from call to lss
19159- label = 1645LLU; // continue to roll stack
19295+ label = 1661LLU; // continue to roll stack
1916019296 break;
1916119297 }
19162- case 1650LLU: // return from lss to isparam
19298+ case 1666LLU: // return from lss to isparam
1916319299 {
1916419300 // copy mutable arguments back from call to lss
1916519301 // copy back results provided by call to lss
@@ -19169,13 +19305,13 @@
1916919305 base = stack[base - 2];
1917019306 break;
1917119307 }
19172- case 1652LLU: // function REGISTER failed
19308+ case 1668LLU: // function REGISTER failed
1917319309 {
1917419310 label = stack[base - 3];
1917519311 base = stack[base - 2];
1917619312 break;
1917719313 }
19178- case 1651LLU: // REGISTER
19314+ case 1667LLU: // REGISTER
1917919315 {
1918019316 //#define arg0 0
1918119317 //#define arg1 1
@@ -19185,26 +19321,26 @@
1918519321 //#define arg5 5
1918619322 //#define arg6 6
1918719323 //#define arg7 7
19188- label = 1654LLU; // skip deleter
19324+ label = 1670LLU; // skip deleter
1918919325 break;
1919019326 }
19191- case 1653LLU: // deleter
19327+ case 1669LLU: // deleter
1919219328 {
1919319329 // throw from REGISTER
1919419330 if(!stack[base + 8])
1919519331 {
19196- label = 1652LLU; // skip, variable already deleted/unscoped
19332+ label = 1668LLU; // skip, variable already deleted/unscoped
1919719333 break;
1919819334 }
1919919335 // delete list
19200- label = 1655LLU; // start to repeat
19336+ label = 1671LLU; // start to repeat
1920119337 break;
1920219338 }
19203- case 1655LLU: // repeat from here
19339+ case 1671LLU: // repeat from here
1920419340 {
1920519341 if(!stack[base + 8])
1920619342 {
19207- label = 1656LLU; // break loop
19343+ label = 1672LLU; // break loop
1920819344 break;
1920919345 }
1921019346
@@ -19215,7 +19351,7 @@
1921519351 newstack[0] = (uint64_t)stack; // backup stack location
1921619352 newstack[1] = 1234567890;
1921719353 newstack[2] = base;
19218- newstack[3] = 1657LLU;
19354+ newstack[3] = 1673LLU;
1921919355 stack = newstack;
1922019356 // set stack-base & callee-address
1922119357 base = 4/*deloffset*/;
@@ -19222,7 +19358,7 @@
1922219358 label = 417LLU; // ~result
1922319359 break;
1922419360 }
19225- case 1657LLU: // return from ~result to REGISTER
19361+ case 1673LLU: // return from ~result to REGISTER
1922619362 {
1922719363 stack = (uint64_t *)stack[0];
1922819364 // releasing toplevel container
@@ -19233,40 +19369,40 @@
1923319369 stack[base + 8] = (uint64_t)list->next;
1923419370 Free(1, sizeof(struct listnode), list);
1923519371 }
19236- label = 1655LLU; // repeat
19372+ label = 1671LLU; // repeat
1923719373 break;
1923819374 }
19239- case 1656LLU: // loop finished
19375+ case 1672LLU: // loop finished
1924019376 {
19241- label = 1652LLU; // continue unrolling stack, delete next variable
19377+ label = 1668LLU; // continue unrolling stack, delete next variable
1924219378 break;
1924319379 }
19244- case 1654LLU: // skipped deleter
19380+ case 1670LLU: // skipped deleter
1924519381 {
1924619382 stack[base + 8] = 0;
1924719383 stack[base + 9] = stack[base + 0]/*rescount*/;
1924819384
19249- label = 1658LLU; // start to repeat
19385+ label = 1674LLU; // start to repeat
1925019386 break;
1925119387 }
19252- case 1658LLU: // repeat from here
19388+ case 1674LLU: // repeat from here
1925319389 {
1925419390 if(!stack[base + 9]--)
1925519391 {
19256- label = 1659LLU; // break loop
19392+ label = 1675LLU; // break loop
1925719393 break;
1925819394 }
1925919395
1926019396 // loop body
19261- label = 1661LLU; // skip deleter
19397+ label = 1677LLU; // skip deleter
1926219398 break;
1926319399 }
19264- case 1660LLU: // deleter
19400+ case 1676LLU: // deleter
1926519401 {
1926619402 // throw from REGISTER
1926719403 if(!stack[base + 10])
1926819404 {
19269- label = 1653LLU; // skip, variable already deleted/unscoped
19405+ label = 1669LLU; // skip, variable already deleted/unscoped
1927019406 break;
1927119407 }
1927219408
@@ -19275,7 +19411,7 @@
1927519411 newstack[0] = (uint64_t)stack; // backup stack location
1927619412 newstack[1] = 1234567890;
1927719413 newstack[2] = base;
19278- newstack[3] = 1662LLU;
19414+ newstack[3] = 1678LLU;
1927919415 stack = newstack;
1928019416 // set stack-base & callee-address
1928119417 base = 4/*deloffset*/;
@@ -19282,21 +19418,21 @@
1928219418 label = 310LLU; // ~type
1928319419 break;
1928419420 }
19285- case 1662LLU: // return from ~type to REGISTER
19421+ case 1678LLU: // return from ~type to REGISTER
1928619422 {
1928719423 stack = (uint64_t *)stack[0];
1928819424 // releasing toplevel container
1928919425 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 10] - sizeof(uint64_t) * 4));
1929019426
19291- label = 1653LLU; // continue unrolling stack, delete next variable
19427+ label = 1669LLU; // continue unrolling stack, delete next variable
1929219428 break;
1929319429 }
19294- case 1661LLU: // skipped deleter
19430+ case 1677LLU: // skipped deleter
1929519431 {
1929619432 // call mktypedata from REGISTER
19297- stack[base + 11LLU] = 1663LLU/*throw to this address*/;
19433+ stack[base + 11LLU] = 1679LLU/*throw to this address*/;
1929819434 stack[base + 12LLU] = base;
19299- stack[base + 13LLU] = 1664LLU;
19435+ stack[base + 13LLU] = 1680LLU;
1930019436 // arguments for call to mktypedata
1930119437 stack[base + 15LLU] = 881834713755418624LLU;
1930219438 // set stack-base & callee-address
@@ -19304,43 +19440,43 @@
1930419440 label = 314LLU; // mktypedata
1930519441 break;
1930619442 }
19307- case 1663LLU: // copy-back deleter (mktypedata to REGISTER)
19443+ case 1679LLU: // copy-back deleter (mktypedata to REGISTER)
1930819444 {
1930919445 // copy mutable arguments back from call to mktypedata
19310- label = 1653LLU; // continue to roll stack
19446+ label = 1669LLU; // continue to roll stack
1931119447 break;
1931219448 }
19313- case 1664LLU: // return from mktypedata to REGISTER
19449+ case 1680LLU: // return from mktypedata to REGISTER
1931419450 {
1931519451 // copy mutable arguments back from call to mktypedata
1931619452 // copy back results provided by call to mktypedata
1931719453 stack[base + 10] = stack[base + 14LLU];
19318- label = 1666LLU; // skip deleter
19454+ label = 1682LLU; // skip deleter
1931919455 break;
1932019456 }
19321- case 1665LLU: // deleter
19457+ case 1681LLU: // deleter
1932219458 {
1932319459 // throw from REGISTER
1932419460 if(!stack[base + 11])
1932519461 {
19326- label = 1660LLU; // skip, variable already deleted/unscoped
19462+ label = 1676LLU; // skip, variable already deleted/unscoped
1932719463 break;
1932819464 }
19329- label = 1660LLU; // continue unrolling stack, delete next variable
19465+ label = 1676LLU; // continue unrolling stack, delete next variable
1933019466 break;
1933119467 }
19332- case 1666LLU: // skipped deleter
19468+ case 1682LLU: // skipped deleter
1933319469 {
1933419470 stack[base + 11] = 1;
19335- label = 1668LLU; // skip deleter
19471+ label = 1684LLU; // skip deleter
1933619472 break;
1933719473 }
19338- case 1667LLU: // deleter
19474+ case 1683LLU: // deleter
1933919475 {
1934019476 // throw from REGISTER
1934119477 if(!stack[base + 12])
1934219478 {
19343- label = 1665LLU; // skip, variable already deleted/unscoped
19479+ label = 1681LLU; // skip, variable already deleted/unscoped
1934419480 break;
1934519481 }
1934619482
@@ -19349,7 +19485,7 @@
1934919485 newstack[0] = (uint64_t)stack; // backup stack location
1935019486 newstack[1] = 1234567890;
1935119487 newstack[2] = base;
19352- newstack[3] = 1669LLU;
19488+ newstack[3] = 1685LLU;
1935319489 stack = newstack;
1935419490 // set stack-base & callee-address
1935519491 base = 4/*deloffset*/;
@@ -19356,21 +19492,21 @@
1935619492 label = 417LLU; // ~result
1935719493 break;
1935819494 }
19359- case 1669LLU: // return from ~result to REGISTER
19495+ case 1685LLU: // return from ~result to REGISTER
1936019496 {
1936119497 stack = (uint64_t *)stack[0];
1936219498 // releasing toplevel container
1936319499 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1936419500
19365- label = 1665LLU; // continue unrolling stack, delete next variable
19501+ label = 1681LLU; // continue unrolling stack, delete next variable
1936619502 break;
1936719503 }
19368- case 1668LLU: // skipped deleter
19504+ case 1684LLU: // skipped deleter
1936919505 {
1937019506 // construct result.result
1937119507 if(!(stack[base + 12] = construct(2)))
1937219508 {
19373- label = 1665LLU; // throw: begin to unroll stack
19509+ label = 1681LLU; // throw: begin to unroll stack
1937419510 break;
1937519511 }
1937619512
@@ -19391,31 +19527,31 @@
1939119527 /*fnrestypes*/stack[base + 8] = (uint64_t)list;
1939219528 MOVE(&list->data, &stack[base + 12]/*result*/);
1939319529 }
19394- label = 1658LLU; // repeat
19530+ label = 1674LLU; // repeat
1939519531 break;
1939619532 }
19397- case 1659LLU: // loop finished
19533+ case 1675LLU: // loop finished
1939819534 {
19399- label = 1671LLU; // skip deleter
19535+ label = 1687LLU; // skip deleter
1940019536 break;
1940119537 }
19402- case 1670LLU: // deleter
19538+ case 1686LLU: // deleter
1940319539 {
1940419540 // throw from REGISTER
1940519541 if(!stack[base + 10])
1940619542 {
19407- label = 1653LLU; // skip, variable already deleted/unscoped
19543+ label = 1669LLU; // skip, variable already deleted/unscoped
1940819544 break;
1940919545 }
1941019546 // delete list
19411- label = 1672LLU; // start to repeat
19547+ label = 1688LLU; // start to repeat
1941219548 break;
1941319549 }
19414- case 1672LLU: // repeat from here
19550+ case 1688LLU: // repeat from here
1941519551 {
1941619552 if(!stack[base + 10])
1941719553 {
19418- label = 1673LLU; // break loop
19554+ label = 1689LLU; // break loop
1941919555 break;
1942019556 }
1942119557
@@ -19426,7 +19562,7 @@
1942619562 newstack[0] = (uint64_t)stack; // backup stack location
1942719563 newstack[1] = 1234567890;
1942819564 newstack[2] = base;
19429- newstack[3] = 1674LLU;
19565+ newstack[3] = 1690LLU;
1943019566 stack = newstack;
1943119567 // set stack-base & callee-address
1943219568 base = 4/*deloffset*/;
@@ -19433,7 +19569,7 @@
1943319569 label = 440LLU; // ~param
1943419570 break;
1943519571 }
19436- case 1674LLU: // return from ~param to REGISTER
19572+ case 1690LLU: // return from ~param to REGISTER
1943719573 {
1943819574 stack = (uint64_t *)stack[0];
1943919575 // releasing toplevel container
@@ -19444,40 +19580,40 @@
1944419580 stack[base + 10] = (uint64_t)list->next;
1944519581 Free(1, sizeof(struct listnode), list);
1944619582 }
19447- label = 1672LLU; // repeat
19583+ label = 1688LLU; // repeat
1944819584 break;
1944919585 }
19450- case 1673LLU: // loop finished
19586+ case 1689LLU: // loop finished
1945119587 {
19452- label = 1653LLU; // continue unrolling stack, delete next variable
19588+ label = 1669LLU; // continue unrolling stack, delete next variable
1945319589 break;
1945419590 }
19455- case 1671LLU: // skipped deleter
19591+ case 1687LLU: // skipped deleter
1945619592 {
1945719593 stack[base + 10] = 0;
1945819594 stack[base + 11] = stack[base + 1]/*argcount*/;
1945919595
19460- label = 1675LLU; // start to repeat
19596+ label = 1691LLU; // start to repeat
1946119597 break;
1946219598 }
19463- case 1675LLU: // repeat from here
19599+ case 1691LLU: // repeat from here
1946419600 {
1946519601 if(!stack[base + 11]--)
1946619602 {
19467- label = 1676LLU; // break loop
19603+ label = 1692LLU; // break loop
1946819604 break;
1946919605 }
1947019606
1947119607 // loop body
19472- label = 1678LLU; // skip deleter
19608+ label = 1694LLU; // skip deleter
1947319609 break;
1947419610 }
19475- case 1677LLU: // deleter
19611+ case 1693LLU: // deleter
1947619612 {
1947719613 // throw from REGISTER
1947819614 if(!stack[base + 12])
1947919615 {
19480- label = 1670LLU; // skip, variable already deleted/unscoped
19616+ label = 1686LLU; // skip, variable already deleted/unscoped
1948119617 break;
1948219618 }
1948319619
@@ -19486,7 +19622,7 @@
1948619622 newstack[0] = (uint64_t)stack; // backup stack location
1948719623 newstack[1] = 1234567890;
1948819624 newstack[2] = base;
19489- newstack[3] = 1679LLU;
19625+ newstack[3] = 1695LLU;
1949019626 stack = newstack;
1949119627 // set stack-base & callee-address
1949219628 base = 4/*deloffset*/;
@@ -19493,21 +19629,21 @@
1949319629 label = 310LLU; // ~type
1949419630 break;
1949519631 }
19496- case 1679LLU: // return from ~type to REGISTER
19632+ case 1695LLU: // return from ~type to REGISTER
1949719633 {
1949819634 stack = (uint64_t *)stack[0];
1949919635 // releasing toplevel container
1950019636 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1950119637
19502- label = 1670LLU; // continue unrolling stack, delete next variable
19638+ label = 1686LLU; // continue unrolling stack, delete next variable
1950319639 break;
1950419640 }
19505- case 1678LLU: // skipped deleter
19641+ case 1694LLU: // skipped deleter
1950619642 {
1950719643 // call mktypedata from REGISTER
19508- stack[base + 13LLU] = 1680LLU/*throw to this address*/;
19644+ stack[base + 13LLU] = 1696LLU/*throw to this address*/;
1950919645 stack[base + 14LLU] = base;
19510- stack[base + 15LLU] = 1681LLU;
19646+ stack[base + 15LLU] = 1697LLU;
1951119647 // arguments for call to mktypedata
1951219648 stack[base + 17LLU] = 881834713755418624LLU;
1951319649 // set stack-base & callee-address
@@ -19515,37 +19651,37 @@
1951519651 label = 314LLU; // mktypedata
1951619652 break;
1951719653 }
19518- case 1680LLU: // copy-back deleter (mktypedata to REGISTER)
19654+ case 1696LLU: // copy-back deleter (mktypedata to REGISTER)
1951919655 {
1952019656 // copy mutable arguments back from call to mktypedata
19521- label = 1670LLU; // continue to roll stack
19657+ label = 1686LLU; // continue to roll stack
1952219658 break;
1952319659 }
19524- case 1681LLU: // return from mktypedata to REGISTER
19660+ case 1697LLU: // return from mktypedata to REGISTER
1952519661 {
1952619662 // copy mutable arguments back from call to mktypedata
1952719663 // copy back results provided by call to mktypedata
1952819664 stack[base + 12] = stack[base + 16LLU];
19529- label = 1683LLU; // skip deleter
19665+ label = 1699LLU; // skip deleter
1953019666 break;
1953119667 }
19532- case 1682LLU: // deleter
19668+ case 1698LLU: // deleter
1953319669 {
1953419670 // throw from REGISTER
1953519671 if(!stack[base + 13])
1953619672 {
19537- label = 1677LLU; // skip, variable already deleted/unscoped
19673+ label = 1693LLU; // skip, variable already deleted/unscoped
1953819674 break;
1953919675 }
19540- label = 1677LLU; // continue unrolling stack, delete next variable
19676+ label = 1693LLU; // continue unrolling stack, delete next variable
1954119677 break;
1954219678 }
19543- case 1683LLU: // skipped deleter
19679+ case 1699LLU: // skipped deleter
1954419680 {
1954519681 // call idwithnr from REGISTER
19546- stack[base + 14LLU] = 1684LLU/*throw to this address*/;
19682+ stack[base + 14LLU] = 1700LLU/*throw to this address*/;
1954719683 stack[base + 15LLU] = base;
19548- stack[base + 16LLU] = 1685LLU;
19684+ stack[base + 16LLU] = 1701LLU;
1954919685 // arguments for call to idwithnr
1955019686 stack[base + 18LLU] = 517219065798852608LLU;
1955119687 stack[base + 19LLU] = stack[base + 11]/*ARGCOUNT*/;
@@ -19554,26 +19690,26 @@
1955419690 label = 18446744073709551579LLU; // idwithnr
1955519691 break;
1955619692 }
19557- case 1684LLU: // copy-back deleter (idwithnr to REGISTER)
19693+ case 1700LLU: // copy-back deleter (idwithnr to REGISTER)
1955819694 {
1955919695 // copy mutable arguments back from call to idwithnr
19560- label = 1677LLU; // continue to roll stack
19696+ label = 1693LLU; // continue to roll stack
1956119697 break;
1956219698 }
19563- case 1685LLU: // return from idwithnr to REGISTER
19699+ case 1701LLU: // return from idwithnr to REGISTER
1956419700 {
1956519701 // copy mutable arguments back from call to idwithnr
1956619702 // copy back results provided by call to idwithnr
1956719703 stack[base + 13] = stack[base + 17LLU];
19568- label = 1687LLU; // skip deleter
19704+ label = 1703LLU; // skip deleter
1956919705 break;
1957019706 }
19571- case 1686LLU: // deleter
19707+ case 1702LLU: // deleter
1957219708 {
1957319709 // throw from REGISTER
1957419710 if(!stack[base + 14])
1957519711 {
19576- label = 1682LLU; // skip, variable already deleted/unscoped
19712+ label = 1698LLU; // skip, variable already deleted/unscoped
1957719713 break;
1957819714 }
1957919715
@@ -19582,7 +19718,7 @@
1958219718 newstack[0] = (uint64_t)stack; // backup stack location
1958319719 newstack[1] = 1234567890;
1958419720 newstack[2] = base;
19585- newstack[3] = 1688LLU;
19721+ newstack[3] = 1704LLU;
1958619722 stack = newstack;
1958719723 // set stack-base & callee-address
1958819724 base = 4/*deloffset*/;
@@ -19589,21 +19725,21 @@
1958919725 label = 372LLU; // ~typeid
1959019726 break;
1959119727 }
19592- case 1688LLU: // return from ~typeid to REGISTER
19728+ case 1704LLU: // return from ~typeid to REGISTER
1959319729 {
1959419730 stack = (uint64_t *)stack[0];
1959519731 // releasing toplevel container
1959619732 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1959719733
19598- label = 1682LLU; // continue unrolling stack, delete next variable
19734+ label = 1698LLU; // continue unrolling stack, delete next variable
1959919735 break;
1960019736 }
19601- case 1687LLU: // skipped deleter
19737+ case 1703LLU: // skipped deleter
1960219738 {
1960319739 // construct typeid.typeid
1960419740 if(!(stack[base + 14] = construct(2)))
1960519741 {
19606- label = 1682LLU; // throw: begin to unroll stack
19742+ label = 1698LLU; // throw: begin to unroll stack
1960719743 break;
1960819744 }
1960919745
@@ -19611,32 +19747,32 @@
1961119747 ((uint64_t *)stack[base + 14])[0] = 0;
1961219748 INIT(&(((uint64_t **)(stack[base + 14]))[1][0]), &stack[base + 12]/*type*/);
1961319749 (((uint64_t **)(stack[base + 14]))[1][1]) = stack[base + 13]/*id*/;
19614- label = 1690LLU; // skip deleter
19750+ label = 1706LLU; // skip deleter
1961519751 break;
1961619752 }
19617- case 1689LLU: // deleter
19753+ case 1705LLU: // deleter
1961819754 {
1961919755 // throw from REGISTER
1962019756 if(!stack[base + 15])
1962119757 {
19622- label = 1686LLU; // skip, variable already deleted/unscoped
19758+ label = 1702LLU; // skip, variable already deleted/unscoped
1962319759 break;
1962419760 }
19625- label = 1686LLU; // continue unrolling stack, delete next variable
19761+ label = 1702LLU; // continue unrolling stack, delete next variable
1962619762 break;
1962719763 }
19628- case 1690LLU: // skipped deleter
19764+ case 1706LLU: // skipped deleter
1962919765 {
1963019766 stack[base + 15] = 0;
19631- label = 1692LLU; // skip deleter
19767+ label = 1708LLU; // skip deleter
1963219768 break;
1963319769 }
19634- case 1691LLU: // deleter
19770+ case 1707LLU: // deleter
1963519771 {
1963619772 // throw from REGISTER
1963719773 if(!stack[base + 16])
1963819774 {
19639- label = 1689LLU; // skip, variable already deleted/unscoped
19775+ label = 1705LLU; // skip, variable already deleted/unscoped
1964019776 break;
1964119777 }
1964219778
@@ -19645,7 +19781,7 @@
1964519781 newstack[0] = (uint64_t)stack; // backup stack location
1964619782 newstack[1] = 1234567890;
1964719783 newstack[2] = base;
19648- newstack[3] = 1693LLU;
19784+ newstack[3] = 1709LLU;
1964919785 stack = newstack;
1965019786 // set stack-base & callee-address
1965119787 base = 4/*deloffset*/;
@@ -19652,21 +19788,21 @@
1965219788 label = 440LLU; // ~param
1965319789 break;
1965419790 }
19655- case 1693LLU: // return from ~param to REGISTER
19791+ case 1709LLU: // return from ~param to REGISTER
1965619792 {
1965719793 stack = (uint64_t *)stack[0];
1965819794 // releasing toplevel container
1965919795 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
1966019796
19661- label = 1689LLU; // continue unrolling stack, delete next variable
19797+ label = 1705LLU; // continue unrolling stack, delete next variable
1966219798 break;
1966319799 }
19664- case 1692LLU: // skipped deleter
19800+ case 1708LLU: // skipped deleter
1966519801 {
1966619802 // construct param.param
1966719803 if(!(stack[base + 16] = construct(2)))
1966819804 {
19669- label = 1689LLU; // throw: begin to unroll stack
19805+ label = 1705LLU; // throw: begin to unroll stack
1967019806 break;
1967119807 }
1967219808
@@ -19687,49 +19823,49 @@
1968719823 /*fnargtypes*/stack[base + 10] = (uint64_t)list;
1968819824 MOVE(&list->data, &stack[base + 16]/*param*/);
1968919825 }
19690- label = 1675LLU; // repeat
19826+ label = 1691LLU; // repeat
1969119827 break;
1969219828 }
19693- case 1676LLU: // loop finished
19829+ case 1692LLU: // loop finished
1969419830 {
19695- label = 1695LLU; // skip deleter
19831+ label = 1711LLU; // skip deleter
1969619832 break;
1969719833 }
19698- case 1694LLU: // deleter
19834+ case 1710LLU: // deleter
1969919835 {
1970019836 // throw from REGISTER
1970119837 if(!stack[base + 12])
1970219838 {
19703- label = 1670LLU; // skip, variable already deleted/unscoped
19839+ label = 1686LLU; // skip, variable already deleted/unscoped
1970419840 break;
1970519841 }
19706- label = 1670LLU; // continue unrolling stack, delete next variable
19842+ label = 1686LLU; // continue unrolling stack, delete next variable
1970719843 break;
1970819844 }
19709- case 1695LLU: // skipped deleter
19845+ case 1711LLU: // skipped deleter
1971019846 {
1971119847 stack[base + 12] = 0;
19712- label = 1697LLU; // skip deleter
19848+ label = 1713LLU; // skip deleter
1971319849 break;
1971419850 }
19715- case 1696LLU: // deleter
19851+ case 1712LLU: // deleter
1971619852 {
1971719853 // throw from REGISTER
1971819854 if(!stack[base + 13])
1971919855 {
19720- label = 1694LLU; // skip, variable already deleted/unscoped
19856+ label = 1710LLU; // skip, variable already deleted/unscoped
1972119857 break;
1972219858 }
19723- label = 1694LLU; // continue unrolling stack, delete next variable
19859+ label = 1710LLU; // continue unrolling stack, delete next variable
1972419860 break;
1972519861 }
19726- case 1697LLU: // skipped deleter
19862+ case 1713LLU: // skipped deleter
1972719863 {
1972819864 stack[base + 13] = 0;
1972919865 // call sub from REGISTER
19730- stack[base + 14LLU] = 1698LLU/*throw to this address*/;
19866+ stack[base + 14LLU] = 1714LLU/*throw to this address*/;
1973119867 stack[base + 15LLU] = base;
19732- stack[base + 16LLU] = 1699LLU;
19868+ stack[base + 16LLU] = 1715LLU;
1973319869 // arguments for call to sub
1973419870 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1973519871 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
@@ -19738,21 +19874,21 @@
1973819874 label = 18446744073709551604LLU; // sub
1973919875 break;
1974019876 }
19741- case 1698LLU: // copy-back deleter (sub to REGISTER)
19877+ case 1714LLU: // copy-back deleter (sub to REGISTER)
1974219878 {
1974319879 // copy mutable arguments back from call to sub
19744- label = 1696LLU; // continue to roll stack
19880+ label = 1712LLU; // continue to roll stack
1974519881 break;
1974619882 }
19747- case 1699LLU: // return from sub to REGISTER
19883+ case 1715LLU: // return from sub to REGISTER
1974819884 {
1974919885 // copy mutable arguments back from call to sub
1975019886 // copy back results provided by call to sub
1975119887 stack[base + 13] = stack[base + 17LLU];
1975219888 // call sub from REGISTER
19753- stack[base + 14LLU] = 1700LLU/*throw to this address*/;
19889+ stack[base + 14LLU] = 1716LLU/*throw to this address*/;
1975419890 stack[base + 15LLU] = base;
19755- stack[base + 16LLU] = 1701LLU;
19891+ stack[base + 16LLU] = 1717LLU;
1975619892 // arguments for call to sub
1975719893 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1975819894 stack[base + 19LLU] = 1LLU;
@@ -19761,26 +19897,26 @@
1976119897 label = 18446744073709551604LLU; // sub
1976219898 break;
1976319899 }
19764- case 1700LLU: // copy-back deleter (sub to REGISTER)
19900+ case 1716LLU: // copy-back deleter (sub to REGISTER)
1976519901 {
1976619902 // copy mutable arguments back from call to sub
19767- label = 1696LLU; // continue to roll stack
19903+ label = 1712LLU; // continue to roll stack
1976819904 break;
1976919905 }
19770- case 1701LLU: // return from sub to REGISTER
19906+ case 1717LLU: // return from sub to REGISTER
1977119907 {
1977219908 // copy mutable arguments back from call to sub
1977319909 // copy back results provided by call to sub
1977419910 stack[base + 13] = stack[base + 17LLU];
19775- label = 1703LLU; // skip deleter
19911+ label = 1719LLU; // skip deleter
1977619912 break;
1977719913 }
19778- case 1702LLU: // deleter
19914+ case 1718LLU: // deleter
1977919915 {
1978019916 // throw from REGISTER
1978119917 if(!stack[base + 14])
1978219918 {
19783- label = 1696LLU; // skip, variable already deleted/unscoped
19919+ label = 1712LLU; // skip, variable already deleted/unscoped
1978419920 break;
1978519921 }
1978619922
@@ -19789,7 +19925,7 @@
1978919925 newstack[0] = (uint64_t)stack; // backup stack location
1979019926 newstack[1] = 1234567890;
1979119927 newstack[2] = base;
19792- newstack[3] = 1704LLU;
19928+ newstack[3] = 1720LLU;
1979319929 stack = newstack;
1979419930 // set stack-base & callee-address
1979519931 base = 4/*deloffset*/;
@@ -19796,21 +19932,21 @@
1979619932 label = 1420LLU; // ~fndef
1979719933 break;
1979819934 }
19799- case 1704LLU: // return from ~fndef to REGISTER
19935+ case 1720LLU: // return from ~fndef to REGISTER
1980019936 {
1980119937 stack = (uint64_t *)stack[0];
1980219938 // releasing toplevel container
1980319939 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1980419940
19805- label = 1696LLU; // continue unrolling stack, delete next variable
19941+ label = 1712LLU; // continue unrolling stack, delete next variable
1980619942 break;
1980719943 }
19808- case 1703LLU: // skipped deleter
19944+ case 1719LLU: // skipped deleter
1980919945 {
1981019946 // construct fndef.fndef
1981119947 if(!(stack[base + 14] = construct(8)))
1981219948 {
19813- label = 1696LLU; // throw: begin to unroll stack
19949+ label = 1712LLU; // throw: begin to unroll stack
1981419950 break;
1981519951 }
1981619952
@@ -19838,9 +19974,9 @@
1983819974 MOVE(&list->data, &stack[base + 14]/*fndef*/);
1983919975 }
1984019976 // call add from REGISTER
19841- stack[base + 15LLU] = 1705LLU/*throw to this address*/;
19977+ stack[base + 15LLU] = 1721LLU/*throw to this address*/;
1984219978 stack[base + 16LLU] = base;
19843- stack[base + 17LLU] = 1706LLU;
19979+ stack[base + 17LLU] = 1722LLU;
1984419980 // arguments for call to add
1984519981 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
1984619982 stack[base + 20LLU] = 1LLU;
@@ -19849,13 +19985,13 @@
1984919985 label = 18446744073709551605LLU; // add
1985019986 break;
1985119987 }
19852- case 1705LLU: // copy-back deleter (add to REGISTER)
19988+ case 1721LLU: // copy-back deleter (add to REGISTER)
1985319989 {
1985419990 // copy mutable arguments back from call to add
19855- label = 1702LLU; // continue to roll stack
19991+ label = 1718LLU; // continue to roll stack
1985619992 break;
1985719993 }
19858- case 1706LLU: // return from add to REGISTER
19994+ case 1722LLU: // return from add to REGISTER
1985919995 {
1986019996 // copy mutable arguments back from call to add
1986119997 // copy back results provided by call to add
@@ -19865,13 +20001,13 @@
1986520001 base = stack[base - 2];
1986620002 break;
1986720003 }
19868- case 1708LLU: // function register failed
20004+ case 1724LLU: // function register failed
1986920005 {
1987020006 label = stack[base - 3];
1987120007 base = stack[base - 2];
1987220008 break;
1987320009 }
19874- case 1707LLU: // register
20010+ case 1723LLU: // register
1987520011 {
1987620012 //#define arg0 0
1987720013 //#define arg1 1
@@ -19882,28 +20018,28 @@
1988220018 //#define arg6 6
1988320019 //#define arg7 7
1988420020 // call emitreturn from register
19885- stack[base + 8LLU] = 1709LLU/*throw to this address*/;
20021+ stack[base + 8LLU] = 1725LLU/*throw to this address*/;
1988620022 stack[base + 9LLU] = base;
19887- stack[base + 10LLU] = 1710LLU;
20023+ stack[base + 10LLU] = 1726LLU;
1988820024 // arguments for call to emitreturn
1988920025 // set stack-base & callee-address
1989020026 base += 11LLU;
19891- label = 1639LLU; // emitreturn
20027+ label = 1655LLU; // emitreturn
1989220028 break;
1989320029 }
19894- case 1709LLU: // copy-back deleter (emitreturn to register)
20030+ case 1725LLU: // copy-back deleter (emitreturn to register)
1989520031 {
1989620032 // copy mutable arguments back from call to emitreturn
19897- label = 1708LLU; // continue to roll stack
20033+ label = 1724LLU; // continue to roll stack
1989820034 break;
1989920035 }
19900- case 1710LLU: // return from emitreturn to register
20036+ case 1726LLU: // return from emitreturn to register
1990120037 {
1990220038 // copy mutable arguments back from call to emitreturn
1990320039 // call REGISTER from register
19904- stack[base + 8LLU] = 1711LLU/*throw to this address*/;
20040+ stack[base + 8LLU] = 1727LLU/*throw to this address*/;
1990520041 stack[base + 9LLU] = base;
19906- stack[base + 10LLU] = 1712LLU;
20042+ stack[base + 10LLU] = 1728LLU;
1990720043 // arguments for call to REGISTER
1990820044 stack[base + 11LLU] = stack[base + 0]/*rescount*/;
1990920045 stack[base + 12LLU] = stack[base + 1]/*argcount*/;
@@ -19915,41 +20051,41 @@
1991520051 stack[base + 18LLU] = stack[base + 7]/*IO*/;
1991620052 // set stack-base & callee-address
1991720053 base += 11LLU;
19918- label = 1651LLU; // REGISTER
20054+ label = 1667LLU; // REGISTER
1991920055 break;
1992020056 }
19921- case 1711LLU: // copy-back deleter (REGISTER to register)
20057+ case 1727LLU: // copy-back deleter (REGISTER to register)
1992220058 {
1992320059 // copy mutable arguments back from call to REGISTER
1992420060 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
1992520061 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
19926- label = 1708LLU; // continue to roll stack
20062+ label = 1724LLU; // continue to roll stack
1992720063 break;
1992820064 }
19929- case 1712LLU: // return from REGISTER to register
20065+ case 1728LLU: // return from REGISTER to register
1993020066 {
1993120067 // copy mutable arguments back from call to REGISTER
1993220068 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
1993320069 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
1993420070 // call emitcase from register
19935- stack[base + 8LLU] = 1713LLU/*throw to this address*/;
20071+ stack[base + 8LLU] = 1729LLU/*throw to this address*/;
1993620072 stack[base + 9LLU] = base;
19937- stack[base + 10LLU] = 1714LLU;
20073+ stack[base + 10LLU] = 1730LLU;
1993820074 // arguments for call to emitcase
1993920075 stack[base + 11LLU] = stack[base + 5]/*defcount*/;
1994020076 stack[base + 12LLU] = stack[base + 3]/*fnid*/;
1994120077 // set stack-base & callee-address
1994220078 base += 11LLU;
19943- label = 1633LLU; // emitcase
20079+ label = 1649LLU; // emitcase
1994420080 break;
1994520081 }
19946- case 1713LLU: // copy-back deleter (emitcase to register)
20082+ case 1729LLU: // copy-back deleter (emitcase to register)
1994720083 {
1994820084 // copy mutable arguments back from call to emitcase
19949- label = 1708LLU; // continue to roll stack
20085+ label = 1724LLU; // continue to roll stack
1995020086 break;
1995120087 }
19952- case 1714LLU: // return from emitcase to register
20088+ case 1730LLU: // return from emitcase to register
1995320089 {
1995420090 // copy mutable arguments back from call to emitcase
1995520091 // return from register
@@ -19957,19 +20093,19 @@
1995720093 base = stack[base - 2];
1995820094 break;
1995920095 }
19960- case 1716LLU: // function linkthrow failed
20096+ case 1732LLU: // function linkthrow failed
1996120097 {
1996220098 label = stack[base - 3];
1996320099 base = stack[base - 2];
1996420100 break;
1996520101 }
19966- case 1715LLU: // linkthrow
20102+ case 1731LLU: // linkthrow
1996720103 {
1996820104 //#define arg0 0
1996920105 //#define arg1 1
1997020106 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
1997120107 {
19972- label = 1718LLU; // jump to alternative
20108+ label = 1734LLU; // jump to alternative
1997320109 break;
1997420110 }
1997520111
@@ -19980,22 +20116,22 @@
1998020116 stack[base + 2]/*labelthrow*/ = stack[base + 1]/*labelfail*/;
1998120117 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
1998220118 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
19983- label = 1717LLU; // case complete
20119+ label = 1733LLU; // case complete
1998420120 break;
1998520121 }
19986- case 1719LLU: // copy-back deleter (switch)
20122+ case 1735LLU: // copy-back deleter (switch)
1998720123 {
1998820124 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
1998920125 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
19990- label = 1716LLU; // continue to unroll stack
20126+ label = 1732LLU; // continue to unroll stack
1999120127 break;
1999220128 }
19993- case 1718LLU: // try next case
20129+ case 1734LLU: // try next case
1999420130 {
1999520131 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1999620132 exit(-1);
1999720133 }
19998- case 1717LLU: // completed switch
20134+ case 1733LLU: // completed switch
1999920135 {
2000020136 // return from linkthrow
2000120137 label = stack[base - 1];
@@ -20002,19 +20138,19 @@
2000220138 base = stack[base - 2];
2000320139 break;
2000420140 }
20005- case 1721LLU: // function emitthrow failed
20141+ case 1737LLU: // function emitthrow failed
2000620142 {
2000720143 label = stack[base - 3];
2000820144 base = stack[base - 2];
2000920145 break;
2001020146 }
20011- case 1720LLU: // emitthrow
20147+ case 1736LLU: // emitthrow
2001220148 {
2001320149 //#define arg0 0
2001420150 printf("%s", "\n {");
2001520151 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
2001620152 {
20017- label = 1723LLU; // jump to alternative
20153+ label = 1739LLU; // jump to alternative
2001820154 break;
2001920155 }
2002020156
@@ -20024,9 +20160,9 @@
2002420160 // case
2002520161 printf("%s", "\n label = ");
2002620162 // call printnr from emitthrow
20027- stack[base + 3LLU] = 1725LLU/*throw to this address*/;
20163+ stack[base + 3LLU] = 1741LLU/*throw to this address*/;
2002820164 stack[base + 4LLU] = base;
20029- stack[base + 5LLU] = 1726LLU;
20165+ stack[base + 5LLU] = 1742LLU;
2003020166 // arguments for call to printnr
2003120167 stack[base + 6LLU] = stack[base + 1]/*labelthrow*/;
2003220168 // set stack-base & callee-address
@@ -20034,34 +20170,34 @@
2003420170 label = 18446744073709551590LLU; // printnr
2003520171 break;
2003620172 }
20037- case 1725LLU: // copy-back deleter (printnr to emitthrow)
20173+ case 1741LLU: // copy-back deleter (printnr to emitthrow)
2003820174 {
2003920175 // copy mutable arguments back from call to printnr
20040- label = 1724LLU; // continue to roll stack
20176+ label = 1740LLU; // continue to roll stack
2004120177 break;
2004220178 }
20043- case 1726LLU: // return from printnr to emitthrow
20179+ case 1742LLU: // return from printnr to emitthrow
2004420180 {
2004520181 // copy mutable arguments back from call to printnr
2004620182 printf("%s", "LLU; // throw: begin to unroll stack");
2004720183 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
2004820184 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
20049- label = 1722LLU; // case complete
20185+ label = 1738LLU; // case complete
2005020186 break;
2005120187 }
20052- case 1724LLU: // copy-back deleter (switch)
20188+ case 1740LLU: // copy-back deleter (switch)
2005320189 {
2005420190 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
2005520191 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
20056- label = 1721LLU; // continue to unroll stack
20192+ label = 1737LLU; // continue to unroll stack
2005720193 break;
2005820194 }
20059- case 1723LLU: // try next case
20195+ case 1739LLU: // try next case
2006020196 {
2006120197 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2006220198 exit(-1);
2006320199 }
20064- case 1722LLU: // completed switch
20200+ case 1738LLU: // completed switch
2006520201 {
2006620202 printf("%s", "\n break;");
2006720203 printf("%s", "\n }");
@@ -20071,13 +20207,13 @@
2007120207 base = stack[base - 2];
2007220208 break;
2007320209 }
20074- case 1728LLU: // function ProcCall failed
20210+ case 1744LLU: // function ProcCall failed
2007520211 {
2007620212 label = stack[base - 3];
2007720213 base = stack[base - 2];
2007820214 break;
2007920215 }
20080- case 1727LLU: // ProcCall
20216+ case 1743LLU: // ProcCall
2008120217 {
2008220218 //#define arg0 0
2008320219 //#define arg1 1
@@ -20097,43 +20233,43 @@
2009720233 //#define arg15 15
2009820234 //#define arg16 16
2009920235 //#define arg17 17
20100- label = 1730LLU; // skip deleter
20236+ label = 1746LLU; // skip deleter
2010120237 break;
2010220238 }
20103- case 1729LLU: // deleter
20239+ case 1745LLU: // deleter
2010420240 {
2010520241 // throw from ProcCall
2010620242 if(!stack[base + 18])
2010720243 {
20108- label = 1728LLU; // skip, variable already deleted/unscoped
20244+ label = 1744LLU; // skip, variable already deleted/unscoped
2010920245 break;
2011020246 }
20111- label = 1728LLU; // continue unrolling stack, delete next variable
20247+ label = 1744LLU; // continue unrolling stack, delete next variable
2011220248 break;
2011320249 }
20114- case 1730LLU: // skipped deleter
20250+ case 1746LLU: // skipped deleter
2011520251 {
2011620252 stack[base + 18] = 0;
20117- label = 1732LLU; // skip deleter
20253+ label = 1748LLU; // skip deleter
2011820254 break;
2011920255 }
20120- case 1731LLU: // deleter
20256+ case 1747LLU: // deleter
2012120257 {
2012220258 // throw from ProcCall
2012320259 if(!stack[base + 19])
2012420260 {
20125- label = 1729LLU; // skip, variable already deleted/unscoped
20261+ label = 1745LLU; // skip, variable already deleted/unscoped
2012620262 break;
2012720263 }
2012820264 // delete list
20129- label = 1733LLU; // start to repeat
20265+ label = 1749LLU; // start to repeat
2013020266 break;
2013120267 }
20132- case 1733LLU: // repeat from here
20268+ case 1749LLU: // repeat from here
2013320269 {
2013420270 if(!stack[base + 19])
2013520271 {
20136- label = 1734LLU; // break loop
20272+ label = 1750LLU; // break loop
2013720273 break;
2013820274 }
2013920275
@@ -20144,7 +20280,7 @@
2014420280 newstack[0] = (uint64_t)stack; // backup stack location
2014520281 newstack[1] = 1234567890;
2014620282 newstack[2] = base;
20147- newstack[3] = 1735LLU;
20283+ newstack[3] = 1751LLU;
2014820284 stack = newstack;
2014920285 // set stack-base & callee-address
2015020286 base = 4/*deloffset*/;
@@ -20151,7 +20287,7 @@
2015120287 label = 833LLU; // ~idnr
2015220288 break;
2015320289 }
20154- case 1735LLU: // return from ~idnr to ProcCall
20290+ case 1751LLU: // return from ~idnr to ProcCall
2015520291 {
2015620292 stack = (uint64_t *)stack[0];
2015720293 // releasing toplevel container
@@ -20162,20 +20298,20 @@
2016220298 stack[base + 19] = (uint64_t)list->next;
2016320299 Free(1, sizeof(struct listnode), list);
2016420300 }
20165- label = 1733LLU; // repeat
20301+ label = 1749LLU; // repeat
2016620302 break;
2016720303 }
20168- case 1734LLU: // loop finished
20304+ case 1750LLU: // loop finished
2016920305 {
20170- label = 1729LLU; // continue unrolling stack, delete next variable
20306+ label = 1745LLU; // continue unrolling stack, delete next variable
2017120307 break;
2017220308 }
20173- case 1732LLU: // skipped deleter
20309+ case 1748LLU: // skipped deleter
2017420310 {
2017520311 stack[base + 19] = 0;
2017620312 if(/*fndef*/0 != ((uint64_t *)(stack[base + 13]/*calleedef*/))[0])
2017720313 {
20178- label = 1737LLU; // jump to alternative
20314+ label = 1753LLU; // jump to alternative
2017920315 break;
2018020316 }
2018120317
@@ -20191,19 +20327,19 @@
2019120327 // case
2019220328 if(!stack[base + 6]/*fncanthrow*/)
2019320329 {
20194- label = 1739LLU; // jump to alternative
20330+ label = 1755LLU; // jump to alternative
2019520331 break;
2019620332 }
2019720333
2019820334 // consequent
20199- label = 1740LLU; // consequent complete
20335+ label = 1756LLU; // consequent complete
2020020336 break;
2020120337 }
20202- case 1739LLU: // alternative
20338+ case 1755LLU: // alternative
2020320339 {
2020420340 if(!stack[base + 26]/*cecanthrow*/)
2020520341 {
20206- label = 1741LLU; // jump to alternative
20342+ label = 1757LLU; // jump to alternative
2020720343 break;
2020820344 }
2020920345
@@ -20210,9 +20346,9 @@
2021020346 // consequent
2021120347 fprintf(stderr, "%s", "in function ");
2021220348 // call reportid from ProcCall
20213- stack[base + 28LLU] = 1743LLU/*throw to this address*/;
20349+ stack[base + 28LLU] = 1759LLU/*throw to this address*/;
2021420350 stack[base + 29LLU] = base;
20215- stack[base + 30LLU] = 1744LLU;
20351+ stack[base + 30LLU] = 1760LLU;
2021620352 // arguments for call to reportid
2021720353 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2021820354 // set stack-base & callee-address
@@ -20220,20 +20356,20 @@
2022020356 label = 18446744073709551586LLU; // reportid
2022120357 break;
2022220358 }
20223- case 1743LLU: // copy-back deleter (reportid to ProcCall)
20359+ case 1759LLU: // copy-back deleter (reportid to ProcCall)
2022420360 {
2022520361 // copy mutable arguments back from call to reportid
20226- label = 1738LLU; // continue to roll stack
20362+ label = 1754LLU; // continue to roll stack
2022720363 break;
2022820364 }
20229- case 1744LLU: // return from reportid to ProcCall
20365+ case 1760LLU: // return from reportid to ProcCall
2023020366 {
2023120367 // copy mutable arguments back from call to reportid
2023220368 fprintf(stderr, "%s", ": call to function ");
2023320369 // call reportid from ProcCall
20234- stack[base + 28LLU] = 1745LLU/*throw to this address*/;
20370+ stack[base + 28LLU] = 1761LLU/*throw to this address*/;
2023520371 stack[base + 29LLU] = base;
20236- stack[base + 30LLU] = 1746LLU;
20372+ stack[base + 30LLU] = 1762LLU;
2023720373 // arguments for call to reportid
2023820374 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2023920375 // set stack-base & callee-address
@@ -20241,51 +20377,51 @@
2024120377 label = 18446744073709551586LLU; // reportid
2024220378 break;
2024320379 }
20244- case 1745LLU: // copy-back deleter (reportid to ProcCall)
20380+ case 1761LLU: // copy-back deleter (reportid to ProcCall)
2024520381 {
2024620382 // copy mutable arguments back from call to reportid
20247- label = 1738LLU; // continue to roll stack
20383+ label = 1754LLU; // continue to roll stack
2024820384 break;
2024920385 }
20250- case 1746LLU: // return from reportid to ProcCall
20386+ case 1762LLU: // return from reportid to ProcCall
2025120387 {
2025220388 // copy mutable arguments back from call to reportid
2025320389 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2025420390 {
20255- label = 1738LLU; // throw: begin to unroll stack
20391+ label = 1754LLU; // throw: begin to unroll stack
2025620392 break;
2025720393 }
2025820394
20259- label = 1742LLU; // consequent complete
20395+ label = 1758LLU; // consequent complete
2026020396 break;
2026120397 }
20262- case 1741LLU: // alternative
20398+ case 1757LLU: // alternative
2026320399 {
20264- label = 1742LLU; // alternative complete
20400+ label = 1758LLU; // alternative complete
2026520401 break;
2026620402 }
20267- case 1742LLU: // completed if-then-else
20403+ case 1758LLU: // completed if-then-else
2026820404 {
20269- label = 1740LLU; // alternative complete
20405+ label = 1756LLU; // alternative complete
2027020406 break;
2027120407 }
20272- case 1740LLU: // completed if-then-else
20408+ case 1756LLU: // completed if-then-else
2027320409 {
2027420410 if(!stack[base + 7]/*fnIO*/)
2027520411 {
20276- label = 1747LLU; // jump to alternative
20412+ label = 1763LLU; // jump to alternative
2027720413 break;
2027820414 }
2027920415
2028020416 // consequent
20281- label = 1748LLU; // consequent complete
20417+ label = 1764LLU; // consequent complete
2028220418 break;
2028320419 }
20284- case 1747LLU: // alternative
20420+ case 1763LLU: // alternative
2028520421 {
2028620422 if(!stack[base + 27]/*ceIO*/)
2028720423 {
20288- label = 1749LLU; // jump to alternative
20424+ label = 1765LLU; // jump to alternative
2028920425 break;
2029020426 }
2029120427
@@ -20292,9 +20428,9 @@
2029220428 // consequent
2029320429 fprintf(stderr, "%s", "in function ");
2029420430 // call reportid from ProcCall
20295- stack[base + 28LLU] = 1751LLU/*throw to this address*/;
20431+ stack[base + 28LLU] = 1767LLU/*throw to this address*/;
2029620432 stack[base + 29LLU] = base;
20297- stack[base + 30LLU] = 1752LLU;
20433+ stack[base + 30LLU] = 1768LLU;
2029820434 // arguments for call to reportid
2029920435 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2030020436 // set stack-base & callee-address
@@ -20302,20 +20438,20 @@
2030220438 label = 18446744073709551586LLU; // reportid
2030320439 break;
2030420440 }
20305- case 1751LLU: // copy-back deleter (reportid to ProcCall)
20441+ case 1767LLU: // copy-back deleter (reportid to ProcCall)
2030620442 {
2030720443 // copy mutable arguments back from call to reportid
20308- label = 1738LLU; // continue to roll stack
20444+ label = 1754LLU; // continue to roll stack
2030920445 break;
2031020446 }
20311- case 1752LLU: // return from reportid to ProcCall
20447+ case 1768LLU: // return from reportid to ProcCall
2031220448 {
2031320449 // copy mutable arguments back from call to reportid
2031420450 fprintf(stderr, "%s", ": call to IO-function ");
2031520451 // call reportid from ProcCall
20316- stack[base + 28LLU] = 1753LLU/*throw to this address*/;
20452+ stack[base + 28LLU] = 1769LLU/*throw to this address*/;
2031720453 stack[base + 29LLU] = base;
20318- stack[base + 30LLU] = 1754LLU;
20454+ stack[base + 30LLU] = 1770LLU;
2031920455 // arguments for call to reportid
2032020456 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2032120457 // set stack-base & callee-address
@@ -20323,147 +20459,147 @@
2032320459 label = 18446744073709551586LLU; // reportid
2032420460 break;
2032520461 }
20326- case 1753LLU: // copy-back deleter (reportid to ProcCall)
20462+ case 1769LLU: // copy-back deleter (reportid to ProcCall)
2032720463 {
2032820464 // copy mutable arguments back from call to reportid
20329- label = 1738LLU; // continue to roll stack
20465+ label = 1754LLU; // continue to roll stack
2033020466 break;
2033120467 }
20332- case 1754LLU: // return from reportid to ProcCall
20468+ case 1770LLU: // return from reportid to ProcCall
2033320469 {
2033420470 // copy mutable arguments back from call to reportid
2033520471 fprintf(stderr, "%s", " in non-IO environment\n");
2033620472 {
20337- label = 1738LLU; // throw: begin to unroll stack
20473+ label = 1754LLU; // throw: begin to unroll stack
2033820474 break;
2033920475 }
2034020476
20341- label = 1750LLU; // consequent complete
20477+ label = 1766LLU; // consequent complete
2034220478 break;
2034320479 }
20344- case 1749LLU: // alternative
20480+ case 1765LLU: // alternative
2034520481 {
20346- label = 1750LLU; // alternative complete
20482+ label = 1766LLU; // alternative complete
2034720483 break;
2034820484 }
20349- case 1750LLU: // completed if-then-else
20485+ case 1766LLU: // completed if-then-else
2035020486 {
20351- label = 1748LLU; // alternative complete
20487+ label = 1764LLU; // alternative complete
2035220488 break;
2035320489 }
20354- case 1748LLU: // completed if-then-else
20490+ case 1764LLU: // completed if-then-else
2035520491 {
20356- label = 1756LLU; // skip deleter
20492+ label = 1772LLU; // skip deleter
2035720493 break;
2035820494 }
20359- case 1755LLU: // deleter
20495+ case 1771LLU: // deleter
2036020496 {
2036120497 // throw from ProcCall
2036220498 if(!stack[base + 28])
2036320499 {
20364- label = 1738LLU; // skip, variable already deleted/unscoped
20500+ label = 1754LLU; // skip, variable already deleted/unscoped
2036520501 break;
2036620502 }
20367- label = 1738LLU; // continue unrolling stack, delete next variable
20503+ label = 1754LLU; // continue unrolling stack, delete next variable
2036820504 break;
2036920505 }
20370- case 1756LLU: // skipped deleter
20506+ case 1772LLU: // skipped deleter
2037120507 {
2037220508 stack[base + 28] = list_size(((struct listnode *)(stack[base + 21]/*cerestypes*/)));
20373- label = 1758LLU; // skip deleter
20509+ label = 1774LLU; // skip deleter
2037420510 break;
2037520511 }
20376- case 1757LLU: // deleter
20512+ case 1773LLU: // deleter
2037720513 {
2037820514 // throw from ProcCall
2037920515 if(!stack[base + 29])
2038020516 {
20381- label = 1755LLU; // skip, variable already deleted/unscoped
20517+ label = 1771LLU; // skip, variable already deleted/unscoped
2038220518 break;
2038320519 }
20384- label = 1755LLU; // continue unrolling stack, delete next variable
20520+ label = 1771LLU; // continue unrolling stack, delete next variable
2038520521 break;
2038620522 }
20387- case 1758LLU: // skipped deleter
20523+ case 1774LLU: // skipped deleter
2038820524 {
2038920525 stack[base + 29] = list_size(((struct listnode *)(stack[base + 22]/*ceargtypes*/)));
2039020526 if(!stack[base + 20]/*celabel*/)
2039120527 {
20392- label = 1759LLU; // jump to alternative
20528+ label = 1775LLU; // jump to alternative
2039320529 break;
2039420530 }
2039520531
2039620532 // consequent
20397- label = 1760LLU; // consequent complete
20533+ label = 1776LLU; // consequent complete
2039820534 break;
2039920535 }
20400- case 1759LLU: // alternative
20536+ case 1775LLU: // alternative
2040120537 {
2040220538 fprintf(stderr, "%s", " NULL-label!\n");
2040320539 {
20404- label = 1757LLU; // throw: begin to unroll stack
20540+ label = 1773LLU; // throw: begin to unroll stack
2040520541 break;
2040620542 }
2040720543
20408- label = 1760LLU; // alternative complete
20544+ label = 1776LLU; // alternative complete
2040920545 break;
2041020546 }
20411- case 1760LLU: // completed if-then-else
20547+ case 1776LLU: // completed if-then-else
2041220548 {
20413- label = 1762LLU; // skip deleter
20549+ label = 1778LLU; // skip deleter
2041420550 break;
2041520551 }
20416- case 1761LLU: // deleter
20552+ case 1777LLU: // deleter
2041720553 {
2041820554 // throw from ProcCall
2041920555 if(!stack[base + 30])
2042020556 {
20421- label = 1757LLU; // skip, variable already deleted/unscoped
20557+ label = 1773LLU; // skip, variable already deleted/unscoped
2042220558 break;
2042320559 }
20424- label = 1757LLU; // continue unrolling stack, delete next variable
20560+ label = 1773LLU; // continue unrolling stack, delete next variable
2042520561 break;
2042620562 }
20427- case 1762LLU: // skipped deleter
20563+ case 1778LLU: // skipped deleter
2042820564 {
2042920565 stack[base + 30] = 0;
20430- label = 1764LLU; // skip deleter
20566+ label = 1780LLU; // skip deleter
2043120567 break;
2043220568 }
20433- case 1763LLU: // deleter
20569+ case 1779LLU: // deleter
2043420570 {
2043520571 // throw from ProcCall
2043620572 if(!stack[base + 31])
2043720573 {
20438- label = 1761LLU; // skip, variable already deleted/unscoped
20574+ label = 1777LLU; // skip, variable already deleted/unscoped
2043920575 break;
2044020576 }
20441- label = 1761LLU; // continue unrolling stack, delete next variable
20577+ label = 1777LLU; // continue unrolling stack, delete next variable
2044220578 break;
2044320579 }
20444- case 1764LLU: // skipped deleter
20580+ case 1780LLU: // skipped deleter
2044520581 {
2044620582 stack[base + 31] = 0;
20447- label = 1766LLU; // skip deleter
20583+ label = 1782LLU; // skip deleter
2044820584 break;
2044920585 }
20450- case 1765LLU: // deleter
20586+ case 1781LLU: // deleter
2045120587 {
2045220588 // throw from ProcCall
2045320589 if(!stack[base + 32])
2045420590 {
20455- label = 1763LLU; // skip, variable already deleted/unscoped
20591+ label = 1779LLU; // skip, variable already deleted/unscoped
2045620592 break;
2045720593 }
20458- label = 1763LLU; // continue unrolling stack, delete next variable
20594+ label = 1779LLU; // continue unrolling stack, delete next variable
2045920595 break;
2046020596 }
20461- case 1766LLU: // skipped deleter
20597+ case 1782LLU: // skipped deleter
2046220598 {
2046320599 stack[base + 32] = 0;
2046420600 if(!stack[base + 25]/*cerec*/)
2046520601 {
20466- label = 1767LLU; // jump to alternative
20602+ label = 1783LLU; // jump to alternative
2046720603 break;
2046820604 }
2046920605
@@ -20470,21 +20606,21 @@
2047020606 // consequent
2047120607 if(!stack[base + 6]/*fncanthrow*/)
2047220608 {
20473- label = 1769LLU; // jump to alternative
20609+ label = 1785LLU; // jump to alternative
2047420610 break;
2047520611 }
2047620612
2047720613 // consequent
20478- label = 1770LLU; // consequent complete
20614+ label = 1786LLU; // consequent complete
2047920615 break;
2048020616 }
20481- case 1769LLU: // alternative
20617+ case 1785LLU: // alternative
2048220618 {
2048320619 fprintf(stderr, "%s", "in function ");
2048420620 // call reportid from ProcCall
20485- stack[base + 33LLU] = 1771LLU/*throw to this address*/;
20621+ stack[base + 33LLU] = 1787LLU/*throw to this address*/;
2048620622 stack[base + 34LLU] = base;
20487- stack[base + 35LLU] = 1772LLU;
20623+ stack[base + 35LLU] = 1788LLU;
2048820624 // arguments for call to reportid
2048920625 stack[base + 36LLU] = stack[base + 8]/*fnid*/;
2049020626 // set stack-base & callee-address
@@ -20492,20 +20628,20 @@
2049220628 label = 18446744073709551586LLU; // reportid
2049320629 break;
2049420630 }
20495- case 1771LLU: // copy-back deleter (reportid to ProcCall)
20631+ case 1787LLU: // copy-back deleter (reportid to ProcCall)
2049620632 {
2049720633 // copy mutable arguments back from call to reportid
20498- label = 1765LLU; // continue to roll stack
20634+ label = 1781LLU; // continue to roll stack
2049920635 break;
2050020636 }
20501- case 1772LLU: // return from reportid to ProcCall
20637+ case 1788LLU: // return from reportid to ProcCall
2050220638 {
2050320639 // copy mutable arguments back from call to reportid
2050420640 fprintf(stderr, "%s", ": call to recursive function ");
2050520641 // call reportid from ProcCall
20506- stack[base + 33LLU] = 1773LLU/*throw to this address*/;
20642+ stack[base + 33LLU] = 1789LLU/*throw to this address*/;
2050720643 stack[base + 34LLU] = base;
20508- stack[base + 35LLU] = 1774LLU;
20644+ stack[base + 35LLU] = 1790LLU;
2050920645 // arguments for call to reportid
2051020646 stack[base + 36LLU] = stack[base + 24]/*ceid*/;
2051120647 // set stack-base & callee-address
@@ -20513,30 +20649,30 @@
2051320649 label = 18446744073709551586LLU; // reportid
2051420650 break;
2051520651 }
20516- case 1773LLU: // copy-back deleter (reportid to ProcCall)
20652+ case 1789LLU: // copy-back deleter (reportid to ProcCall)
2051720653 {
2051820654 // copy mutable arguments back from call to reportid
20519- label = 1765LLU; // continue to roll stack
20655+ label = 1781LLU; // continue to roll stack
2052020656 break;
2052120657 }
20522- case 1774LLU: // return from reportid to ProcCall
20658+ case 1790LLU: // return from reportid to ProcCall
2052320659 {
2052420660 // copy mutable arguments back from call to reportid
2052520661 fprintf(stderr, "%s", " in no-throw environment\n");
2052620662 {
20527- label = 1765LLU; // throw: begin to unroll stack
20663+ label = 1781LLU; // throw: begin to unroll stack
2052820664 break;
2052920665 }
2053020666
20531- label = 1770LLU; // alternative complete
20667+ label = 1786LLU; // alternative complete
2053220668 break;
2053320669 }
20534- case 1770LLU: // completed if-then-else
20670+ case 1786LLU: // completed if-then-else
2053520671 {
2053620672 // call add from ProcCall
20537- stack[base + 33LLU] = 1775LLU/*throw to this address*/;
20673+ stack[base + 33LLU] = 1791LLU/*throw to this address*/;
2053820674 stack[base + 34LLU] = base;
20539- stack[base + 35LLU] = 1776LLU;
20675+ stack[base + 35LLU] = 1792LLU;
2054020676 // arguments for call to add
2054120677 stack[base + 37LLU] = 1LLU;
2054220678 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -20545,56 +20681,56 @@
2054520681 label = 18446744073709551605LLU; // add
2054620682 break;
2054720683 }
20548- case 1775LLU: // copy-back deleter (add to ProcCall)
20684+ case 1791LLU: // copy-back deleter (add to ProcCall)
2054920685 {
2055020686 // copy mutable arguments back from call to add
20551- label = 1765LLU; // continue to roll stack
20687+ label = 1781LLU; // continue to roll stack
2055220688 break;
2055320689 }
20554- case 1776LLU: // return from add to ProcCall
20690+ case 1792LLU: // return from add to ProcCall
2055520691 {
2055620692 // copy mutable arguments back from call to add
2055720693 // copy back results provided by call to add
2055820694 stack[base + 17] = stack[base + 36LLU];
20559- label = 1778LLU; // skip deleter
20695+ label = 1794LLU; // skip deleter
2056020696 break;
2056120697 }
20562- case 1777LLU: // deleter
20698+ case 1793LLU: // deleter
2056320699 {
2056420700 // throw from ProcCall
2056520701 if(!stack[base + 33])
2056620702 {
20567- label = 1765LLU; // skip, variable already deleted/unscoped
20703+ label = 1781LLU; // skip, variable already deleted/unscoped
2056820704 break;
2056920705 }
20570- label = 1765LLU; // continue unrolling stack, delete next variable
20706+ label = 1781LLU; // continue unrolling stack, delete next variable
2057120707 break;
2057220708 }
20573- case 1778LLU: // skipped deleter
20709+ case 1794LLU: // skipped deleter
2057420710 {
2057520711 stack[base + 33] = stack[base + 17]/*label*/;
20576- label = 1780LLU; // skip deleter
20712+ label = 1796LLU; // skip deleter
2057720713 break;
2057820714 }
20579- case 1779LLU: // deleter
20715+ case 1795LLU: // deleter
2058020716 {
2058120717 // throw from ProcCall
2058220718 if(!stack[base + 34])
2058320719 {
20584- label = 1777LLU; // skip, variable already deleted/unscoped
20720+ label = 1793LLU; // skip, variable already deleted/unscoped
2058520721 break;
2058620722 }
20587- label = 1777LLU; // continue unrolling stack, delete next variable
20723+ label = 1793LLU; // continue unrolling stack, delete next variable
2058820724 break;
2058920725 }
20590- case 1780LLU: // skipped deleter
20726+ case 1796LLU: // skipped deleter
2059120727 {
2059220728 stack[base + 34] = 0;
2059320729 stack[base + 34]/*recsztotal*/ = 0;
2059420730 // call add from ProcCall
20595- stack[base + 35LLU] = 1781LLU/*throw to this address*/;
20731+ stack[base + 35LLU] = 1797LLU/*throw to this address*/;
2059620732 stack[base + 36LLU] = base;
20597- stack[base + 37LLU] = 1782LLU;
20733+ stack[base + 37LLU] = 1798LLU;
2059820734 // arguments for call to add
2059920735 stack[base + 39LLU] = 4LLU;
2060020736 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20603,21 +20739,21 @@
2060320739 label = 18446744073709551605LLU; // add
2060420740 break;
2060520741 }
20606- case 1781LLU: // copy-back deleter (add to ProcCall)
20742+ case 1797LLU: // copy-back deleter (add to ProcCall)
2060720743 {
2060820744 // copy mutable arguments back from call to add
20609- label = 1779LLU; // continue to roll stack
20745+ label = 1795LLU; // continue to roll stack
2061020746 break;
2061120747 }
20612- case 1782LLU: // return from add to ProcCall
20748+ case 1798LLU: // return from add to ProcCall
2061320749 {
2061420750 // copy mutable arguments back from call to add
2061520751 // copy back results provided by call to add
2061620752 stack[base + 34] = stack[base + 38LLU];
2061720753 // call add from ProcCall
20618- stack[base + 35LLU] = 1783LLU/*throw to this address*/;
20754+ stack[base + 35LLU] = 1799LLU/*throw to this address*/;
2061920755 stack[base + 36LLU] = base;
20620- stack[base + 37LLU] = 1784LLU;
20756+ stack[base + 37LLU] = 1800LLU;
2062120757 // arguments for call to add
2062220758 stack[base + 39LLU] = stack[base + 28]/*cerescount*/;
2062320759 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20626,21 +20762,21 @@
2062620762 label = 18446744073709551605LLU; // add
2062720763 break;
2062820764 }
20629- case 1783LLU: // copy-back deleter (add to ProcCall)
20765+ case 1799LLU: // copy-back deleter (add to ProcCall)
2063020766 {
2063120767 // copy mutable arguments back from call to add
20632- label = 1779LLU; // continue to roll stack
20768+ label = 1795LLU; // continue to roll stack
2063320769 break;
2063420770 }
20635- case 1784LLU: // return from add to ProcCall
20771+ case 1800LLU: // return from add to ProcCall
2063620772 {
2063720773 // copy mutable arguments back from call to add
2063820774 // copy back results provided by call to add
2063920775 stack[base + 34] = stack[base + 38LLU];
2064020776 // call add from ProcCall
20641- stack[base + 35LLU] = 1785LLU/*throw to this address*/;
20777+ stack[base + 35LLU] = 1801LLU/*throw to this address*/;
2064220778 stack[base + 36LLU] = base;
20643- stack[base + 37LLU] = 1786LLU;
20779+ stack[base + 37LLU] = 1802LLU;
2064420780 // arguments for call to add
2064520781 stack[base + 39LLU] = stack[base + 29]/*ceargcount*/;
2064620782 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20649,21 +20785,21 @@
2064920785 label = 18446744073709551605LLU; // add
2065020786 break;
2065120787 }
20652- case 1785LLU: // copy-back deleter (add to ProcCall)
20788+ case 1801LLU: // copy-back deleter (add to ProcCall)
2065320789 {
2065420790 // copy mutable arguments back from call to add
20655- label = 1779LLU; // continue to roll stack
20791+ label = 1795LLU; // continue to roll stack
2065620792 break;
2065720793 }
20658- case 1786LLU: // return from add to ProcCall
20794+ case 1802LLU: // return from add to ProcCall
2065920795 {
2066020796 // copy mutable arguments back from call to add
2066120797 // copy back results provided by call to add
2066220798 stack[base + 34] = stack[base + 38LLU];
2066320799 // call add from ProcCall
20664- stack[base + 35LLU] = 1787LLU/*throw to this address*/;
20800+ stack[base + 35LLU] = 1803LLU/*throw to this address*/;
2066520801 stack[base + 36LLU] = base;
20666- stack[base + 37LLU] = 1788LLU;
20802+ stack[base + 37LLU] = 1804LLU;
2066720803 // arguments for call to add
2066820804 stack[base + 39LLU] = stack[base + 23]/*cemaxcount*/;
2066920805 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20672,13 +20808,13 @@
2067220808 label = 18446744073709551605LLU; // add
2067320809 break;
2067420810 }
20675- case 1787LLU: // copy-back deleter (add to ProcCall)
20811+ case 1803LLU: // copy-back deleter (add to ProcCall)
2067620812 {
2067720813 // copy mutable arguments back from call to add
20678- label = 1779LLU; // continue to roll stack
20814+ label = 1795LLU; // continue to roll stack
2067920815 break;
2068020816 }
20681- case 1788LLU: // return from add to ProcCall
20817+ case 1804LLU: // return from add to ProcCall
2068220818 {
2068320819 // copy mutable arguments back from call to add
2068420820 // copy back results provided by call to add
@@ -20685,9 +20821,9 @@
2068520821 stack[base + 34] = stack[base + 38LLU];
2068620822 printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
2068720823 // call printnr from ProcCall
20688- stack[base + 35LLU] = 1789LLU/*throw to this address*/;
20824+ stack[base + 35LLU] = 1805LLU/*throw to this address*/;
2068920825 stack[base + 36LLU] = base;
20690- stack[base + 37LLU] = 1790LLU;
20826+ stack[base + 37LLU] = 1806LLU;
2069120827 // arguments for call to printnr
2069220828 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2069320829 // set stack-base & callee-address
@@ -20695,42 +20831,42 @@
2069520831 label = 18446744073709551590LLU; // printnr
2069620832 break;
2069720833 }
20698- case 1789LLU: // copy-back deleter (printnr to ProcCall)
20834+ case 1805LLU: // copy-back deleter (printnr to ProcCall)
2069920835 {
2070020836 // copy mutable arguments back from call to printnr
20701- label = 1779LLU; // continue to roll stack
20837+ label = 1795LLU; // continue to roll stack
2070220838 break;
2070320839 }
20704- case 1790LLU: // return from printnr to ProcCall
20840+ case 1806LLU: // return from printnr to ProcCall
2070520841 {
2070620842 // copy mutable arguments back from call to printnr
2070720843 printf("%s", "LLU + 1, sizeof(uint64_t));");
2070820844 printf("%s", "\n if(!newstack)");
2070920845 // call emitthrow from ProcCall
20710- stack[base + 35LLU] = 1791LLU/*throw to this address*/;
20846+ stack[base + 35LLU] = 1807LLU/*throw to this address*/;
2071120847 stack[base + 36LLU] = base;
20712- stack[base + 37LLU] = 1792LLU;
20848+ stack[base + 37LLU] = 1808LLU;
2071320849 // arguments for call to emitthrow
2071420850 stack[base + 38LLU] = stack[base + 3]/*scope*/;
2071520851 // set stack-base & callee-address
2071620852 base += 38LLU;
20717- label = 1720LLU; // emitthrow
20853+ label = 1736LLU; // emitthrow
2071820854 break;
2071920855 }
20720- case 1791LLU: // copy-back deleter (emitthrow to ProcCall)
20856+ case 1807LLU: // copy-back deleter (emitthrow to ProcCall)
2072120857 {
2072220858 // copy mutable arguments back from call to emitthrow
20723- label = 1779LLU; // continue to roll stack
20859+ label = 1795LLU; // continue to roll stack
2072420860 break;
2072520861 }
20726- case 1792LLU: // return from emitthrow to ProcCall
20862+ case 1808LLU: // return from emitthrow to ProcCall
2072720863 {
2072820864 // copy mutable arguments back from call to emitthrow
2072920865 printf("%s", "\n newstack[");
2073020866 // call printnr from ProcCall
20731- stack[base + 35LLU] = 1793LLU/*throw to this address*/;
20867+ stack[base + 35LLU] = 1809LLU/*throw to this address*/;
2073220868 stack[base + 36LLU] = base;
20733- stack[base + 37LLU] = 1794LLU;
20869+ stack[base + 37LLU] = 1810LLU;
2073420870 // arguments for call to printnr
2073520871 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2073620872 // set stack-base & callee-address
@@ -20738,21 +20874,21 @@
2073820874 label = 18446744073709551590LLU; // printnr
2073920875 break;
2074020876 }
20741- case 1793LLU: // copy-back deleter (printnr to ProcCall)
20877+ case 1809LLU: // copy-back deleter (printnr to ProcCall)
2074220878 {
2074320879 // copy mutable arguments back from call to printnr
20744- label = 1779LLU; // continue to roll stack
20880+ label = 1795LLU; // continue to roll stack
2074520881 break;
2074620882 }
20747- case 1794LLU: // return from printnr to ProcCall
20883+ case 1810LLU: // return from printnr to ProcCall
2074820884 {
2074920885 // copy mutable arguments back from call to printnr
2075020886 printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
2075120887 printf("%s", "\n // call ");
2075220888 // call printid from ProcCall
20753- stack[base + 35LLU] = 1795LLU/*throw to this address*/;
20889+ stack[base + 35LLU] = 1811LLU/*throw to this address*/;
2075420890 stack[base + 36LLU] = base;
20755- stack[base + 37LLU] = 1796LLU;
20891+ stack[base + 37LLU] = 1812LLU;
2075620892 // arguments for call to printid
2075720893 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2075820894 // set stack-base & callee-address
@@ -20760,20 +20896,20 @@
2076020896 label = 18446744073709551587LLU; // printid
2076120897 break;
2076220898 }
20763- case 1795LLU: // copy-back deleter (printid to ProcCall)
20899+ case 1811LLU: // copy-back deleter (printid to ProcCall)
2076420900 {
2076520901 // copy mutable arguments back from call to printid
20766- label = 1779LLU; // continue to roll stack
20902+ label = 1795LLU; // continue to roll stack
2076720903 break;
2076820904 }
20769- case 1796LLU: // return from printid to ProcCall
20905+ case 1812LLU: // return from printid to ProcCall
2077020906 {
2077120907 // copy mutable arguments back from call to printid
2077220908 printf("%s", " from ");
2077320909 // call printid from ProcCall
20774- stack[base + 35LLU] = 1797LLU/*throw to this address*/;
20910+ stack[base + 35LLU] = 1813LLU/*throw to this address*/;
2077520911 stack[base + 36LLU] = base;
20776- stack[base + 37LLU] = 1798LLU;
20912+ stack[base + 37LLU] = 1814LLU;
2077720913 // arguments for call to printid
2077820914 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2077920915 // set stack-base & callee-address
@@ -20781,21 +20917,21 @@
2078120917 label = 18446744073709551587LLU; // printid
2078220918 break;
2078320919 }
20784- case 1797LLU: // copy-back deleter (printid to ProcCall)
20920+ case 1813LLU: // copy-back deleter (printid to ProcCall)
2078520921 {
2078620922 // copy mutable arguments back from call to printid
20787- label = 1779LLU; // continue to roll stack
20923+ label = 1795LLU; // continue to roll stack
2078820924 break;
2078920925 }
20790- case 1798LLU: // return from printid to ProcCall
20926+ case 1814LLU: // return from printid to ProcCall
2079120927 {
2079220928 // copy mutable arguments back from call to printid
2079320929 printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
2079420930 printf("%s", "\n newstack[1] = ");
2079520931 // call printnr from ProcCall
20796- stack[base + 35LLU] = 1799LLU/*throw to this address*/;
20932+ stack[base + 35LLU] = 1815LLU/*throw to this address*/;
2079720933 stack[base + 36LLU] = base;
20798- stack[base + 37LLU] = 1800LLU;
20934+ stack[base + 37LLU] = 1816LLU;
2079920935 // arguments for call to printnr
2080020936 stack[base + 38LLU] = stack[base + 33]/*labelfail*/;
2080120937 // set stack-base & callee-address
@@ -20803,21 +20939,21 @@
2080320939 label = 18446744073709551590LLU; // printnr
2080420940 break;
2080520941 }
20806- case 1799LLU: // copy-back deleter (printnr to ProcCall)
20942+ case 1815LLU: // copy-back deleter (printnr to ProcCall)
2080720943 {
2080820944 // copy mutable arguments back from call to printnr
20809- label = 1779LLU; // continue to roll stack
20945+ label = 1795LLU; // continue to roll stack
2081020946 break;
2081120947 }
20812- case 1800LLU: // return from printnr to ProcCall
20948+ case 1816LLU: // return from printnr to ProcCall
2081320949 {
2081420950 // copy mutable arguments back from call to printnr
2081520951 printf("%s", "LLU;");
2081620952 printf("%s", "\n newstack[2] = base;");
2081720953 // call add from ProcCall
20818- stack[base + 35LLU] = 1801LLU/*throw to this address*/;
20954+ stack[base + 35LLU] = 1817LLU/*throw to this address*/;
2081920955 stack[base + 36LLU] = base;
20820- stack[base + 37LLU] = 1802LLU;
20956+ stack[base + 37LLU] = 1818LLU;
2082120957 // arguments for call to add
2082220958 stack[base + 39LLU] = 1LLU;
2082320959 stack[base + 40LLU] = stack[base + 17]/*label*/;
@@ -20826,13 +20962,13 @@
2082620962 label = 18446744073709551605LLU; // add
2082720963 break;
2082820964 }
20829- case 1801LLU: // copy-back deleter (add to ProcCall)
20965+ case 1817LLU: // copy-back deleter (add to ProcCall)
2083020966 {
2083120967 // copy mutable arguments back from call to add
20832- label = 1779LLU; // continue to roll stack
20968+ label = 1795LLU; // continue to roll stack
2083320969 break;
2083420970 }
20835- case 1802LLU: // return from add to ProcCall
20971+ case 1818LLU: // return from add to ProcCall
2083620972 {
2083720973 // copy mutable arguments back from call to add
2083820974 // copy back results provided by call to add
@@ -20839,9 +20975,9 @@
2083920975 stack[base + 17] = stack[base + 38LLU];
2084020976 printf("%s", "\n newstack[3] = ");
2084120977 // call printnr from ProcCall
20842- stack[base + 35LLU] = 1803LLU/*throw to this address*/;
20978+ stack[base + 35LLU] = 1819LLU/*throw to this address*/;
2084320979 stack[base + 36LLU] = base;
20844- stack[base + 37LLU] = 1804LLU;
20980+ stack[base + 37LLU] = 1820LLU;
2084520981 // arguments for call to printnr
2084620982 stack[base + 38LLU] = stack[base + 17]/*label*/;
2084720983 // set stack-base & callee-address
@@ -20849,13 +20985,13 @@
2084920985 label = 18446744073709551590LLU; // printnr
2085020986 break;
2085120987 }
20852- case 1803LLU: // copy-back deleter (printnr to ProcCall)
20988+ case 1819LLU: // copy-back deleter (printnr to ProcCall)
2085320989 {
2085420990 // copy mutable arguments back from call to printnr
20855- label = 1779LLU; // continue to roll stack
20991+ label = 1795LLU; // continue to roll stack
2085620992 break;
2085720993 }
20858- case 1804LLU: // return from printnr to ProcCall
20994+ case 1820LLU: // return from printnr to ProcCall
2085920995 {
2086020996 // copy mutable arguments back from call to printnr
2086120997 printf("%s", "LLU;");
@@ -20862,9 +20998,9 @@
2086220998 stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
2086320999 printf("%s", "\n // arguments for call to ");
2086421000 // call printid from ProcCall
20865- stack[base + 35LLU] = 1805LLU/*throw to this address*/;
21001+ stack[base + 35LLU] = 1821LLU/*throw to this address*/;
2086621002 stack[base + 36LLU] = base;
20867- stack[base + 37LLU] = 1806LLU;
21003+ stack[base + 37LLU] = 1822LLU;
2086821004 // arguments for call to printid
2086921005 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2087021006 // set stack-base & callee-address
@@ -20872,41 +21008,41 @@
2087221008 label = 18446744073709551587LLU; // printid
2087321009 break;
2087421010 }
20875- case 1805LLU: // copy-back deleter (printid to ProcCall)
21011+ case 1821LLU: // copy-back deleter (printid to ProcCall)
2087621012 {
2087721013 // copy mutable arguments back from call to printid
20878- label = 1779LLU; // continue to roll stack
21014+ label = 1795LLU; // continue to roll stack
2087921015 break;
2088021016 }
20881- case 1806LLU: // return from printid to ProcCall
21017+ case 1822LLU: // return from printid to ProcCall
2088221018 {
2088321019 // copy mutable arguments back from call to printid
20884- label = 1808LLU; // skip deleter
21020+ label = 1824LLU; // skip deleter
2088521021 break;
2088621022 }
20887- case 1807LLU: // deleter
21023+ case 1823LLU: // deleter
2088821024 {
2088921025 // throw from ProcCall
2089021026 if(!stack[base + 35])
2089121027 {
20892- label = 1779LLU; // skip, variable already deleted/unscoped
21028+ label = 1795LLU; // skip, variable already deleted/unscoped
2089321029 break;
2089421030 }
20895- label = 1779LLU; // continue unrolling stack, delete next variable
21031+ label = 1795LLU; // continue unrolling stack, delete next variable
2089621032 break;
2089721033 }
20898- case 1808LLU: // skipped deleter
21034+ case 1824LLU: // skipped deleter
2089921035 {
2090021036 stack[base + 35] = 0;
2090121037 flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 36]);
20902- label = 1809LLU; // start to repeat
21038+ label = 1825LLU; // start to repeat
2090321039 break;
2090421040 }
20905- case 1809LLU: // repeat from here
21041+ case 1825LLU: // repeat from here
2090621042 {
2090721043 if(!stack[base + 36])
2090821044 {
20909- label = 1810LLU; // break loop
21045+ label = 1826LLU; // break loop
2091021046 break;
2091121047 }
2091221048
@@ -20915,9 +21051,9 @@
2091521051 stack[base + 38]/*previous*/ = stack[base + 36];
2091621052 stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
2091721053 // call sub from ProcCall
20918- stack[base + 39LLU] = 1812LLU/*throw to this address*/;
21054+ stack[base + 39LLU] = 1828LLU/*throw to this address*/;
2091921055 stack[base + 40LLU] = base;
20920- stack[base + 41LLU] = 1813LLU;
21056+ stack[base + 41LLU] = 1829LLU;
2092121057 // arguments for call to sub
2092221058 stack[base + 43LLU] = stack[base + 29]/*ceargcount*/;
2092321059 stack[base + 44LLU] = stack[base + 31]/*n*/;
@@ -20926,21 +21062,21 @@
2092621062 label = 18446744073709551604LLU; // sub
2092721063 break;
2092821064 }
20929- case 1812LLU: // copy-back deleter (sub to ProcCall)
21065+ case 1828LLU: // copy-back deleter (sub to ProcCall)
2093021066 {
2093121067 // copy mutable arguments back from call to sub
20932- label = 1811LLU; // continue to roll stack
21068+ label = 1827LLU; // continue to roll stack
2093321069 break;
2093421070 }
20935- case 1813LLU: // return from sub to ProcCall
21071+ case 1829LLU: // return from sub to ProcCall
2093621072 {
2093721073 // copy mutable arguments back from call to sub
2093821074 // copy back results provided by call to sub
2093921075 stack[base + 32] = stack[base + 42LLU];
2094021076 // call sub from ProcCall
20941- stack[base + 39LLU] = 1814LLU/*throw to this address*/;
21077+ stack[base + 39LLU] = 1830LLU/*throw to this address*/;
2094221078 stack[base + 40LLU] = base;
20943- stack[base + 41LLU] = 1815LLU;
21079+ stack[base + 41LLU] = 1831LLU;
2094421080 // arguments for call to sub
2094521081 stack[base + 43LLU] = stack[base + 31]/*n*/;
2094621082 stack[base + 44LLU] = 1LLU;
@@ -20949,13 +21085,13 @@
2094921085 label = 18446744073709551604LLU; // sub
2095021086 break;
2095121087 }
20952- case 1814LLU: // copy-back deleter (sub to ProcCall)
21088+ case 1830LLU: // copy-back deleter (sub to ProcCall)
2095321089 {
2095421090 // copy mutable arguments back from call to sub
20955- label = 1811LLU; // continue to roll stack
21091+ label = 1827LLU; // continue to roll stack
2095621092 break;
2095721093 }
20958- case 1815LLU: // return from sub to ProcCall
21094+ case 1831LLU: // return from sub to ProcCall
2095921095 {
2096021096 // copy mutable arguments back from call to sub
2096121097 // copy back results provided by call to sub
@@ -20962,15 +21098,15 @@
2096221098 stack[base + 31] = stack[base + 42LLU];
2096321099 if(!stack[base + 32]/*index*/)
2096421100 {
20965- label = 1816LLU; // jump to alternative
21101+ label = 1832LLU; // jump to alternative
2096621102 break;
2096721103 }
2096821104
2096921105 // consequent
2097021106 // call matchsym from ProcCall
20971- stack[base + 39LLU] = 1818LLU/*throw to this address*/;
21107+ stack[base + 39LLU] = 1834LLU/*throw to this address*/;
2097221108 stack[base + 40LLU] = base;
20973- stack[base + 41LLU] = 1819LLU;
21109+ stack[base + 41LLU] = 1835LLU;
2097421110 // arguments for call to matchsym
2097521111 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2097621112 stack[base + 43LLU] = 44LLU;
@@ -20980,32 +21116,32 @@
2098021116 label = 246LLU; // matchsym
2098121117 break;
2098221118 }
20983- case 1818LLU: // copy-back deleter (matchsym to ProcCall)
21119+ case 1834LLU: // copy-back deleter (matchsym to ProcCall)
2098421120 {
2098521121 // copy mutable arguments back from call to matchsym
2098621122 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
20987- label = 1811LLU; // continue to roll stack
21123+ label = 1827LLU; // continue to roll stack
2098821124 break;
2098921125 }
20990- case 1819LLU: // return from matchsym to ProcCall
21126+ case 1835LLU: // return from matchsym to ProcCall
2099121127 {
2099221128 // copy mutable arguments back from call to matchsym
2099321129 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
20994- label = 1817LLU; // consequent complete
21130+ label = 1833LLU; // consequent complete
2099521131 break;
2099621132 }
20997- case 1816LLU: // alternative
21133+ case 1832LLU: // alternative
2099821134 {
20999- label = 1817LLU; // alternative complete
21135+ label = 1833LLU; // alternative complete
2100021136 break;
2100121137 }
21002- case 1817LLU: // completed if-then-else
21138+ case 1833LLU: // completed if-then-else
2100321139 {
2100421140 stack[base + 30]/*sum*/ = 0;
2100521141 // call add from ProcCall
21006- stack[base + 39LLU] = 1820LLU/*throw to this address*/;
21142+ stack[base + 39LLU] = 1836LLU/*throw to this address*/;
2100721143 stack[base + 40LLU] = base;
21008- stack[base + 41LLU] = 1821LLU;
21144+ stack[base + 41LLU] = 1837LLU;
2100921145 // arguments for call to add
2101021146 stack[base + 43LLU] = 4LLU;
2101121147 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21014,21 +21150,21 @@
2101421150 label = 18446744073709551605LLU; // add
2101521151 break;
2101621152 }
21017- case 1820LLU: // copy-back deleter (add to ProcCall)
21153+ case 1836LLU: // copy-back deleter (add to ProcCall)
2101821154 {
2101921155 // copy mutable arguments back from call to add
21020- label = 1811LLU; // continue to roll stack
21156+ label = 1827LLU; // continue to roll stack
2102121157 break;
2102221158 }
21023- case 1821LLU: // return from add to ProcCall
21159+ case 1837LLU: // return from add to ProcCall
2102421160 {
2102521161 // copy mutable arguments back from call to add
2102621162 // copy back results provided by call to add
2102721163 stack[base + 30] = stack[base + 42LLU];
2102821164 // call add from ProcCall
21029- stack[base + 39LLU] = 1822LLU/*throw to this address*/;
21165+ stack[base + 39LLU] = 1838LLU/*throw to this address*/;
2103021166 stack[base + 40LLU] = base;
21031- stack[base + 41LLU] = 1823LLU;
21167+ stack[base + 41LLU] = 1839LLU;
2103221168 // arguments for call to add
2103321169 stack[base + 43LLU] = stack[base + 28]/*cerescount*/;
2103421170 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21037,21 +21173,21 @@
2103721173 label = 18446744073709551605LLU; // add
2103821174 break;
2103921175 }
21040- case 1822LLU: // copy-back deleter (add to ProcCall)
21176+ case 1838LLU: // copy-back deleter (add to ProcCall)
2104121177 {
2104221178 // copy mutable arguments back from call to add
21043- label = 1811LLU; // continue to roll stack
21179+ label = 1827LLU; // continue to roll stack
2104421180 break;
2104521181 }
21046- case 1823LLU: // return from add to ProcCall
21182+ case 1839LLU: // return from add to ProcCall
2104721183 {
2104821184 // copy mutable arguments back from call to add
2104921185 // copy back results provided by call to add
2105021186 stack[base + 30] = stack[base + 42LLU];
2105121187 // call add from ProcCall
21052- stack[base + 39LLU] = 1824LLU/*throw to this address*/;
21188+ stack[base + 39LLU] = 1840LLU/*throw to this address*/;
2105321189 stack[base + 40LLU] = base;
21054- stack[base + 41LLU] = 1825LLU;
21190+ stack[base + 41LLU] = 1841LLU;
2105521191 // arguments for call to add
2105621192 stack[base + 43LLU] = stack[base + 32]/*index*/;
2105721193 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -21060,13 +21196,13 @@
2106021196 label = 18446744073709551605LLU; // add
2106121197 break;
2106221198 }
21063- case 1824LLU: // copy-back deleter (add to ProcCall)
21199+ case 1840LLU: // copy-back deleter (add to ProcCall)
2106421200 {
2106521201 // copy mutable arguments back from call to add
21066- label = 1811LLU; // continue to roll stack
21202+ label = 1827LLU; // continue to roll stack
2106721203 break;
2106821204 }
21069- case 1825LLU: // return from add to ProcCall
21205+ case 1841LLU: // return from add to ProcCall
2107021206 {
2107121207 // copy mutable arguments back from call to add
2107221208 // copy back results provided by call to add
@@ -21073,7 +21209,7 @@
2107321209 stack[base + 30] = stack[base + 42LLU];
2107421210 if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0])
2107521211 {
21076- label = 1827LLU; // jump to alternative
21212+ label = 1843LLU; // jump to alternative
2107721213 break;
2107821214 }
2107921215
@@ -21083,7 +21219,7 @@
2108321219 // case
2108421220 if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0])
2108521221 {
21086- label = 1830LLU; // jump to alternative
21222+ label = 1846LLU; // jump to alternative
2108721223 break;
2108821224 }
2108921225
@@ -21092,9 +21228,9 @@
2109221228
2109321229 // case
2109421230 // call ParseToken from ProcCall
21095- stack[base + 43LLU] = 1832LLU/*throw to this address*/;
21231+ stack[base + 43LLU] = 1848LLU/*throw to this address*/;
2109621232 stack[base + 44LLU] = base;
21097- stack[base + 45LLU] = 1833LLU;
21233+ stack[base + 45LLU] = 1849LLU;
2109821234 // arguments for call to ParseToken
2109921235 stack[base + 48LLU] = stack[base + 14]/*lookahead*/;
2110021236 // set stack-base & callee-address
@@ -21102,14 +21238,14 @@
2110221238 label = 3LLU; // ParseToken
2110321239 break;
2110421240 }
21105- case 1832LLU: // copy-back deleter (ParseToken to ProcCall)
21241+ case 1848LLU: // copy-back deleter (ParseToken to ProcCall)
2110621242 {
2110721243 // copy mutable arguments back from call to ParseToken
2110821244 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21109- label = 1831LLU; // continue to roll stack
21245+ label = 1847LLU; // continue to roll stack
2111021246 break;
2111121247 }
21112- case 1833LLU: // return from ParseToken to ProcCall
21248+ case 1849LLU: // return from ParseToken to ProcCall
2111321249 {
2111421250 // copy mutable arguments back from call to ParseToken
2111521251 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
@@ -21117,9 +21253,9 @@
2111721253 stack[base + 15] = stack[base + 46LLU];
2111821254 stack[base + 16] = stack[base + 47LLU];
2111921255 // call isncs from ProcCall
21120- stack[base + 43LLU] = 1834LLU/*throw to this address*/;
21256+ stack[base + 43LLU] = 1850LLU/*throw to this address*/;
2112121257 stack[base + 44LLU] = base;
21122- stack[base + 45LLU] = 1835LLU;
21258+ stack[base + 45LLU] = 1851LLU;
2112321259 // arguments for call to isncs
2112421260 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2112521261 // set stack-base & callee-address
@@ -21127,13 +21263,13 @@
2112721263 label = 286LLU; // isncs
2112821264 break;
2112921265 }
21130- case 1834LLU: // copy-back deleter (isncs to ProcCall)
21266+ case 1850LLU: // copy-back deleter (isncs to ProcCall)
2113121267 {
2113221268 // copy mutable arguments back from call to isncs
21133- label = 1831LLU; // continue to roll stack
21269+ label = 1847LLU; // continue to roll stack
2113421270 break;
2113521271 }
21136- case 1835LLU: // return from isncs to ProcCall
21272+ case 1851LLU: // return from isncs to ProcCall
2113721273 {
2113821274 // copy mutable arguments back from call to isncs
2113921275 // copy back results provided by call to isncs
@@ -21140,20 +21276,20 @@
2114021276 stack[base + 18] = stack[base + 46LLU];
2114121277 if(!stack[base + 18]/*isequal*/)
2114221278 {
21143- label = 1836LLU; // jump to alternative
21279+ label = 1852LLU; // jump to alternative
2114421280 break;
2114521281 }
2114621282
2114721283 // consequent
21148- label = 1839LLU; // skip deleter
21284+ label = 1855LLU; // skip deleter
2114921285 break;
2115021286 }
21151- case 1838LLU: // deleter
21287+ case 1854LLU: // deleter
2115221288 {
2115321289 // throw from ProcCall
2115421290 if(!stack[base + 43])
2115521291 {
21156- label = 1831LLU; // skip, variable already deleted/unscoped
21292+ label = 1847LLU; // skip, variable already deleted/unscoped
2115721293 break;
2115821294 }
2115921295
@@ -21162,7 +21298,7 @@
2116221298 newstack[0] = (uint64_t)stack; // backup stack location
2116321299 newstack[1] = 1234567890;
2116421300 newstack[2] = base;
21165- newstack[3] = 1840LLU;
21301+ newstack[3] = 1856LLU;
2116621302 stack = newstack;
2116721303 // set stack-base & callee-address
2116821304 base = 4/*deloffset*/;
@@ -21169,21 +21305,21 @@
2116921305 label = 310LLU; // ~type
2117021306 break;
2117121307 }
21172- case 1840LLU: // return from ~type to ProcCall
21308+ case 1856LLU: // return from ~type to ProcCall
2117321309 {
2117421310 stack = (uint64_t *)stack[0];
2117521311 // releasing toplevel container
2117621312 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2117721313
21178- label = 1831LLU; // continue unrolling stack, delete next variable
21314+ label = 1847LLU; // continue unrolling stack, delete next variable
2117921315 break;
2118021316 }
21181- case 1839LLU: // skipped deleter
21317+ case 1855LLU: // skipped deleter
2118221318 {
2118321319 // call mktypedata from ProcCall
21184- stack[base + 44LLU] = 1841LLU/*throw to this address*/;
21320+ stack[base + 44LLU] = 1857LLU/*throw to this address*/;
2118521321 stack[base + 45LLU] = base;
21186- stack[base + 46LLU] = 1842LLU;
21322+ stack[base + 46LLU] = 1858LLU;
2118721323 // arguments for call to mktypedata
2118821324 stack[base + 48LLU] = 881834713755418624LLU;
2118921325 // set stack-base & callee-address
@@ -21191,13 +21327,13 @@
2119121327 label = 314LLU; // mktypedata
2119221328 break;
2119321329 }
21194- case 1841LLU: // copy-back deleter (mktypedata to ProcCall)
21330+ case 1857LLU: // copy-back deleter (mktypedata to ProcCall)
2119521331 {
2119621332 // copy mutable arguments back from call to mktypedata
21197- label = 1831LLU; // continue to roll stack
21333+ label = 1847LLU; // continue to roll stack
2119821334 break;
2119921335 }
21200- case 1842LLU: // return from mktypedata to ProcCall
21336+ case 1858LLU: // return from mktypedata to ProcCall
2120121337 {
2120221338 // copy mutable arguments back from call to mktypedata
2120321339 // copy back results provided by call to mktypedata
@@ -21205,7 +21341,7 @@
2120521341 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2120621342 if(!newstack)
2120721343 {
21208- label = 1838LLU; // throw: begin to unroll stack
21344+ label = 1854LLU; // throw: begin to unroll stack
2120921345 break;
2121021346 }
2121121347
@@ -21212,9 +21348,9 @@
2121221348 newstack[15LLU] = 9876543210LLU; // overflow-marker
2121321349 // call equtype from ProcCall
2121421350 newstack[0] = (uint64_t)stack; // backup stack location
21215- newstack[1] = 1843LLU;
21351+ newstack[1] = 1859LLU;
2121621352 newstack[2] = base;
21217- newstack[3] = 1844LLU;
21353+ newstack[3] = 1860LLU;
2121821354 // arguments for call to equtype
2121921355 newstack[5LLU] = stack[base + 43]/*type*/;
2122021356 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -21224,7 +21360,7 @@
2122421360 label = 359LLU; // equtype
2122521361 break;
2122621362 }
21227- case 1843LLU: // copy-back deleter (equtype to ProcCall)
21363+ case 1859LLU: // copy-back deleter (equtype to ProcCall)
2122821364 {
2122921365 uint64_t *oldstack = (uint64_t *)stack[0];
2123021366 // copy mutable arguments back from call to equtype
@@ -21235,10 +21371,10 @@
2123521371 }
2123621372 Free(15LLU + 1, sizeof(uint64_t), stack);
2123721373 stack = oldstack;
21238- label = 1838LLU; // continue to unroll stack
21374+ label = 1854LLU; // continue to unroll stack
2123921375 break;
2124021376 }
21241- case 1844LLU: // return from equtype to ProcCall
21377+ case 1860LLU: // return from equtype to ProcCall
2124221378 {
2124321379 uint64_t *oldstack = (uint64_t *)stack[0];
2124421380 // copy mutable arguments back from call to equtype
@@ -21253,21 +21389,21 @@
2125321389 stack = oldstack;
2125421390 if(!stack[base + 18]/*isequal*/)
2125521391 {
21256- label = 1845LLU; // jump to alternative
21392+ label = 1861LLU; // jump to alternative
2125721393 break;
2125821394 }
2125921395
2126021396 // consequent
21261- label = 1846LLU; // consequent complete
21397+ label = 1862LLU; // consequent complete
2126221398 break;
2126321399 }
21264- case 1845LLU: // alternative
21400+ case 1861LLU: // alternative
2126521401 {
2126621402 fprintf(stderr, "%s", "in function ");
2126721403 // call reportid from ProcCall
21268- stack[base + 44LLU] = 1847LLU/*throw to this address*/;
21404+ stack[base + 44LLU] = 1863LLU/*throw to this address*/;
2126921405 stack[base + 45LLU] = base;
21270- stack[base + 46LLU] = 1848LLU;
21406+ stack[base + 46LLU] = 1864LLU;
2127121407 // arguments for call to reportid
2127221408 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2127321409 // set stack-base & callee-address
@@ -21275,20 +21411,20 @@
2127521411 label = 18446744073709551586LLU; // reportid
2127621412 break;
2127721413 }
21278- case 1847LLU: // copy-back deleter (reportid to ProcCall)
21414+ case 1863LLU: // copy-back deleter (reportid to ProcCall)
2127921415 {
2128021416 // copy mutable arguments back from call to reportid
21281- label = 1838LLU; // continue to roll stack
21417+ label = 1854LLU; // continue to roll stack
2128221418 break;
2128321419 }
21284- case 1848LLU: // return from reportid to ProcCall
21420+ case 1864LLU: // return from reportid to ProcCall
2128521421 {
2128621422 // copy mutable arguments back from call to reportid
2128721423 fprintf(stderr, "%s", " call to ");
2128821424 // call reportid from ProcCall
21289- stack[base + 44LLU] = 1849LLU/*throw to this address*/;
21425+ stack[base + 44LLU] = 1865LLU/*throw to this address*/;
2129021426 stack[base + 45LLU] = base;
21291- stack[base + 46LLU] = 1850LLU;
21427+ stack[base + 46LLU] = 1866LLU;
2129221428 // arguments for call to reportid
2129321429 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2129421430 // set stack-base & callee-address
@@ -21296,20 +21432,20 @@
2129621432 label = 18446744073709551586LLU; // reportid
2129721433 break;
2129821434 }
21299- case 1849LLU: // copy-back deleter (reportid to ProcCall)
21435+ case 1865LLU: // copy-back deleter (reportid to ProcCall)
2130021436 {
2130121437 // copy mutable arguments back from call to reportid
21302- label = 1838LLU; // continue to roll stack
21438+ label = 1854LLU; // continue to roll stack
2130321439 break;
2130421440 }
21305- case 1850LLU: // return from reportid to ProcCall
21441+ case 1866LLU: // return from reportid to ProcCall
2130621442 {
2130721443 // copy mutable arguments back from call to reportid
2130821444 fprintf(stderr, "%s", " at position ");
2130921445 // call reportnr from ProcCall
21310- stack[base + 44LLU] = 1851LLU/*throw to this address*/;
21446+ stack[base + 44LLU] = 1867LLU/*throw to this address*/;
2131121447 stack[base + 45LLU] = base;
21312- stack[base + 46LLU] = 1852LLU;
21448+ stack[base + 46LLU] = 1868LLU;
2131321449 // arguments for call to reportnr
2131421450 stack[base + 47LLU] = stack[base + 32]/*index*/;
2131521451 // set stack-base & callee-address
@@ -21317,13 +21453,13 @@
2131721453 label = 18446744073709551589LLU; // reportnr
2131821454 break;
2131921455 }
21320- case 1851LLU: // copy-back deleter (reportnr to ProcCall)
21456+ case 1867LLU: // copy-back deleter (reportnr to ProcCall)
2132121457 {
2132221458 // copy mutable arguments back from call to reportnr
21323- label = 1838LLU; // continue to roll stack
21459+ label = 1854LLU; // continue to roll stack
2132421460 break;
2132521461 }
21326- case 1852LLU: // return from reportnr to ProcCall
21462+ case 1868LLU: // return from reportnr to ProcCall
2132721463 {
2132821464 // copy mutable arguments back from call to reportnr
2132921465 fprintf(stderr, "%s", " expected parameter of type ");
@@ -21330,7 +21466,7 @@
2133021466 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2133121467 if(!newstack)
2133221468 {
21333- label = 1838LLU; // throw: begin to unroll stack
21469+ label = 1854LLU; // throw: begin to unroll stack
2133421470 break;
2133521471 }
2133621472
@@ -21337,9 +21473,9 @@
2133721473 newstack[10LLU] = 9876543210LLU; // overflow-marker
2133821474 // call reporttype from ProcCall
2133921475 newstack[0] = (uint64_t)stack; // backup stack location
21340- newstack[1] = 1853LLU;
21476+ newstack[1] = 1869LLU;
2134121477 newstack[2] = base;
21342- newstack[3] = 1854LLU;
21478+ newstack[3] = 1870LLU;
2134321479 // arguments for call to reporttype
2134421480 newstack[4LLU] = stack[base + 41]/*expected*/;
2134521481 stack = newstack;
@@ -21348,7 +21484,7 @@
2134821484 label = 330LLU; // reporttype
2134921485 break;
2135021486 }
21351- case 1853LLU: // copy-back deleter (reporttype to ProcCall)
21487+ case 1869LLU: // copy-back deleter (reporttype to ProcCall)
2135221488 {
2135321489 uint64_t *oldstack = (uint64_t *)stack[0];
2135421490 // copy mutable arguments back from call to reporttype
@@ -21359,10 +21495,10 @@
2135921495 }
2136021496 Free(10LLU + 1, sizeof(uint64_t), stack);
2136121497 stack = oldstack;
21362- label = 1838LLU; // continue to unroll stack
21498+ label = 1854LLU; // continue to unroll stack
2136321499 break;
2136421500 }
21365- case 1854LLU: // return from reporttype to ProcCall
21501+ case 1870LLU: // return from reporttype to ProcCall
2136621502 {
2136721503 uint64_t *oldstack = (uint64_t *)stack[0];
2136821504 // copy mutable arguments back from call to reporttype
@@ -21376,18 +21512,18 @@
2137621512 fprintf(stderr, "%s", " but found constant-argument of type u64");
2137721513 fprintf(stderr, "%s", "\n");
2137821514 {
21379- label = 1838LLU; // throw: begin to unroll stack
21515+ label = 1854LLU; // throw: begin to unroll stack
2138021516 break;
2138121517 }
2138221518
21383- label = 1846LLU; // alternative complete
21519+ label = 1862LLU; // alternative complete
2138421520 break;
2138521521 }
21386- case 1846LLU: // completed if-then-else
21522+ case 1862LLU: // completed if-then-else
2138721523 {
2138821524 if(!stack[base + 40]/*mutable*/)
2138921525 {
21390- label = 1855LLU; // jump to alternative
21526+ label = 1871LLU; // jump to alternative
2139121527 break;
2139221528 }
2139321529
@@ -21394,9 +21530,9 @@
2139421530 // consequent
2139521531 fprintf(stderr, "%s", "in function ");
2139621532 // call reportid from ProcCall
21397- stack[base + 44LLU] = 1857LLU/*throw to this address*/;
21533+ stack[base + 44LLU] = 1873LLU/*throw to this address*/;
2139821534 stack[base + 45LLU] = base;
21399- stack[base + 46LLU] = 1858LLU;
21535+ stack[base + 46LLU] = 1874LLU;
2140021536 // arguments for call to reportid
2140121537 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2140221538 // set stack-base & callee-address
@@ -21404,20 +21540,20 @@
2140421540 label = 18446744073709551586LLU; // reportid
2140521541 break;
2140621542 }
21407- case 1857LLU: // copy-back deleter (reportid to ProcCall)
21543+ case 1873LLU: // copy-back deleter (reportid to ProcCall)
2140821544 {
2140921545 // copy mutable arguments back from call to reportid
21410- label = 1838LLU; // continue to roll stack
21546+ label = 1854LLU; // continue to roll stack
2141121547 break;
2141221548 }
21413- case 1858LLU: // return from reportid to ProcCall
21549+ case 1874LLU: // return from reportid to ProcCall
2141421550 {
2141521551 // copy mutable arguments back from call to reportid
2141621552 fprintf(stderr, "%s", ", calling ");
2141721553 // call reportid from ProcCall
21418- stack[base + 44LLU] = 1859LLU/*throw to this address*/;
21554+ stack[base + 44LLU] = 1875LLU/*throw to this address*/;
2141921555 stack[base + 45LLU] = base;
21420- stack[base + 46LLU] = 1860LLU;
21556+ stack[base + 46LLU] = 1876LLU;
2142121557 // arguments for call to reportid
2142221558 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2142321559 // set stack-base & callee-address
@@ -21425,21 +21561,21 @@
2142521561 label = 18446744073709551586LLU; // reportid
2142621562 break;
2142721563 }
21428- case 1859LLU: // copy-back deleter (reportid to ProcCall)
21564+ case 1875LLU: // copy-back deleter (reportid to ProcCall)
2142921565 {
2143021566 // copy mutable arguments back from call to reportid
21431- label = 1838LLU; // continue to roll stack
21567+ label = 1854LLU; // continue to roll stack
2143221568 break;
2143321569 }
21434- case 1860LLU: // return from reportid to ProcCall
21570+ case 1876LLU: // return from reportid to ProcCall
2143521571 {
2143621572 // copy mutable arguments back from call to reportid
2143721573 fprintf(stderr, "%s", ": ");
2143821574 fprintf(stderr, "%s", "can't use constant argument ");
2143921575 // call printnr from ProcCall
21440- stack[base + 44LLU] = 1861LLU/*throw to this address*/;
21576+ stack[base + 44LLU] = 1877LLU/*throw to this address*/;
2144121577 stack[base + 45LLU] = base;
21442- stack[base + 46LLU] = 1862LLU;
21578+ stack[base + 46LLU] = 1878LLU;
2144321579 // arguments for call to printnr
2144421580 stack[base + 47LLU] = stack[base + 16]/*content*/;
2144521581 // set stack-base & callee-address
@@ -21447,20 +21583,20 @@
2144721583 label = 18446744073709551590LLU; // printnr
2144821584 break;
2144921585 }
21450- case 1861LLU: // copy-back deleter (printnr to ProcCall)
21586+ case 1877LLU: // copy-back deleter (printnr to ProcCall)
2145121587 {
2145221588 // copy mutable arguments back from call to printnr
21453- label = 1838LLU; // continue to roll stack
21589+ label = 1854LLU; // continue to roll stack
2145421590 break;
2145521591 }
21456- case 1862LLU: // return from printnr to ProcCall
21592+ case 1878LLU: // return from printnr to ProcCall
2145721593 {
2145821594 // copy mutable arguments back from call to printnr
2145921595 printf("%s", " for mutable parameter ");
2146021596 // call reportti from ProcCall
21461- stack[base + 44LLU] = 1863LLU/*throw to this address*/;
21597+ stack[base + 44LLU] = 1879LLU/*throw to this address*/;
2146221598 stack[base + 45LLU] = base;
21463- stack[base + 46LLU] = 1864LLU;
21599+ stack[base + 46LLU] = 1880LLU;
2146421600 // arguments for call to reportti
2146521601 stack[base + 47LLU] = stack[base + 39]/*typeid*/;
2146621602 // set stack-base & callee-address
@@ -21468,36 +21604,36 @@
2146821604 label = 390LLU; // reportti
2146921605 break;
2147021606 }
21471- case 1863LLU: // copy-back deleter (reportti to ProcCall)
21607+ case 1879LLU: // copy-back deleter (reportti to ProcCall)
2147221608 {
2147321609 // copy mutable arguments back from call to reportti
21474- label = 1838LLU; // continue to roll stack
21610+ label = 1854LLU; // continue to roll stack
2147521611 break;
2147621612 }
21477- case 1864LLU: // return from reportti to ProcCall
21613+ case 1880LLU: // return from reportti to ProcCall
2147821614 {
2147921615 // copy mutable arguments back from call to reportti
2148021616 fprintf(stderr, "%s", "\n");
2148121617 {
21482- label = 1838LLU; // throw: begin to unroll stack
21618+ label = 1854LLU; // throw: begin to unroll stack
2148321619 break;
2148421620 }
2148521621
21486- label = 1856LLU; // consequent complete
21622+ label = 1872LLU; // consequent complete
2148721623 break;
2148821624 }
21489- case 1855LLU: // alternative
21625+ case 1871LLU: // alternative
2149021626 {
21491- label = 1856LLU; // alternative complete
21627+ label = 1872LLU; // alternative complete
2149221628 break;
2149321629 }
21494- case 1856LLU: // completed if-then-else
21630+ case 1872LLU: // completed if-then-else
2149521631 {
2149621632 printf("%s", "\n newstack[");
2149721633 // call printnr from ProcCall
21498- stack[base + 44LLU] = 1865LLU/*throw to this address*/;
21634+ stack[base + 44LLU] = 1881LLU/*throw to this address*/;
2149921635 stack[base + 45LLU] = base;
21500- stack[base + 46LLU] = 1866LLU;
21636+ stack[base + 46LLU] = 1882LLU;
2150121637 // arguments for call to printnr
2150221638 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2150321639 // set stack-base & callee-address
@@ -21505,20 +21641,20 @@
2150521641 label = 18446744073709551590LLU; // printnr
2150621642 break;
2150721643 }
21508- case 1865LLU: // copy-back deleter (printnr to ProcCall)
21644+ case 1881LLU: // copy-back deleter (printnr to ProcCall)
2150921645 {
2151021646 // copy mutable arguments back from call to printnr
21511- label = 1838LLU; // continue to roll stack
21647+ label = 1854LLU; // continue to roll stack
2151221648 break;
2151321649 }
21514- case 1866LLU: // return from printnr to ProcCall
21650+ case 1882LLU: // return from printnr to ProcCall
2151521651 {
2151621652 // copy mutable arguments back from call to printnr
2151721653 printf("%s", "LLU] = ");
2151821654 // call printnr from ProcCall
21519- stack[base + 44LLU] = 1867LLU/*throw to this address*/;
21655+ stack[base + 44LLU] = 1883LLU/*throw to this address*/;
2152021656 stack[base + 45LLU] = base;
21521- stack[base + 46LLU] = 1868LLU;
21657+ stack[base + 46LLU] = 1884LLU;
2152221658 // arguments for call to printnr
2152321659 stack[base + 47LLU] = stack[base + 16]/*content*/;
2152421660 // set stack-base & callee-address
@@ -21526,20 +21662,20 @@
2152621662 label = 18446744073709551590LLU; // printnr
2152721663 break;
2152821664 }
21529- case 1867LLU: // copy-back deleter (printnr to ProcCall)
21665+ case 1883LLU: // copy-back deleter (printnr to ProcCall)
2153021666 {
2153121667 // copy mutable arguments back from call to printnr
21532- label = 1838LLU; // continue to roll stack
21668+ label = 1854LLU; // continue to roll stack
2153321669 break;
2153421670 }
21535- case 1868LLU: // return from printnr to ProcCall
21671+ case 1884LLU: // return from printnr to ProcCall
2153621672 {
2153721673 // copy mutable arguments back from call to printnr
2153821674 printf("%s", "LLU; // ");
2153921675 // call printid from ProcCall
21540- stack[base + 44LLU] = 1869LLU/*throw to this address*/;
21676+ stack[base + 44LLU] = 1885LLU/*throw to this address*/;
2154121677 stack[base + 45LLU] = base;
21542- stack[base + 46LLU] = 1870LLU;
21678+ stack[base + 46LLU] = 1886LLU;
2154321679 // arguments for call to printid
2154421680 stack[base + 47LLU] = stack[base + 16]/*content*/;
2154521681 // set stack-base & callee-address
@@ -21547,13 +21683,13 @@
2154721683 label = 18446744073709551587LLU; // printid
2154821684 break;
2154921685 }
21550- case 1869LLU: // copy-back deleter (printid to ProcCall)
21686+ case 1885LLU: // copy-back deleter (printid to ProcCall)
2155121687 {
2155221688 // copy mutable arguments back from call to printid
21553- label = 1838LLU; // continue to roll stack
21689+ label = 1854LLU; // continue to roll stack
2155421690 break;
2155521691 }
21556- case 1870LLU: // return from printid to ProcCall
21692+ case 1886LLU: // return from printid to ProcCall
2155721693 {
2155821694 // copy mutable arguments back from call to printid
2155921695
@@ -21562,7 +21698,7 @@
2156221698 newstack[0] = (uint64_t)stack; // backup stack location
2156321699 newstack[1] = 1234567890;
2156421700 newstack[2] = base;
21565- newstack[3] = 1871LLU;
21701+ newstack[3] = 1887LLU;
2156621702 stack = newstack;
2156721703 // set stack-base & callee-address
2156821704 base = 4/*deloffset*/;
@@ -21569,21 +21705,21 @@
2156921705 label = 310LLU; // ~type
2157021706 break;
2157121707 }
21572- case 1871LLU: // return from ~type to ProcCall
21708+ case 1887LLU: // return from ~type to ProcCall
2157321709 {
2157421710 stack = (uint64_t *)stack[0];
2157521711 // releasing toplevel container
2157621712 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2157721713
21578- label = 1837LLU; // consequent complete
21714+ label = 1853LLU; // consequent complete
2157921715 break;
2158021716 }
21581- case 1836LLU: // alternative
21717+ case 1852LLU: // alternative
2158221718 {
2158321719 // call equ from ProcCall
21584- stack[base + 43LLU] = 1872LLU/*throw to this address*/;
21720+ stack[base + 43LLU] = 1888LLU/*throw to this address*/;
2158521721 stack[base + 44LLU] = base;
21586- stack[base + 45LLU] = 1873LLU;
21722+ stack[base + 45LLU] = 1889LLU;
2158721723 // arguments for call to equ
2158821724 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2158921725 stack[base + 48LLU] = 4LLU;
@@ -21592,13 +21728,13 @@
2159221728 label = 18446744073709551600LLU; // equ
2159321729 break;
2159421730 }
21595- case 1872LLU: // copy-back deleter (equ to ProcCall)
21731+ case 1888LLU: // copy-back deleter (equ to ProcCall)
2159621732 {
2159721733 // copy mutable arguments back from call to equ
21598- label = 1831LLU; // continue to roll stack
21734+ label = 1847LLU; // continue to roll stack
2159921735 break;
2160021736 }
21601- case 1873LLU: // return from equ to ProcCall
21737+ case 1889LLU: // return from equ to ProcCall
2160221738 {
2160321739 // copy mutable arguments back from call to equ
2160421740 // copy back results provided by call to equ
@@ -21605,15 +21741,15 @@
2160521741 stack[base + 18] = stack[base + 46LLU];
2160621742 if(!stack[base + 18]/*isequal*/)
2160721743 {
21608- label = 1874LLU; // jump to alternative
21744+ label = 1890LLU; // jump to alternative
2160921745 break;
2161021746 }
2161121747
2161221748 // consequent
2161321749 // call equ from ProcCall
21614- stack[base + 43LLU] = 1876LLU/*throw to this address*/;
21750+ stack[base + 43LLU] = 1892LLU/*throw to this address*/;
2161521751 stack[base + 44LLU] = base;
21616- stack[base + 45LLU] = 1877LLU;
21752+ stack[base + 45LLU] = 1893LLU;
2161721753 // arguments for call to equ
2161821754 stack[base + 47LLU] = stack[base + 16]/*content*/;
2161921755 stack[base + 48LLU] = 621705506259468288LLU;
@@ -21622,13 +21758,13 @@
2162221758 label = 18446744073709551600LLU; // equ
2162321759 break;
2162421760 }
21625- case 1876LLU: // copy-back deleter (equ to ProcCall)
21761+ case 1892LLU: // copy-back deleter (equ to ProcCall)
2162621762 {
2162721763 // copy mutable arguments back from call to equ
21628- label = 1831LLU; // continue to roll stack
21764+ label = 1847LLU; // continue to roll stack
2162921765 break;
2163021766 }
21631- case 1877LLU: // return from equ to ProcCall
21767+ case 1893LLU: // return from equ to ProcCall
2163221768 {
2163321769 // copy mutable arguments back from call to equ
2163421770 // copy back results provided by call to equ
@@ -21635,15 +21771,15 @@
2163521771 stack[base + 18] = stack[base + 46LLU];
2163621772 if(!stack[base + 18]/*isequal*/)
2163721773 {
21638- label = 1878LLU; // jump to alternative
21774+ label = 1894LLU; // jump to alternative
2163921775 break;
2164021776 }
2164121777
2164221778 // consequent
2164321779 // call matchsym from ProcCall
21644- stack[base + 43LLU] = 1880LLU/*throw to this address*/;
21780+ stack[base + 43LLU] = 1896LLU/*throw to this address*/;
2164521781 stack[base + 44LLU] = base;
21646- stack[base + 45LLU] = 1881LLU;
21782+ stack[base + 45LLU] = 1897LLU;
2164721783 // arguments for call to matchsym
2164821784 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2164921785 stack[base + 47LLU] = 40LLU;
@@ -21653,21 +21789,21 @@
2165321789 label = 246LLU; // matchsym
2165421790 break;
2165521791 }
21656- case 1880LLU: // copy-back deleter (matchsym to ProcCall)
21792+ case 1896LLU: // copy-back deleter (matchsym to ProcCall)
2165721793 {
2165821794 // copy mutable arguments back from call to matchsym
2165921795 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21660- label = 1831LLU; // continue to roll stack
21796+ label = 1847LLU; // continue to roll stack
2166121797 break;
2166221798 }
21663- case 1881LLU: // return from matchsym to ProcCall
21799+ case 1897LLU: // return from matchsym to ProcCall
2166421800 {
2166521801 // copy mutable arguments back from call to matchsym
2166621802 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2166721803 // call matchsym from ProcCall
21668- stack[base + 43LLU] = 1882LLU/*throw to this address*/;
21804+ stack[base + 43LLU] = 1898LLU/*throw to this address*/;
2166921805 stack[base + 44LLU] = base;
21670- stack[base + 45LLU] = 1883LLU;
21806+ stack[base + 45LLU] = 1899LLU;
2167121807 // arguments for call to matchsym
2167221808 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2167321809 stack[base + 47LLU] = 41LLU;
@@ -21677,20 +21813,20 @@
2167721813 label = 246LLU; // matchsym
2167821814 break;
2167921815 }
21680- case 1882LLU: // copy-back deleter (matchsym to ProcCall)
21816+ case 1898LLU: // copy-back deleter (matchsym to ProcCall)
2168121817 {
2168221818 // copy mutable arguments back from call to matchsym
2168321819 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21684- label = 1831LLU; // continue to roll stack
21820+ label = 1847LLU; // continue to roll stack
2168521821 break;
2168621822 }
21687- case 1883LLU: // return from matchsym to ProcCall
21823+ case 1899LLU: // return from matchsym to ProcCall
2168821824 {
2168921825 // copy mutable arguments back from call to matchsym
2169021826 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2169121827 if(/*typedata*/0 != ((uint64_t *)(stack[base + 41]/*expected*/))[0])
2169221828 {
21693- label = 1885LLU; // jump to alternative
21829+ label = 1901LLU; // jump to alternative
2169421830 break;
2169521831 }
2169621832
@@ -21698,9 +21834,9 @@
2169821834
2169921835 // case
2170021836 // call equ from ProcCall
21701- stack[base + 44LLU] = 1887LLU/*throw to this address*/;
21837+ stack[base + 44LLU] = 1903LLU/*throw to this address*/;
2170221838 stack[base + 45LLU] = base;
21703- stack[base + 46LLU] = 1888LLU;
21839+ stack[base + 46LLU] = 1904LLU;
2170421840 // arguments for call to equ
2170521841 stack[base + 48LLU] = stack[base + 43]/*name*/;
2170621842 stack[base + 49LLU] = 881834713755418624LLU;
@@ -21709,13 +21845,13 @@
2170921845 label = 18446744073709551600LLU; // equ
2171021846 break;
2171121847 }
21712- case 1887LLU: // copy-back deleter (equ to ProcCall)
21848+ case 1903LLU: // copy-back deleter (equ to ProcCall)
2171321849 {
2171421850 // copy mutable arguments back from call to equ
21715- label = 1886LLU; // continue to roll stack
21851+ label = 1902LLU; // continue to roll stack
2171621852 break;
2171721853 }
21718- case 1888LLU: // return from equ to ProcCall
21854+ case 1904LLU: // return from equ to ProcCall
2171921855 {
2172021856 // copy mutable arguments back from call to equ
2172121857 // copy back results provided by call to equ
@@ -21722,7 +21858,7 @@
2172221858 stack[base + 18] = stack[base + 47LLU];
2172321859 if(!stack[base + 18]/*isequal*/)
2172421860 {
21725- label = 1889LLU; // jump to alternative
21861+ label = 1905LLU; // jump to alternative
2172621862 break;
2172721863 }
2172821864
@@ -21729,7 +21865,7 @@
2172921865 // consequent
2173021866 if(!stack[base + 40]/*mutable*/)
2173121867 {
21732- label = 1891LLU; // jump to alternative
21868+ label = 1907LLU; // jump to alternative
2173321869 break;
2173421870 }
2173521871
@@ -21736,9 +21872,9 @@
2173621872 // consequent
2173721873 fprintf(stderr, "%s", "in function ");
2173821874 // call reportid from ProcCall
21739- stack[base + 44LLU] = 1893LLU/*throw to this address*/;
21875+ stack[base + 44LLU] = 1909LLU/*throw to this address*/;
2174021876 stack[base + 45LLU] = base;
21741- stack[base + 46LLU] = 1894LLU;
21877+ stack[base + 46LLU] = 1910LLU;
2174221878 // arguments for call to reportid
2174321879 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2174421880 // set stack-base & callee-address
@@ -21746,20 +21882,20 @@
2174621882 label = 18446744073709551586LLU; // reportid
2174721883 break;
2174821884 }
21749- case 1893LLU: // copy-back deleter (reportid to ProcCall)
21885+ case 1909LLU: // copy-back deleter (reportid to ProcCall)
2175021886 {
2175121887 // copy mutable arguments back from call to reportid
21752- label = 1886LLU; // continue to roll stack
21888+ label = 1902LLU; // continue to roll stack
2175321889 break;
2175421890 }
21755- case 1894LLU: // return from reportid to ProcCall
21891+ case 1910LLU: // return from reportid to ProcCall
2175621892 {
2175721893 // copy mutable arguments back from call to reportid
2175821894 fprintf(stderr, "%s", ", call to ");
2175921895 // call reportid from ProcCall
21760- stack[base + 44LLU] = 1895LLU/*throw to this address*/;
21896+ stack[base + 44LLU] = 1911LLU/*throw to this address*/;
2176121897 stack[base + 45LLU] = base;
21762- stack[base + 46LLU] = 1896LLU;
21898+ stack[base + 46LLU] = 1912LLU;
2176321899 // arguments for call to reportid
2176421900 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2176521901 // set stack-base & callee-address
@@ -21767,13 +21903,13 @@
2176721903 label = 18446744073709551586LLU; // reportid
2176821904 break;
2176921905 }
21770- case 1895LLU: // copy-back deleter (reportid to ProcCall)
21906+ case 1911LLU: // copy-back deleter (reportid to ProcCall)
2177121907 {
2177221908 // copy mutable arguments back from call to reportid
21773- label = 1886LLU; // continue to roll stack
21909+ label = 1902LLU; // continue to roll stack
2177421910 break;
2177521911 }
21776- case 1896LLU: // return from reportid to ProcCall
21912+ case 1912LLU: // return from reportid to ProcCall
2177721913 {
2177821914 // copy mutable arguments back from call to reportid
2177921915 fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
@@ -21780,7 +21916,7 @@
2178021916 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2178121917 if(!newstack)
2178221918 {
21783- label = 1886LLU; // throw: begin to unroll stack
21919+ label = 1902LLU; // throw: begin to unroll stack
2178421920 break;
2178521921 }
2178621922
@@ -21787,9 +21923,9 @@
2178721923 newstack[10LLU] = 9876543210LLU; // overflow-marker
2178821924 // call reporttype from ProcCall
2178921925 newstack[0] = (uint64_t)stack; // backup stack location
21790- newstack[1] = 1897LLU;
21926+ newstack[1] = 1913LLU;
2179121927 newstack[2] = base;
21792- newstack[3] = 1898LLU;
21928+ newstack[3] = 1914LLU;
2179321929 // arguments for call to reporttype
2179421930 newstack[4LLU] = stack[base + 41]/*expected*/;
2179521931 stack = newstack;
@@ -21798,7 +21934,7 @@
2179821934 label = 330LLU; // reporttype
2179921935 break;
2180021936 }
21801- case 1897LLU: // copy-back deleter (reporttype to ProcCall)
21937+ case 1913LLU: // copy-back deleter (reporttype to ProcCall)
2180221938 {
2180321939 uint64_t *oldstack = (uint64_t *)stack[0];
2180421940 // copy mutable arguments back from call to reporttype
@@ -21809,10 +21945,10 @@
2180921945 }
2181021946 Free(10LLU + 1, sizeof(uint64_t), stack);
2181121947 stack = oldstack;
21812- label = 1886LLU; // continue to unroll stack
21948+ label = 1902LLU; // continue to unroll stack
2181321949 break;
2181421950 }
21815- case 1898LLU: // return from reporttype to ProcCall
21951+ case 1914LLU: // return from reporttype to ProcCall
2181621952 {
2181721953 uint64_t *oldstack = (uint64_t *)stack[0];
2181821954 // copy mutable arguments back from call to reporttype
@@ -21824,9 +21960,9 @@
2182421960 Free(10LLU + 1, sizeof(uint64_t), stack);
2182521961 stack = oldstack;
2182621962 // call reportid from ProcCall
21827- stack[base + 44LLU] = 1899LLU/*throw to this address*/;
21963+ stack[base + 44LLU] = 1915LLU/*throw to this address*/;
2182821964 stack[base + 45LLU] = base;
21829- stack[base + 46LLU] = 1900LLU;
21965+ stack[base + 46LLU] = 1916LLU;
2183021966 // arguments for call to reportid
2183121967 stack[base + 47LLU] = stack[base + 42]/*paramname*/;
2183221968 // set stack-base & callee-address
@@ -21834,32 +21970,32 @@
2183421970 label = 18446744073709551586LLU; // reportid
2183521971 break;
2183621972 }
21837- case 1899LLU: // copy-back deleter (reportid to ProcCall)
21973+ case 1915LLU: // copy-back deleter (reportid to ProcCall)
2183821974 {
2183921975 // copy mutable arguments back from call to reportid
21840- label = 1886LLU; // continue to roll stack
21976+ label = 1902LLU; // continue to roll stack
2184121977 break;
2184221978 }
21843- case 1900LLU: // return from reportid to ProcCall
21979+ case 1916LLU: // return from reportid to ProcCall
2184421980 {
2184521981 // copy mutable arguments back from call to reportid
2184621982 fprintf(stderr, "%s", "\n");
2184721983 {
21848- label = 1886LLU; // throw: begin to unroll stack
21984+ label = 1902LLU; // throw: begin to unroll stack
2184921985 break;
2185021986 }
2185121987
21852- label = 1892LLU; // consequent complete
21988+ label = 1908LLU; // consequent complete
2185321989 break;
2185421990 }
21855- case 1891LLU: // alternative
21991+ case 1907LLU: // alternative
2185621992 {
2185721993 stack[base + 35]/*csubstruct*/ = 1;
2185821994 printf("%s", "\n newstack[");
2185921995 // call printnr from ProcCall
21860- stack[base + 44LLU] = 1901LLU/*throw to this address*/;
21996+ stack[base + 44LLU] = 1917LLU/*throw to this address*/;
2186121997 stack[base + 45LLU] = base;
21862- stack[base + 46LLU] = 1902LLU;
21998+ stack[base + 46LLU] = 1918LLU;
2186321999 // arguments for call to printnr
2186422000 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2186522001 // set stack-base & callee-address
@@ -21867,31 +22003,31 @@
2186722003 label = 18446744073709551590LLU; // printnr
2186822004 break;
2186922005 }
21870- case 1901LLU: // copy-back deleter (printnr to ProcCall)
22006+ case 1917LLU: // copy-back deleter (printnr to ProcCall)
2187122007 {
2187222008 // copy mutable arguments back from call to printnr
21873- label = 1886LLU; // continue to roll stack
22009+ label = 1902LLU; // continue to roll stack
2187422010 break;
2187522011 }
21876- case 1902LLU: // return from printnr to ProcCall
22012+ case 1918LLU: // return from printnr to ProcCall
2187722013 {
2187822014 // copy mutable arguments back from call to printnr
2187922015 printf("%s", "LLU] = getchar();");
21880- label = 1892LLU; // alternative complete
22016+ label = 1908LLU; // alternative complete
2188122017 break;
2188222018 }
21883- case 1892LLU: // completed if-then-else
22019+ case 1908LLU: // completed if-then-else
2188422020 {
21885- label = 1890LLU; // consequent complete
22021+ label = 1906LLU; // consequent complete
2188622022 break;
2188722023 }
21888- case 1889LLU: // alternative
22024+ case 1905LLU: // alternative
2188922025 {
2189022026 fprintf(stderr, "%s", "in function ");
2189122027 // call reportid from ProcCall
21892- stack[base + 44LLU] = 1903LLU/*throw to this address*/;
22028+ stack[base + 44LLU] = 1919LLU/*throw to this address*/;
2189322029 stack[base + 45LLU] = base;
21894- stack[base + 46LLU] = 1904LLU;
22030+ stack[base + 46LLU] = 1920LLU;
2189522031 // arguments for call to reportid
2189622032 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2189722033 // set stack-base & callee-address
@@ -21899,20 +22035,20 @@
2189922035 label = 18446744073709551586LLU; // reportid
2190022036 break;
2190122037 }
21902- case 1903LLU: // copy-back deleter (reportid to ProcCall)
22038+ case 1919LLU: // copy-back deleter (reportid to ProcCall)
2190322039 {
2190422040 // copy mutable arguments back from call to reportid
21905- label = 1886LLU; // continue to roll stack
22041+ label = 1902LLU; // continue to roll stack
2190622042 break;
2190722043 }
21908- case 1904LLU: // return from reportid to ProcCall
22044+ case 1920LLU: // return from reportid to ProcCall
2190922045 {
2191022046 // copy mutable arguments back from call to reportid
2191122047 fprintf(stderr, "%s", " recursive call to ");
2191222048 // call reportid from ProcCall
21913- stack[base + 44LLU] = 1905LLU/*throw to this address*/;
22049+ stack[base + 44LLU] = 1921LLU/*throw to this address*/;
2191422050 stack[base + 45LLU] = base;
21915- stack[base + 46LLU] = 1906LLU;
22051+ stack[base + 46LLU] = 1922LLU;
2191622052 // arguments for call to reportid
2191722053 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2191822054 // set stack-base & callee-address
@@ -21920,20 +22056,20 @@
2192022056 label = 18446744073709551586LLU; // reportid
2192122057 break;
2192222058 }
21923- case 1905LLU: // copy-back deleter (reportid to ProcCall)
22059+ case 1921LLU: // copy-back deleter (reportid to ProcCall)
2192422060 {
2192522061 // copy mutable arguments back from call to reportid
21926- label = 1886LLU; // continue to roll stack
22062+ label = 1902LLU; // continue to roll stack
2192722063 break;
2192822064 }
21929- case 1906LLU: // return from reportid to ProcCall
22065+ case 1922LLU: // return from reportid to ProcCall
2193022066 {
2193122067 // copy mutable arguments back from call to reportid
2193222068 fprintf(stderr, "%s", " at position ");
2193322069 // call reportnr from ProcCall
21934- stack[base + 44LLU] = 1907LLU/*throw to this address*/;
22070+ stack[base + 44LLU] = 1923LLU/*throw to this address*/;
2193522071 stack[base + 45LLU] = base;
21936- stack[base + 46LLU] = 1908LLU;
22072+ stack[base + 46LLU] = 1924LLU;
2193722073 // arguments for call to reportnr
2193822074 stack[base + 47LLU] = stack[base + 32]/*index*/;
2193922075 // set stack-base & callee-address
@@ -21941,13 +22077,13 @@
2194122077 label = 18446744073709551589LLU; // reportnr
2194222078 break;
2194322079 }
21944- case 1907LLU: // copy-back deleter (reportnr to ProcCall)
22080+ case 1923LLU: // copy-back deleter (reportnr to ProcCall)
2194522081 {
2194622082 // copy mutable arguments back from call to reportnr
21947- label = 1886LLU; // continue to roll stack
22083+ label = 1902LLU; // continue to roll stack
2194822084 break;
2194922085 }
21950- case 1908LLU: // return from reportnr to ProcCall
22086+ case 1924LLU: // return from reportnr to ProcCall
2195122087 {
2195222088 // copy mutable arguments back from call to reportnr
2195322089 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -21955,7 +22091,7 @@
2195522091 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2195622092 if(!newstack)
2195722093 {
21958- label = 1886LLU; // throw: begin to unroll stack
22094+ label = 1902LLU; // throw: begin to unroll stack
2195922095 break;
2196022096 }
2196122097
@@ -21962,9 +22098,9 @@
2196222098 newstack[10LLU] = 9876543210LLU; // overflow-marker
2196322099 // call reporttype from ProcCall
2196422100 newstack[0] = (uint64_t)stack; // backup stack location
21965- newstack[1] = 1909LLU;
22101+ newstack[1] = 1925LLU;
2196622102 newstack[2] = base;
21967- newstack[3] = 1910LLU;
22103+ newstack[3] = 1926LLU;
2196822104 // arguments for call to reporttype
2196922105 newstack[4LLU] = stack[base + 41]/*expected*/;
2197022106 stack = newstack;
@@ -21973,7 +22109,7 @@
2197322109 label = 330LLU; // reporttype
2197422110 break;
2197522111 }
21976- case 1909LLU: // copy-back deleter (reporttype to ProcCall)
22112+ case 1925LLU: // copy-back deleter (reporttype to ProcCall)
2197722113 {
2197822114 uint64_t *oldstack = (uint64_t *)stack[0];
2197922115 // copy mutable arguments back from call to reporttype
@@ -21984,10 +22120,10 @@
2198422120 }
2198522121 Free(10LLU + 1, sizeof(uint64_t), stack);
2198622122 stack = oldstack;
21987- label = 1886LLU; // continue to unroll stack
22123+ label = 1902LLU; // continue to unroll stack
2198822124 break;
2198922125 }
21990- case 1910LLU: // return from reporttype to ProcCall
22126+ case 1926LLU: // return from reporttype to ProcCall
2199122127 {
2199222128 uint64_t *oldstack = (uint64_t *)stack[0];
2199322129 // copy mutable arguments back from call to reporttype
@@ -22000,33 +22136,33 @@
2200022136 stack = oldstack;
2200122137 fprintf(stderr, "%s", "\n");
2200222138 {
22003- label = 1886LLU; // throw: begin to unroll stack
22139+ label = 1902LLU; // throw: begin to unroll stack
2200422140 break;
2200522141 }
2200622142
22007- label = 1890LLU; // alternative complete
22143+ label = 1906LLU; // alternative complete
2200822144 break;
2200922145 }
22010- case 1890LLU: // completed if-then-else
22146+ case 1906LLU: // completed if-then-else
2201122147 {
2201222148 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
22013- label = 1884LLU; // case complete
22149+ label = 1900LLU; // case complete
2201422150 break;
2201522151 }
22016- case 1886LLU: // copy-back deleter (switch)
22152+ case 1902LLU: // copy-back deleter (switch)
2201722153 {
2201822154 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
22019- label = 1831LLU; // continue to unroll stack
22155+ label = 1847LLU; // continue to unroll stack
2202022156 break;
2202122157 }
22022- case 1885LLU: // try next case
22158+ case 1901LLU: // try next case
2202322159 {
2202422160 // default
2202522161 fprintf(stderr, "%s", "in function ");
2202622162 // call reportid from ProcCall
22027- stack[base + 43LLU] = 1911LLU/*throw to this address*/;
22163+ stack[base + 43LLU] = 1927LLU/*throw to this address*/;
2202822164 stack[base + 44LLU] = base;
22029- stack[base + 45LLU] = 1912LLU;
22165+ stack[base + 45LLU] = 1928LLU;
2203022166 // arguments for call to reportid
2203122167 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2203222168 // set stack-base & callee-address
@@ -22034,20 +22170,20 @@
2203422170 label = 18446744073709551586LLU; // reportid
2203522171 break;
2203622172 }
22037- case 1911LLU: // copy-back deleter (reportid to ProcCall)
22173+ case 1927LLU: // copy-back deleter (reportid to ProcCall)
2203822174 {
2203922175 // copy mutable arguments back from call to reportid
22040- label = 1831LLU; // continue to roll stack
22176+ label = 1847LLU; // continue to roll stack
2204122177 break;
2204222178 }
22043- case 1912LLU: // return from reportid to ProcCall
22179+ case 1928LLU: // return from reportid to ProcCall
2204422180 {
2204522181 // copy mutable arguments back from call to reportid
2204622182 fprintf(stderr, "%s", " recursive call to ");
2204722183 // call reportid from ProcCall
22048- stack[base + 43LLU] = 1913LLU/*throw to this address*/;
22184+ stack[base + 43LLU] = 1929LLU/*throw to this address*/;
2204922185 stack[base + 44LLU] = base;
22050- stack[base + 45LLU] = 1914LLU;
22186+ stack[base + 45LLU] = 1930LLU;
2205122187 // arguments for call to reportid
2205222188 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2205322189 // set stack-base & callee-address
@@ -22055,20 +22191,20 @@
2205522191 label = 18446744073709551586LLU; // reportid
2205622192 break;
2205722193 }
22058- case 1913LLU: // copy-back deleter (reportid to ProcCall)
22194+ case 1929LLU: // copy-back deleter (reportid to ProcCall)
2205922195 {
2206022196 // copy mutable arguments back from call to reportid
22061- label = 1831LLU; // continue to roll stack
22197+ label = 1847LLU; // continue to roll stack
2206222198 break;
2206322199 }
22064- case 1914LLU: // return from reportid to ProcCall
22200+ case 1930LLU: // return from reportid to ProcCall
2206522201 {
2206622202 // copy mutable arguments back from call to reportid
2206722203 fprintf(stderr, "%s", " at position ");
2206822204 // call reportnr from ProcCall
22069- stack[base + 43LLU] = 1915LLU/*throw to this address*/;
22205+ stack[base + 43LLU] = 1931LLU/*throw to this address*/;
2207022206 stack[base + 44LLU] = base;
22071- stack[base + 45LLU] = 1916LLU;
22207+ stack[base + 45LLU] = 1932LLU;
2207222208 // arguments for call to reportnr
2207322209 stack[base + 46LLU] = stack[base + 32]/*index*/;
2207422210 // set stack-base & callee-address
@@ -22076,13 +22212,13 @@
2207622212 label = 18446744073709551589LLU; // reportnr
2207722213 break;
2207822214 }
22079- case 1915LLU: // copy-back deleter (reportnr to ProcCall)
22215+ case 1931LLU: // copy-back deleter (reportnr to ProcCall)
2208022216 {
2208122217 // copy mutable arguments back from call to reportnr
22082- label = 1831LLU; // continue to roll stack
22218+ label = 1847LLU; // continue to roll stack
2208322219 break;
2208422220 }
22085- case 1916LLU: // return from reportnr to ProcCall
22221+ case 1932LLU: // return from reportnr to ProcCall
2208622222 {
2208722223 // copy mutable arguments back from call to reportnr
2208822224 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -22090,7 +22226,7 @@
2209022226 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2209122227 if(!newstack)
2209222228 {
22093- label = 1831LLU; // throw: begin to unroll stack
22229+ label = 1847LLU; // throw: begin to unroll stack
2209422230 break;
2209522231 }
2209622232
@@ -22097,9 +22233,9 @@
2209722233 newstack[10LLU] = 9876543210LLU; // overflow-marker
2209822234 // call reporttype from ProcCall
2209922235 newstack[0] = (uint64_t)stack; // backup stack location
22100- newstack[1] = 1917LLU;
22236+ newstack[1] = 1933LLU;
2210122237 newstack[2] = base;
22102- newstack[3] = 1918LLU;
22238+ newstack[3] = 1934LLU;
2210322239 // arguments for call to reporttype
2210422240 newstack[4LLU] = stack[base + 41]/*expected*/;
2210522241 stack = newstack;
@@ -22108,7 +22244,7 @@
2210822244 label = 330LLU; // reporttype
2210922245 break;
2211022246 }
22111- case 1917LLU: // copy-back deleter (reporttype to ProcCall)
22247+ case 1933LLU: // copy-back deleter (reporttype to ProcCall)
2211222248 {
2211322249 uint64_t *oldstack = (uint64_t *)stack[0];
2211422250 // copy mutable arguments back from call to reporttype
@@ -22119,10 +22255,10 @@
2211922255 }
2212022256 Free(10LLU + 1, sizeof(uint64_t), stack);
2212122257 stack = oldstack;
22122- label = 1831LLU; // continue to unroll stack
22258+ label = 1847LLU; // continue to unroll stack
2212322259 break;
2212422260 }
22125- case 1918LLU: // return from reporttype to ProcCall
22261+ case 1934LLU: // return from reporttype to ProcCall
2212622262 {
2212722263 uint64_t *oldstack = (uint64_t *)stack[0];
2212822264 // copy mutable arguments back from call to reporttype
@@ -22135,32 +22271,32 @@
2213522271 stack = oldstack;
2213622272 fprintf(stderr, "%s", "\n");
2213722273 {
22138- label = 1831LLU; // throw: begin to unroll stack
22274+ label = 1847LLU; // throw: begin to unroll stack
2213922275 break;
2214022276 }
2214122277
22142- label = 1884LLU; // default complete
22278+ label = 1900LLU; // default complete
2214322279 break;
2214422280 }
22145- case 1884LLU: // completed switch
22281+ case 1900LLU: // completed switch
2214622282 {
2214722283 if(!stack[base + 7]/*fnIO*/)
2214822284 {
22149- label = 1919LLU; // jump to alternative
22285+ label = 1935LLU; // jump to alternative
2215022286 break;
2215122287 }
2215222288
2215322289 // consequent
22154- label = 1920LLU; // consequent complete
22290+ label = 1936LLU; // consequent complete
2215522291 break;
2215622292 }
22157- case 1919LLU: // alternative
22293+ case 1935LLU: // alternative
2215822294 {
2215922295 fprintf(stderr, "%s", "in function ");
2216022296 // call reportid from ProcCall
22161- stack[base + 43LLU] = 1921LLU/*throw to this address*/;
22297+ stack[base + 43LLU] = 1937LLU/*throw to this address*/;
2216222298 stack[base + 44LLU] = base;
22163- stack[base + 45LLU] = 1922LLU;
22299+ stack[base + 45LLU] = 1938LLU;
2216422300 // arguments for call to reportid
2216522301 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2216622302 // set stack-base & callee-address
@@ -22168,41 +22304,41 @@
2216822304 label = 18446744073709551586LLU; // reportid
2216922305 break;
2217022306 }
22171- case 1921LLU: // copy-back deleter (reportid to ProcCall)
22307+ case 1937LLU: // copy-back deleter (reportid to ProcCall)
2217222308 {
2217322309 // copy mutable arguments back from call to reportid
22174- label = 1831LLU; // continue to roll stack
22310+ label = 1847LLU; // continue to roll stack
2217522311 break;
2217622312 }
22177- case 1922LLU: // return from reportid to ProcCall
22313+ case 1938LLU: // return from reportid to ProcCall
2217822314 {
2217922315 // copy mutable arguments back from call to reportid
2218022316 fprintf(stderr, "%s", ": ");
2218122317 fprintf(stderr, "%s", "getbyte() used in non-IO environment\n");
2218222318 {
22183- label = 1831LLU; // throw: begin to unroll stack
22319+ label = 1847LLU; // throw: begin to unroll stack
2218422320 break;
2218522321 }
2218622322
22187- label = 1920LLU; // alternative complete
22323+ label = 1936LLU; // alternative complete
2218822324 break;
2218922325 }
22190- case 1920LLU: // completed if-then-else
22326+ case 1936LLU: // completed if-then-else
2219122327 {
22192- label = 1879LLU; // consequent complete
22328+ label = 1895LLU; // consequent complete
2219322329 break;
2219422330 }
22195- case 1878LLU: // alternative
22331+ case 1894LLU: // alternative
2219622332 {
22197- label = 1924LLU; // skip deleter
22333+ label = 1940LLU; // skip deleter
2219822334 break;
2219922335 }
22200- case 1923LLU: // deleter
22336+ case 1939LLU: // deleter
2220122337 {
2220222338 // throw from ProcCall
2220322339 if(!stack[base + 43])
2220422340 {
22205- label = 1831LLU; // skip, variable already deleted/unscoped
22341+ label = 1847LLU; // skip, variable already deleted/unscoped
2220622342 break;
2220722343 }
2220822344
@@ -22211,7 +22347,7 @@
2221122347 newstack[0] = (uint64_t)stack; // backup stack location
2221222348 newstack[1] = 1234567890;
2221322349 newstack[2] = base;
22214- newstack[3] = 1925LLU;
22350+ newstack[3] = 1941LLU;
2221522351 stack = newstack;
2221622352 // set stack-base & callee-address
2221722353 base = 4/*deloffset*/;
@@ -22218,21 +22354,21 @@
2221822354 label = 486LLU; // ~letdef
2221922355 break;
2222022356 }
22221- case 1925LLU: // return from ~letdef to ProcCall
22357+ case 1941LLU: // return from ~letdef to ProcCall
2222222358 {
2222322359 stack = (uint64_t *)stack[0];
2222422360 // releasing toplevel container
2222522361 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2222622362
22227- label = 1831LLU; // continue unrolling stack, delete next variable
22363+ label = 1847LLU; // continue unrolling stack, delete next variable
2222822364 break;
2222922365 }
22230- case 1924LLU: // skipped deleter
22366+ case 1940LLU: // skipped deleter
2223122367 {
2223222368 // call FindLet from ProcCall
22233- stack[base + 44LLU] = 1926LLU/*throw to this address*/;
22369+ stack[base + 44LLU] = 1942LLU/*throw to this address*/;
2223422370 stack[base + 45LLU] = base;
22235- stack[base + 46LLU] = 1927LLU;
22371+ stack[base + 46LLU] = 1943LLU;
2223622372 // arguments for call to FindLet
2223722373 stack[base + 48LLU] = stack[base + 8]/*fnid*/;
2223822374 stack[base + 49LLU] = stack[base + 16]/*content*/;
@@ -22243,13 +22379,13 @@
2224322379 label = 619LLU; // FindLet
2224422380 break;
2224522381 }
22246- case 1926LLU: // copy-back deleter (FindLet to ProcCall)
22382+ case 1942LLU: // copy-back deleter (FindLet to ProcCall)
2224722383 {
2224822384 // copy mutable arguments back from call to FindLet
22249- label = 1831LLU; // continue to roll stack
22385+ label = 1847LLU; // continue to roll stack
2225022386 break;
2225122387 }
22252- case 1927LLU: // return from FindLet to ProcCall
22388+ case 1943LLU: // return from FindLet to ProcCall
2225322389 {
2225422390 // copy mutable arguments back from call to FindLet
2225522391 // copy back results provided by call to FindLet
@@ -22256,7 +22392,7 @@
2225622392 stack[base + 43] = stack[base + 47LLU];
2225722393 if(/*letdef*/0 != ((uint64_t *)(stack[base + 43]/*letdef*/))[0])
2225822394 {
22259- label = 1929LLU; // jump to alternative
22395+ label = 1945LLU; // jump to alternative
2226022396 break;
2226122397 }
2226222398
@@ -22268,9 +22404,9 @@
2226822404
2226922405 // case
2227022406 // call or from ProcCall
22271- stack[base + 49LLU] = 1931LLU/*throw to this address*/;
22407+ stack[base + 49LLU] = 1947LLU/*throw to this address*/;
2227222408 stack[base + 50LLU] = base;
22273- stack[base + 51LLU] = 1932LLU;
22409+ stack[base + 51LLU] = 1948LLU;
2227422410 // arguments for call to or
2227522411 stack[base + 53LLU] = stack[base + 35]/*csubstruct*/;
2227622412 stack[base + 54LLU] = stack[base + 48]/*substruct*/;
@@ -22279,13 +22415,13 @@
2227922415 label = 18446744073709551611LLU; // or
2228022416 break;
2228122417 }
22282- case 1931LLU: // copy-back deleter (or to ProcCall)
22418+ case 1947LLU: // copy-back deleter (or to ProcCall)
2228322419 {
2228422420 // copy mutable arguments back from call to or
22285- label = 1930LLU; // continue to roll stack
22421+ label = 1946LLU; // continue to roll stack
2228622422 break;
2228722423 }
22288- case 1932LLU: // return from or to ProcCall
22424+ case 1948LLU: // return from or to ProcCall
2228922425 {
2229022426 // copy mutable arguments back from call to or
2229122427 // copy back results provided by call to or
@@ -22293,7 +22429,7 @@
2229322429 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2229422430 if(!newstack)
2229522431 {
22296- label = 1930LLU; // throw: begin to unroll stack
22432+ label = 1946LLU; // throw: begin to unroll stack
2229722433 break;
2229822434 }
2229922435
@@ -22300,9 +22436,9 @@
2230022436 newstack[15LLU] = 9876543210LLU; // overflow-marker
2230122437 // call equtype from ProcCall
2230222438 newstack[0] = (uint64_t)stack; // backup stack location
22303- newstack[1] = 1933LLU;
22439+ newstack[1] = 1949LLU;
2230422440 newstack[2] = base;
22305- newstack[3] = 1934LLU;
22441+ newstack[3] = 1950LLU;
2230622442 // arguments for call to equtype
2230722443 newstack[5LLU] = stack[base + 44]/*type*/;
2230822444 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -22312,7 +22448,7 @@
2231222448 label = 359LLU; // equtype
2231322449 break;
2231422450 }
22315- case 1933LLU: // copy-back deleter (equtype to ProcCall)
22451+ case 1949LLU: // copy-back deleter (equtype to ProcCall)
2231622452 {
2231722453 uint64_t *oldstack = (uint64_t *)stack[0];
2231822454 // copy mutable arguments back from call to equtype
@@ -22323,10 +22459,10 @@
2232322459 }
2232422460 Free(15LLU + 1, sizeof(uint64_t), stack);
2232522461 stack = oldstack;
22326- label = 1930LLU; // continue to unroll stack
22462+ label = 1946LLU; // continue to unroll stack
2232722463 break;
2232822464 }
22329- case 1934LLU: // return from equtype to ProcCall
22465+ case 1950LLU: // return from equtype to ProcCall
2233022466 {
2233122467 uint64_t *oldstack = (uint64_t *)stack[0];
2233222468 // copy mutable arguments back from call to equtype
@@ -22341,21 +22477,21 @@
2234122477 stack = oldstack;
2234222478 if(!stack[base + 18]/*isequal*/)
2234322479 {
22344- label = 1935LLU; // jump to alternative
22480+ label = 1951LLU; // jump to alternative
2234522481 break;
2234622482 }
2234722483
2234822484 // consequent
22349- label = 1936LLU; // consequent complete
22485+ label = 1952LLU; // consequent complete
2235022486 break;
2235122487 }
22352- case 1935LLU: // alternative
22488+ case 1951LLU: // alternative
2235322489 {
2235422490 fprintf(stderr, "%s", "in function ");
2235522491 // call reportid from ProcCall
22356- stack[base + 49LLU] = 1937LLU/*throw to this address*/;
22492+ stack[base + 49LLU] = 1953LLU/*throw to this address*/;
2235722493 stack[base + 50LLU] = base;
22358- stack[base + 51LLU] = 1938LLU;
22494+ stack[base + 51LLU] = 1954LLU;
2235922495 // arguments for call to reportid
2236022496 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2236122497 // set stack-base & callee-address
@@ -22363,20 +22499,20 @@
2236322499 label = 18446744073709551586LLU; // reportid
2236422500 break;
2236522501 }
22366- case 1937LLU: // copy-back deleter (reportid to ProcCall)
22502+ case 1953LLU: // copy-back deleter (reportid to ProcCall)
2236722503 {
2236822504 // copy mutable arguments back from call to reportid
22369- label = 1930LLU; // continue to roll stack
22505+ label = 1946LLU; // continue to roll stack
2237022506 break;
2237122507 }
22372- case 1938LLU: // return from reportid to ProcCall
22508+ case 1954LLU: // return from reportid to ProcCall
2237322509 {
2237422510 // copy mutable arguments back from call to reportid
2237522511 fprintf(stderr, "%s", " call to ");
2237622512 // call reportid from ProcCall
22377- stack[base + 49LLU] = 1939LLU/*throw to this address*/;
22513+ stack[base + 49LLU] = 1955LLU/*throw to this address*/;
2237822514 stack[base + 50LLU] = base;
22379- stack[base + 51LLU] = 1940LLU;
22515+ stack[base + 51LLU] = 1956LLU;
2238022516 // arguments for call to reportid
2238122517 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2238222518 // set stack-base & callee-address
@@ -22384,20 +22520,20 @@
2238422520 label = 18446744073709551586LLU; // reportid
2238522521 break;
2238622522 }
22387- case 1939LLU: // copy-back deleter (reportid to ProcCall)
22523+ case 1955LLU: // copy-back deleter (reportid to ProcCall)
2238822524 {
2238922525 // copy mutable arguments back from call to reportid
22390- label = 1930LLU; // continue to roll stack
22526+ label = 1946LLU; // continue to roll stack
2239122527 break;
2239222528 }
22393- case 1940LLU: // return from reportid to ProcCall
22529+ case 1956LLU: // return from reportid to ProcCall
2239422530 {
2239522531 // copy mutable arguments back from call to reportid
2239622532 fprintf(stderr, "%s", " at position ");
2239722533 // call reportnr from ProcCall
22398- stack[base + 49LLU] = 1941LLU/*throw to this address*/;
22534+ stack[base + 49LLU] = 1957LLU/*throw to this address*/;
2239922535 stack[base + 50LLU] = base;
22400- stack[base + 51LLU] = 1942LLU;
22536+ stack[base + 51LLU] = 1958LLU;
2240122537 // arguments for call to reportnr
2240222538 stack[base + 52LLU] = stack[base + 32]/*index*/;
2240322539 // set stack-base & callee-address
@@ -22405,13 +22541,13 @@
2240522541 label = 18446744073709551589LLU; // reportnr
2240622542 break;
2240722543 }
22408- case 1941LLU: // copy-back deleter (reportnr to ProcCall)
22544+ case 1957LLU: // copy-back deleter (reportnr to ProcCall)
2240922545 {
2241022546 // copy mutable arguments back from call to reportnr
22411- label = 1930LLU; // continue to roll stack
22547+ label = 1946LLU; // continue to roll stack
2241222548 break;
2241322549 }
22414- case 1942LLU: // return from reportnr to ProcCall
22550+ case 1958LLU: // return from reportnr to ProcCall
2241522551 {
2241622552 // copy mutable arguments back from call to reportnr
2241722553 fprintf(stderr, "%s", " parameter type ");
@@ -22418,7 +22554,7 @@
2241822554 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2241922555 if(!newstack)
2242022556 {
22421- label = 1930LLU; // throw: begin to unroll stack
22557+ label = 1946LLU; // throw: begin to unroll stack
2242222558 break;
2242322559 }
2242422560
@@ -22425,9 +22561,9 @@
2242522561 newstack[10LLU] = 9876543210LLU; // overflow-marker
2242622562 // call reporttype from ProcCall
2242722563 newstack[0] = (uint64_t)stack; // backup stack location
22428- newstack[1] = 1943LLU;
22564+ newstack[1] = 1959LLU;
2242922565 newstack[2] = base;
22430- newstack[3] = 1944LLU;
22566+ newstack[3] = 1960LLU;
2243122567 // arguments for call to reporttype
2243222568 newstack[4LLU] = stack[base + 41]/*expected*/;
2243322569 stack = newstack;
@@ -22436,7 +22572,7 @@
2243622572 label = 330LLU; // reporttype
2243722573 break;
2243822574 }
22439- case 1943LLU: // copy-back deleter (reporttype to ProcCall)
22575+ case 1959LLU: // copy-back deleter (reporttype to ProcCall)
2244022576 {
2244122577 uint64_t *oldstack = (uint64_t *)stack[0];
2244222578 // copy mutable arguments back from call to reporttype
@@ -22447,10 +22583,10 @@
2244722583 }
2244822584 Free(10LLU + 1, sizeof(uint64_t), stack);
2244922585 stack = oldstack;
22450- label = 1930LLU; // continue to unroll stack
22586+ label = 1946LLU; // continue to unroll stack
2245122587 break;
2245222588 }
22453- case 1944LLU: // return from reporttype to ProcCall
22589+ case 1960LLU: // return from reporttype to ProcCall
2245422590 {
2245522591 uint64_t *oldstack = (uint64_t *)stack[0];
2245622592 // copy mutable arguments back from call to reporttype
@@ -22465,7 +22601,7 @@
2246522601 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2246622602 if(!newstack)
2246722603 {
22468- label = 1930LLU; // throw: begin to unroll stack
22604+ label = 1946LLU; // throw: begin to unroll stack
2246922605 break;
2247022606 }
2247122607
@@ -22472,9 +22608,9 @@
2247222608 newstack[10LLU] = 9876543210LLU; // overflow-marker
2247322609 // call reporttype from ProcCall
2247422610 newstack[0] = (uint64_t)stack; // backup stack location
22475- newstack[1] = 1945LLU;
22611+ newstack[1] = 1961LLU;
2247622612 newstack[2] = base;
22477- newstack[3] = 1946LLU;
22613+ newstack[3] = 1962LLU;
2247822614 // arguments for call to reporttype
2247922615 newstack[4LLU] = stack[base + 44]/*type*/;
2248022616 stack = newstack;
@@ -22483,7 +22619,7 @@
2248322619 label = 330LLU; // reporttype
2248422620 break;
2248522621 }
22486- case 1945LLU: // copy-back deleter (reporttype to ProcCall)
22622+ case 1961LLU: // copy-back deleter (reporttype to ProcCall)
2248722623 {
2248822624 uint64_t *oldstack = (uint64_t *)stack[0];
2248922625 // copy mutable arguments back from call to reporttype
@@ -22494,10 +22630,10 @@
2249422630 }
2249522631 Free(10LLU + 1, sizeof(uint64_t), stack);
2249622632 stack = oldstack;
22497- label = 1930LLU; // continue to unroll stack
22633+ label = 1946LLU; // continue to unroll stack
2249822634 break;
2249922635 }
22500- case 1946LLU: // return from reporttype to ProcCall
22636+ case 1962LLU: // return from reporttype to ProcCall
2250122637 {
2250222638 uint64_t *oldstack = (uint64_t *)stack[0];
2250322639 // copy mutable arguments back from call to reporttype
@@ -22510,18 +22646,18 @@
2251022646 stack = oldstack;
2251122647 fprintf(stderr, "%s", "\n");
2251222648 {
22513- label = 1930LLU; // throw: begin to unroll stack
22649+ label = 1946LLU; // throw: begin to unroll stack
2251422650 break;
2251522651 }
2251622652
22517- label = 1936LLU; // alternative complete
22653+ label = 1952LLU; // alternative complete
2251822654 break;
2251922655 }
22520- case 1936LLU: // completed if-then-else
22656+ case 1952LLU: // completed if-then-else
2252122657 {
2252222658 if(!stack[base + 40]/*mutable*/)
2252322659 {
22524- label = 1947LLU; // jump to alternative
22660+ label = 1963LLU; // jump to alternative
2252522661 break;
2252622662 }
2252722663
@@ -22528,31 +22664,31 @@
2252822664 // consequent
2252922665 if(!stack[base + 47]/*mutarg*/)
2253022666 {
22531- label = 1949LLU; // jump to alternative
22667+ label = 1965LLU; // jump to alternative
2253222668 break;
2253322669 }
2253422670
2253522671 // consequent
22536- label = 1952LLU; // skip deleter
22672+ label = 1968LLU; // skip deleter
2253722673 break;
2253822674 }
22539- case 1951LLU: // deleter
22675+ case 1967LLU: // deleter
2254022676 {
2254122677 // throw from ProcCall
2254222678 if(!stack[base + 49])
2254322679 {
22544- label = 1930LLU; // skip, variable already deleted/unscoped
22680+ label = 1946LLU; // skip, variable already deleted/unscoped
2254522681 break;
2254622682 }
22547- label = 1930LLU; // continue unrolling stack, delete next variable
22683+ label = 1946LLU; // continue unrolling stack, delete next variable
2254822684 break;
2254922685 }
22550- case 1952LLU: // skipped deleter
22686+ case 1968LLU: // skipped deleter
2255122687 {
2255222688 // call lookidnr from ProcCall
22553- stack[base + 50LLU] = 1953LLU/*throw to this address*/;
22689+ stack[base + 50LLU] = 1969LLU/*throw to this address*/;
2255422690 stack[base + 51LLU] = base;
22555- stack[base + 52LLU] = 1954LLU;
22691+ stack[base + 52LLU] = 1970LLU;
2255622692 // arguments for call to lookidnr
2255722693 stack[base + 54LLU] = stack[base + 19]/*copyback*/;
2255822694 stack[base + 55LLU] = stack[base + 16]/*content*/;
@@ -22561,13 +22697,13 @@
2256122697 label = 835LLU; // lookidnr
2256222698 break;
2256322699 }
22564- case 1953LLU: // copy-back deleter (lookidnr to ProcCall)
22700+ case 1969LLU: // copy-back deleter (lookidnr to ProcCall)
2256522701 {
2256622702 // copy mutable arguments back from call to lookidnr
22567- label = 1930LLU; // continue to roll stack
22703+ label = 1946LLU; // continue to roll stack
2256822704 break;
2256922705 }
22570- case 1954LLU: // return from lookidnr to ProcCall
22706+ case 1970LLU: // return from lookidnr to ProcCall
2257122707 {
2257222708 // copy mutable arguments back from call to lookidnr
2257322709 // copy back results provided by call to lookidnr
@@ -22574,7 +22710,7 @@
2257422710 stack[base + 49] = stack[base + 53LLU];
2257522711 if(!stack[base + 49]/*found*/)
2257622712 {
22577- label = 1955LLU; // jump to alternative
22713+ label = 1971LLU; // jump to alternative
2257822714 break;
2257922715 }
2258022716
@@ -22581,9 +22717,9 @@
2258122717 // consequent
2258222718 fprintf(stderr, "%s", "in function ");
2258322719 // call reportid from ProcCall
22584- stack[base + 50LLU] = 1957LLU/*throw to this address*/;
22720+ stack[base + 50LLU] = 1973LLU/*throw to this address*/;
2258522721 stack[base + 51LLU] = base;
22586- stack[base + 52LLU] = 1958LLU;
22722+ stack[base + 52LLU] = 1974LLU;
2258722723 // arguments for call to reportid
2258822724 stack[base + 53LLU] = stack[base + 8]/*fnid*/;
2258922725 // set stack-base & callee-address
@@ -22591,20 +22727,20 @@
2259122727 label = 18446744073709551586LLU; // reportid
2259222728 break;
2259322729 }
22594- case 1957LLU: // copy-back deleter (reportid to ProcCall)
22730+ case 1973LLU: // copy-back deleter (reportid to ProcCall)
2259522731 {
2259622732 // copy mutable arguments back from call to reportid
22597- label = 1951LLU; // continue to roll stack
22733+ label = 1967LLU; // continue to roll stack
2259822734 break;
2259922735 }
22600- case 1958LLU: // return from reportid to ProcCall
22736+ case 1974LLU: // return from reportid to ProcCall
2260122737 {
2260222738 // copy mutable arguments back from call to reportid
2260322739 fprintf(stderr, "%s", " call to ");
2260422740 // call reportid from ProcCall
22605- stack[base + 50LLU] = 1959LLU/*throw to this address*/;
22741+ stack[base + 50LLU] = 1975LLU/*throw to this address*/;
2260622742 stack[base + 51LLU] = base;
22607- stack[base + 52LLU] = 1960LLU;
22743+ stack[base + 52LLU] = 1976LLU;
2260822744 // arguments for call to reportid
2260922745 stack[base + 53LLU] = stack[base + 24]/*ceid*/;
2261022746 // set stack-base & callee-address
@@ -22612,20 +22748,20 @@
2261222748 label = 18446744073709551586LLU; // reportid
2261322749 break;
2261422750 }
22615- case 1959LLU: // copy-back deleter (reportid to ProcCall)
22751+ case 1975LLU: // copy-back deleter (reportid to ProcCall)
2261622752 {
2261722753 // copy mutable arguments back from call to reportid
22618- label = 1951LLU; // continue to roll stack
22754+ label = 1967LLU; // continue to roll stack
2261922755 break;
2262022756 }
22621- case 1960LLU: // return from reportid to ProcCall
22757+ case 1976LLU: // return from reportid to ProcCall
2262222758 {
2262322759 // copy mutable arguments back from call to reportid
2262422760 fprintf(stderr, "%s", " - duplicate mutable argument ");
2262522761 // call reportid from ProcCall
22626- stack[base + 50LLU] = 1961LLU/*throw to this address*/;
22762+ stack[base + 50LLU] = 1977LLU/*throw to this address*/;
2262722763 stack[base + 51LLU] = base;
22628- stack[base + 52LLU] = 1962LLU;
22764+ stack[base + 52LLU] = 1978LLU;
2262922765 // arguments for call to reportid
2263022766 stack[base + 53LLU] = stack[base + 16]/*content*/;
2263122767 // set stack-base & callee-address
@@ -22633,40 +22769,40 @@
2263322769 label = 18446744073709551586LLU; // reportid
2263422770 break;
2263522771 }
22636- case 1961LLU: // copy-back deleter (reportid to ProcCall)
22772+ case 1977LLU: // copy-back deleter (reportid to ProcCall)
2263722773 {
2263822774 // copy mutable arguments back from call to reportid
22639- label = 1951LLU; // continue to roll stack
22775+ label = 1967LLU; // continue to roll stack
2264022776 break;
2264122777 }
22642- case 1962LLU: // return from reportid to ProcCall
22778+ case 1978LLU: // return from reportid to ProcCall
2264322779 {
2264422780 // copy mutable arguments back from call to reportid
2264522781 fprintf(stderr, "%s", "\n");
2264622782 {
22647- label = 1951LLU; // throw: begin to unroll stack
22783+ label = 1967LLU; // throw: begin to unroll stack
2264822784 break;
2264922785 }
2265022786
22651- label = 1956LLU; // consequent complete
22787+ label = 1972LLU; // consequent complete
2265222788 break;
2265322789 }
22654- case 1955LLU: // alternative
22790+ case 1971LLU: // alternative
2265522791 {
22656- label = 1956LLU; // alternative complete
22792+ label = 1972LLU; // alternative complete
2265722793 break;
2265822794 }
22659- case 1956LLU: // completed if-then-else
22795+ case 1972LLU: // completed if-then-else
2266022796 {
22661- label = 1964LLU; // skip deleter
22797+ label = 1980LLU; // skip deleter
2266222798 break;
2266322799 }
22664- case 1963LLU: // deleter
22800+ case 1979LLU: // deleter
2266522801 {
2266622802 // throw from ProcCall
2266722803 if(!stack[base + 49])
2266822804 {
22669- label = 1930LLU; // skip, variable already deleted/unscoped
22805+ label = 1946LLU; // skip, variable already deleted/unscoped
2267022806 break;
2267122807 }
2267222808
@@ -22675,7 +22811,7 @@
2267522811 newstack[0] = (uint64_t)stack; // backup stack location
2267622812 newstack[1] = 1234567890;
2267722813 newstack[2] = base;
22678- newstack[3] = 1965LLU;
22814+ newstack[3] = 1981LLU;
2267922815 stack = newstack;
2268022816 // set stack-base & callee-address
2268122817 base = 4/*deloffset*/;
@@ -22682,21 +22818,21 @@
2268222818 label = 833LLU; // ~idnr
2268322819 break;
2268422820 }
22685- case 1965LLU: // return from ~idnr to ProcCall
22821+ case 1981LLU: // return from ~idnr to ProcCall
2268622822 {
2268722823 stack = (uint64_t *)stack[0];
2268822824 // releasing toplevel container
2268922825 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4));
2269022826
22691- label = 1930LLU; // continue unrolling stack, delete next variable
22827+ label = 1946LLU; // continue unrolling stack, delete next variable
2269222828 break;
2269322829 }
22694- case 1964LLU: // skipped deleter
22830+ case 1980LLU: // skipped deleter
2269522831 {
2269622832 // construct idnr.idnr
2269722833 if(!(stack[base + 49] = construct(2)))
2269822834 {
22699- label = 1930LLU; // throw: begin to unroll stack
22835+ label = 1946LLU; // throw: begin to unroll stack
2270022836 break;
2270122837 }
2270222838
@@ -22717,16 +22853,16 @@
2271722853 /*copyback*/stack[base + 19] = (uint64_t)list;
2271822854 MOVE(&list->data, &stack[base + 49]/*idnr*/);
2271922855 }
22720- label = 1950LLU; // consequent complete
22856+ label = 1966LLU; // consequent complete
2272122857 break;
2272222858 }
22723- case 1949LLU: // alternative
22859+ case 1965LLU: // alternative
2272422860 {
2272522861 fprintf(stderr, "%s", "in function ");
2272622862 // call reportid from ProcCall
22727- stack[base + 49LLU] = 1966LLU/*throw to this address*/;
22863+ stack[base + 49LLU] = 1982LLU/*throw to this address*/;
2272822864 stack[base + 50LLU] = base;
22729- stack[base + 51LLU] = 1967LLU;
22865+ stack[base + 51LLU] = 1983LLU;
2273022866 // arguments for call to reportid
2273122867 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2273222868 // set stack-base & callee-address
@@ -22734,20 +22870,20 @@
2273422870 label = 18446744073709551586LLU; // reportid
2273522871 break;
2273622872 }
22737- case 1966LLU: // copy-back deleter (reportid to ProcCall)
22873+ case 1982LLU: // copy-back deleter (reportid to ProcCall)
2273822874 {
2273922875 // copy mutable arguments back from call to reportid
22740- label = 1930LLU; // continue to roll stack
22876+ label = 1946LLU; // continue to roll stack
2274122877 break;
2274222878 }
22743- case 1967LLU: // return from reportid to ProcCall
22879+ case 1983LLU: // return from reportid to ProcCall
2274422880 {
2274522881 // copy mutable arguments back from call to reportid
2274622882 fprintf(stderr, "%s", ", call to ");
2274722883 // call reportid from ProcCall
22748- stack[base + 49LLU] = 1968LLU/*throw to this address*/;
22884+ stack[base + 49LLU] = 1984LLU/*throw to this address*/;
2274922885 stack[base + 50LLU] = base;
22750- stack[base + 51LLU] = 1969LLU;
22886+ stack[base + 51LLU] = 1985LLU;
2275122887 // arguments for call to reportid
2275222888 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2275322889 // set stack-base & callee-address
@@ -22755,13 +22891,13 @@
2275522891 label = 18446744073709551586LLU; // reportid
2275622892 break;
2275722893 }
22758- case 1968LLU: // copy-back deleter (reportid to ProcCall)
22894+ case 1984LLU: // copy-back deleter (reportid to ProcCall)
2275922895 {
2276022896 // copy mutable arguments back from call to reportid
22761- label = 1930LLU; // continue to roll stack
22897+ label = 1946LLU; // continue to roll stack
2276222898 break;
2276322899 }
22764- case 1969LLU: // return from reportid to ProcCall
22900+ case 1985LLU: // return from reportid to ProcCall
2276522901 {
2276622902 // copy mutable arguments back from call to reportid
2276722903 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -22768,7 +22904,7 @@
2276822904 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2276922905 if(!newstack)
2277022906 {
22771- label = 1930LLU; // throw: begin to unroll stack
22907+ label = 1946LLU; // throw: begin to unroll stack
2277222908 break;
2277322909 }
2277422910
@@ -22775,9 +22911,9 @@
2277522911 newstack[10LLU] = 9876543210LLU; // overflow-marker
2277622912 // call reporttype from ProcCall
2277722913 newstack[0] = (uint64_t)stack; // backup stack location
22778- newstack[1] = 1970LLU;
22914+ newstack[1] = 1986LLU;
2277922915 newstack[2] = base;
22780- newstack[3] = 1971LLU;
22916+ newstack[3] = 1987LLU;
2278122917 // arguments for call to reporttype
2278222918 newstack[4LLU] = stack[base + 44]/*type*/;
2278322919 stack = newstack;
@@ -22786,7 +22922,7 @@
2278622922 label = 330LLU; // reporttype
2278722923 break;
2278822924 }
22789- case 1970LLU: // copy-back deleter (reporttype to ProcCall)
22925+ case 1986LLU: // copy-back deleter (reporttype to ProcCall)
2279022926 {
2279122927 uint64_t *oldstack = (uint64_t *)stack[0];
2279222928 // copy mutable arguments back from call to reporttype
@@ -22797,10 +22933,10 @@
2279722933 }
2279822934 Free(10LLU + 1, sizeof(uint64_t), stack);
2279922935 stack = oldstack;
22800- label = 1930LLU; // continue to unroll stack
22936+ label = 1946LLU; // continue to unroll stack
2280122937 break;
2280222938 }
22803- case 1971LLU: // return from reporttype to ProcCall
22939+ case 1987LLU: // return from reporttype to ProcCall
2280422940 {
2280522941 uint64_t *oldstack = (uint64_t *)stack[0];
2280622942 // copy mutable arguments back from call to reporttype
@@ -22813,9 +22949,9 @@
2281322949 stack = oldstack;
2281422950 fprintf(stderr, "%s", " ");
2281522951 // call reportid from ProcCall
22816- stack[base + 49LLU] = 1972LLU/*throw to this address*/;
22952+ stack[base + 49LLU] = 1988LLU/*throw to this address*/;
2281722953 stack[base + 50LLU] = base;
22818- stack[base + 51LLU] = 1973LLU;
22954+ stack[base + 51LLU] = 1989LLU;
2281922955 // arguments for call to reportid
2282022956 stack[base + 52LLU] = stack[base + 16]/*content*/;
2282122957 // set stack-base & callee-address
@@ -22823,13 +22959,13 @@
2282322959 label = 18446744073709551586LLU; // reportid
2282422960 break;
2282522961 }
22826- case 1972LLU: // copy-back deleter (reportid to ProcCall)
22962+ case 1988LLU: // copy-back deleter (reportid to ProcCall)
2282722963 {
2282822964 // copy mutable arguments back from call to reportid
22829- label = 1930LLU; // continue to roll stack
22965+ label = 1946LLU; // continue to roll stack
2283022966 break;
2283122967 }
22832- case 1973LLU: // return from reportid to ProcCall
22968+ case 1989LLU: // return from reportid to ProcCall
2283322969 {
2283422970 // copy mutable arguments back from call to reportid
2283522971 fprintf(stderr, "%s", " into mutable parameter ");
@@ -22836,7 +22972,7 @@
2283622972 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2283722973 if(!newstack)
2283822974 {
22839- label = 1930LLU; // throw: begin to unroll stack
22975+ label = 1946LLU; // throw: begin to unroll stack
2284022976 break;
2284122977 }
2284222978
@@ -22843,9 +22979,9 @@
2284322979 newstack[10LLU] = 9876543210LLU; // overflow-marker
2284422980 // call reporttype from ProcCall
2284522981 newstack[0] = (uint64_t)stack; // backup stack location
22846- newstack[1] = 1974LLU;
22982+ newstack[1] = 1990LLU;
2284722983 newstack[2] = base;
22848- newstack[3] = 1975LLU;
22984+ newstack[3] = 1991LLU;
2284922985 // arguments for call to reporttype
2285022986 newstack[4LLU] = stack[base + 41]/*expected*/;
2285122987 stack = newstack;
@@ -22854,7 +22990,7 @@
2285422990 label = 330LLU; // reporttype
2285522991 break;
2285622992 }
22857- case 1974LLU: // copy-back deleter (reporttype to ProcCall)
22993+ case 1990LLU: // copy-back deleter (reporttype to ProcCall)
2285822994 {
2285922995 uint64_t *oldstack = (uint64_t *)stack[0];
2286022996 // copy mutable arguments back from call to reporttype
@@ -22865,10 +23001,10 @@
2286523001 }
2286623002 Free(10LLU + 1, sizeof(uint64_t), stack);
2286723003 stack = oldstack;
22868- label = 1930LLU; // continue to unroll stack
23004+ label = 1946LLU; // continue to unroll stack
2286923005 break;
2287023006 }
22871- case 1975LLU: // return from reporttype to ProcCall
23007+ case 1991LLU: // return from reporttype to ProcCall
2287223008 {
2287323009 uint64_t *oldstack = (uint64_t *)stack[0];
2287423010 // copy mutable arguments back from call to reporttype
@@ -22880,9 +23016,9 @@
2288023016 Free(10LLU + 1, sizeof(uint64_t), stack);
2288123017 stack = oldstack;
2288223018 // call reportid from ProcCall
22883- stack[base + 49LLU] = 1976LLU/*throw to this address*/;
23019+ stack[base + 49LLU] = 1992LLU/*throw to this address*/;
2288423020 stack[base + 50LLU] = base;
22885- stack[base + 51LLU] = 1977LLU;
23021+ stack[base + 51LLU] = 1993LLU;
2288623022 // arguments for call to reportid
2288723023 stack[base + 52LLU] = stack[base + 42]/*paramname*/;
2288823024 // set stack-base & callee-address
@@ -22890,35 +23026,35 @@
2289023026 label = 18446744073709551586LLU; // reportid
2289123027 break;
2289223028 }
22893- case 1976LLU: // copy-back deleter (reportid to ProcCall)
23029+ case 1992LLU: // copy-back deleter (reportid to ProcCall)
2289423030 {
2289523031 // copy mutable arguments back from call to reportid
22896- label = 1930LLU; // continue to roll stack
23032+ label = 1946LLU; // continue to roll stack
2289723033 break;
2289823034 }
22899- case 1977LLU: // return from reportid to ProcCall
23035+ case 1993LLU: // return from reportid to ProcCall
2290023036 {
2290123037 // copy mutable arguments back from call to reportid
2290223038 fprintf(stderr, "%s", "\n");
2290323039 {
22904- label = 1930LLU; // throw: begin to unroll stack
23040+ label = 1946LLU; // throw: begin to unroll stack
2290523041 break;
2290623042 }
2290723043
22908- label = 1950LLU; // alternative complete
23044+ label = 1966LLU; // alternative complete
2290923045 break;
2291023046 }
22911- case 1950LLU: // completed if-then-else
23047+ case 1966LLU: // completed if-then-else
2291223048 {
22913- label = 1948LLU; // consequent complete
23049+ label = 1964LLU; // consequent complete
2291423050 break;
2291523051 }
22916- case 1947LLU: // alternative
23052+ case 1963LLU: // alternative
2291723053 {
22918- label = 1948LLU; // alternative complete
23054+ label = 1964LLU; // alternative complete
2291923055 break;
2292023056 }
22921- case 1948LLU: // completed if-then-else
23057+ case 1964LLU: // completed if-then-else
2292223058 {
2292323059 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2292423060 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -22925,10 +23061,10 @@
2292523061 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2292623062 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2292723063 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
22928- label = 1928LLU; // case complete
23064+ label = 1944LLU; // case complete
2292923065 break;
2293023066 }
22931- case 1930LLU: // copy-back deleter (switch)
23067+ case 1946LLU: // copy-back deleter (switch)
2293223068 {
2293323069 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2293423070 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -22935,21 +23071,21 @@
2293523071 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2293623072 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2293723073 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
22938- label = 1923LLU; // continue to unroll stack
23074+ label = 1939LLU; // continue to unroll stack
2293923075 break;
2294023076 }
22941- case 1929LLU: // try next case
23077+ case 1945LLU: // try next case
2294223078 {
2294323079 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2294423080 exit(-1);
2294523081 }
22946- case 1928LLU: // completed switch
23082+ case 1944LLU: // completed switch
2294723083 {
2294823084 printf("%s", "\n newstack[");
2294923085 // call printnr from ProcCall
22950- stack[base + 44LLU] = 1978LLU/*throw to this address*/;
23086+ stack[base + 44LLU] = 1994LLU/*throw to this address*/;
2295123087 stack[base + 45LLU] = base;
22952- stack[base + 46LLU] = 1979LLU;
23088+ stack[base + 46LLU] = 1995LLU;
2295323089 // arguments for call to printnr
2295423090 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2295523091 // set stack-base & callee-address
@@ -22957,20 +23093,20 @@
2295723093 label = 18446744073709551590LLU; // printnr
2295823094 break;
2295923095 }
22960- case 1978LLU: // copy-back deleter (printnr to ProcCall)
23096+ case 1994LLU: // copy-back deleter (printnr to ProcCall)
2296123097 {
2296223098 // copy mutable arguments back from call to printnr
22963- label = 1923LLU; // continue to roll stack
23099+ label = 1939LLU; // continue to roll stack
2296423100 break;
2296523101 }
22966- case 1979LLU: // return from printnr to ProcCall
23102+ case 1995LLU: // return from printnr to ProcCall
2296723103 {
2296823104 // copy mutable arguments back from call to printnr
2296923105 printf("%s", "LLU] = ");
2297023106 // call emitvar from ProcCall
22971- stack[base + 44LLU] = 1980LLU/*throw to this address*/;
23107+ stack[base + 44LLU] = 1996LLU/*throw to this address*/;
2297223108 stack[base + 45LLU] = base;
22973- stack[base + 46LLU] = 1981LLU;
23109+ stack[base + 46LLU] = 1997LLU;
2297423110 // arguments for call to emitvar
2297523111 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2297623112 stack[base + 48LLU] = stack[base + 16]/*content*/;
@@ -22981,13 +23117,13 @@
2298123117 label = 749LLU; // emitvar
2298223118 break;
2298323119 }
22984- case 1980LLU: // copy-back deleter (emitvar to ProcCall)
23120+ case 1996LLU: // copy-back deleter (emitvar to ProcCall)
2298523121 {
2298623122 // copy mutable arguments back from call to emitvar
22987- label = 1923LLU; // continue to roll stack
23123+ label = 1939LLU; // continue to roll stack
2298823124 break;
2298923125 }
22990- case 1981LLU: // return from emitvar to ProcCall
23126+ case 1997LLU: // return from emitvar to ProcCall
2299123127 {
2299223128 // copy mutable arguments back from call to emitvar
2299323129 printf("%s", ";");
@@ -22997,7 +23133,7 @@
2299723133 newstack[0] = (uint64_t)stack; // backup stack location
2299823134 newstack[1] = 1234567890;
2299923135 newstack[2] = base;
23000- newstack[3] = 1982LLU;
23136+ newstack[3] = 1998LLU;
2300123137 stack = newstack;
2300223138 // set stack-base & callee-address
2300323139 base = 4/*deloffset*/;
@@ -23004,27 +23140,27 @@
2300423140 label = 486LLU; // ~letdef
2300523141 break;
2300623142 }
23007- case 1982LLU: // return from ~letdef to ProcCall
23143+ case 1998LLU: // return from ~letdef to ProcCall
2300823144 {
2300923145 stack = (uint64_t *)stack[0];
2301023146 // releasing toplevel container
2301123147 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2301223148
23013- label = 1879LLU; // alternative complete
23149+ label = 1895LLU; // alternative complete
2301423150 break;
2301523151 }
23016- case 1879LLU: // completed if-then-else
23152+ case 1895LLU: // completed if-then-else
2301723153 {
23018- label = 1875LLU; // consequent complete
23154+ label = 1891LLU; // consequent complete
2301923155 break;
2302023156 }
23021- case 1874LLU: // alternative
23157+ case 1890LLU: // alternative
2302223158 {
2302323159 fprintf(stderr, "%s", "in function ");
2302423160 // call reportid from ProcCall
23025- stack[base + 43LLU] = 1983LLU/*throw to this address*/;
23161+ stack[base + 43LLU] = 1999LLU/*throw to this address*/;
2302623162 stack[base + 44LLU] = base;
23027- stack[base + 45LLU] = 1984LLU;
23163+ stack[base + 45LLU] = 2000LLU;
2302823164 // arguments for call to reportid
2302923165 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2303023166 // set stack-base & callee-address
@@ -23032,20 +23168,20 @@
2303223168 label = 18446744073709551586LLU; // reportid
2303323169 break;
2303423170 }
23035- case 1983LLU: // copy-back deleter (reportid to ProcCall)
23171+ case 1999LLU: // copy-back deleter (reportid to ProcCall)
2303623172 {
2303723173 // copy mutable arguments back from call to reportid
23038- label = 1831LLU; // continue to roll stack
23174+ label = 1847LLU; // continue to roll stack
2303923175 break;
2304023176 }
23041- case 1984LLU: // return from reportid to ProcCall
23177+ case 2000LLU: // return from reportid to ProcCall
2304223178 {
2304323179 // copy mutable arguments back from call to reportid
2304423180 fprintf(stderr, "%s", " call to ");
2304523181 // call reportid from ProcCall
23046- stack[base + 43LLU] = 1985LLU/*throw to this address*/;
23182+ stack[base + 43LLU] = 2001LLU/*throw to this address*/;
2304723183 stack[base + 44LLU] = base;
23048- stack[base + 45LLU] = 1986LLU;
23184+ stack[base + 45LLU] = 2002LLU;
2304923185 // arguments for call to reportid
2305023186 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2305123187 // set stack-base & callee-address
@@ -23053,20 +23189,20 @@
2305323189 label = 18446744073709551586LLU; // reportid
2305423190 break;
2305523191 }
23056- case 1985LLU: // copy-back deleter (reportid to ProcCall)
23192+ case 2001LLU: // copy-back deleter (reportid to ProcCall)
2305723193 {
2305823194 // copy mutable arguments back from call to reportid
23059- label = 1831LLU; // continue to roll stack
23195+ label = 1847LLU; // continue to roll stack
2306023196 break;
2306123197 }
23062- case 1986LLU: // return from reportid to ProcCall
23198+ case 2002LLU: // return from reportid to ProcCall
2306323199 {
2306423200 // copy mutable arguments back from call to reportid
2306523201 fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
2306623202 // call printtoken from ProcCall
23067- stack[base + 43LLU] = 1987LLU/*throw to this address*/;
23203+ stack[base + 43LLU] = 2003LLU/*throw to this address*/;
2306823204 stack[base + 44LLU] = base;
23069- stack[base + 45LLU] = 1988LLU;
23205+ stack[base + 45LLU] = 2004LLU;
2307023206 // arguments for call to printtoken
2307123207 stack[base + 46LLU] = stack[base + 15]/*variant*/;
2307223208 stack[base + 47LLU] = stack[base + 16]/*content*/;
@@ -23075,85 +23211,85 @@
2307523211 label = 18446744073709551583LLU; // printtoken
2307623212 break;
2307723213 }
23078- case 1987LLU: // copy-back deleter (printtoken to ProcCall)
23214+ case 2003LLU: // copy-back deleter (printtoken to ProcCall)
2307923215 {
2308023216 // copy mutable arguments back from call to printtoken
23081- label = 1831LLU; // continue to roll stack
23217+ label = 1847LLU; // continue to roll stack
2308223218 break;
2308323219 }
23084- case 1988LLU: // return from printtoken to ProcCall
23220+ case 2004LLU: // return from printtoken to ProcCall
2308523221 {
2308623222 // copy mutable arguments back from call to printtoken
2308723223 fprintf(stderr, "%s", "\n");
2308823224 {
23089- label = 1831LLU; // throw: begin to unroll stack
23225+ label = 1847LLU; // throw: begin to unroll stack
2309023226 break;
2309123227 }
2309223228
23093- label = 1875LLU; // alternative complete
23229+ label = 1891LLU; // alternative complete
2309423230 break;
2309523231 }
23096- case 1875LLU: // completed if-then-else
23232+ case 1891LLU: // completed if-then-else
2309723233 {
23098- label = 1837LLU; // alternative complete
23234+ label = 1853LLU; // alternative complete
2309923235 break;
2310023236 }
23101- case 1837LLU: // completed if-then-else
23237+ case 1853LLU: // completed if-then-else
2310223238 {
2310323239 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2310423240 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23105- label = 1829LLU; // case complete
23241+ label = 1845LLU; // case complete
2310623242 break;
2310723243 }
23108- case 1831LLU: // copy-back deleter (switch)
23244+ case 1847LLU: // copy-back deleter (switch)
2310923245 {
2311023246 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2311123247 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23112- label = 1828LLU; // continue to unroll stack
23248+ label = 1844LLU; // continue to unroll stack
2311323249 break;
2311423250 }
23115- case 1830LLU: // try next case
23251+ case 1846LLU: // try next case
2311623252 {
2311723253 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2311823254 exit(-1);
2311923255 }
23120- case 1829LLU: // completed switch
23256+ case 1845LLU: // completed switch
2312123257 {
2312223258 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2312323259 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23124- label = 1826LLU; // case complete
23260+ label = 1842LLU; // case complete
2312523261 break;
2312623262 }
23127- case 1828LLU: // copy-back deleter (switch)
23263+ case 1844LLU: // copy-back deleter (switch)
2312823264 {
2312923265 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2313023266 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23131- label = 1811LLU; // continue to unroll stack
23267+ label = 1827LLU; // continue to unroll stack
2313223268 break;
2313323269 }
23134- case 1827LLU: // try next case
23270+ case 1843LLU: // try next case
2313523271 {
2313623272 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2313723273 exit(-1);
2313823274 }
23139- case 1826LLU: // completed switch
23275+ case 1842LLU: // completed switch
2314023276 {
2314123277 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23142- label = 1809LLU; // repeat
23278+ label = 1825LLU; // repeat
2314323279 break;
2314423280 }
23145- case 1811LLU: // copy-back deleter for while next
23281+ case 1827LLU: // copy-back deleter for while next
2314623282 {
2314723283 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23148- label = 1807LLU; // continue to unroll stack
23284+ label = 1823LLU; // continue to unroll stack
2314923285 break;
2315023286 }
23151- case 1810LLU: // loop finished
23287+ case 1826LLU: // loop finished
2315223288 {
2315323289 // call equ from ProcCall
23154- stack[base + 39LLU] = 1989LLU/*throw to this address*/;
23290+ stack[base + 39LLU] = 2005LLU/*throw to this address*/;
2315523291 stack[base + 40LLU] = base;
23156- stack[base + 41LLU] = 1990LLU;
23292+ stack[base + 41LLU] = 2006LLU;
2315723293 // arguments for call to equ
2315823294 stack[base + 43LLU] = stack[base + 8]/*fnid*/;
2315923295 stack[base + 44LLU] = stack[base + 24]/*ceid*/;
@@ -23162,13 +23298,13 @@
2316223298 label = 18446744073709551600LLU; // equ
2316323299 break;
2316423300 }
23165- case 1989LLU: // copy-back deleter (equ to ProcCall)
23301+ case 2005LLU: // copy-back deleter (equ to ProcCall)
2316623302 {
2316723303 // copy mutable arguments back from call to equ
23168- label = 1807LLU; // continue to roll stack
23304+ label = 1823LLU; // continue to roll stack
2316923305 break;
2317023306 }
23171- case 1990LLU: // return from equ to ProcCall
23307+ case 2006LLU: // return from equ to ProcCall
2317223308 {
2317323309 // copy mutable arguments back from call to equ
2317423310 // copy back results provided by call to equ
@@ -23175,7 +23311,7 @@
2317523311 stack[base + 18] = stack[base + 42LLU];
2317623312 if(!stack[base + 18]/*isequal*/)
2317723313 {
23178- label = 1991LLU; // jump to alternative
23314+ label = 2007LLU; // jump to alternative
2317923315 break;
2318023316 }
2318123317
@@ -23182,21 +23318,21 @@
2318223318 // consequent
2318323319 if(!stack[base + 35]/*csubstruct*/)
2318423320 {
23185- label = 1993LLU; // jump to alternative
23321+ label = 2009LLU; // jump to alternative
2318623322 break;
2318723323 }
2318823324
2318923325 // consequent
23190- label = 1994LLU; // consequent complete
23326+ label = 2010LLU; // consequent complete
2319123327 break;
2319223328 }
23193- case 1993LLU: // alternative
23329+ case 2009LLU: // alternative
2319423330 {
2319523331 fprintf(stderr, "%s", "in function ");
2319623332 // call reportid from ProcCall
23197- stack[base + 39LLU] = 1995LLU/*throw to this address*/;
23333+ stack[base + 39LLU] = 2011LLU/*throw to this address*/;
2319823334 stack[base + 40LLU] = base;
23199- stack[base + 41LLU] = 1996LLU;
23335+ stack[base + 41LLU] = 2012LLU;
2320023336 // arguments for call to reportid
2320123337 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2320223338 // set stack-base & callee-address
@@ -23204,20 +23340,20 @@
2320423340 label = 18446744073709551586LLU; // reportid
2320523341 break;
2320623342 }
23207- case 1995LLU: // copy-back deleter (reportid to ProcCall)
23343+ case 2011LLU: // copy-back deleter (reportid to ProcCall)
2320823344 {
2320923345 // copy mutable arguments back from call to reportid
23210- label = 1807LLU; // continue to roll stack
23346+ label = 1823LLU; // continue to roll stack
2321123347 break;
2321223348 }
23213- case 1996LLU: // return from reportid to ProcCall
23349+ case 2012LLU: // return from reportid to ProcCall
2321423350 {
2321523351 // copy mutable arguments back from call to reportid
2321623352 fprintf(stderr, "%s", " recursive call to ");
2321723353 // call reportid from ProcCall
23218- stack[base + 39LLU] = 1997LLU/*throw to this address*/;
23354+ stack[base + 39LLU] = 2013LLU/*throw to this address*/;
2321923355 stack[base + 40LLU] = base;
23220- stack[base + 41LLU] = 1998LLU;
23356+ stack[base + 41LLU] = 2014LLU;
2322123357 // arguments for call to reportid
2322223358 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2322323359 // set stack-base & callee-address
@@ -23225,35 +23361,35 @@
2322523361 label = 18446744073709551586LLU; // reportid
2322623362 break;
2322723363 }
23228- case 1997LLU: // copy-back deleter (reportid to ProcCall)
23364+ case 2013LLU: // copy-back deleter (reportid to ProcCall)
2322923365 {
2323023366 // copy mutable arguments back from call to reportid
23231- label = 1807LLU; // continue to roll stack
23367+ label = 1823LLU; // continue to roll stack
2323223368 break;
2323323369 }
23234- case 1998LLU: // return from reportid to ProcCall
23370+ case 2014LLU: // return from reportid to ProcCall
2323523371 {
2323623372 // copy mutable arguments back from call to reportid
2323723373 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");
2323823374 {
23239- label = 1807LLU; // throw: begin to unroll stack
23375+ label = 1823LLU; // throw: begin to unroll stack
2324023376 break;
2324123377 }
2324223378
23243- label = 1994LLU; // alternative complete
23379+ label = 2010LLU; // alternative complete
2324423380 break;
2324523381 }
23246- case 1994LLU: // completed if-then-else
23382+ case 2010LLU: // completed if-then-else
2324723383 {
23248- label = 1992LLU; // consequent complete
23384+ label = 2008LLU; // consequent complete
2324923385 break;
2325023386 }
23251- case 1991LLU: // alternative
23387+ case 2007LLU: // alternative
2325223388 {
23253- label = 1992LLU; // alternative complete
23389+ label = 2008LLU; // alternative complete
2325423390 break;
2325523391 }
23256- case 1992LLU: // completed if-then-else
23392+ case 2008LLU: // completed if-then-else
2325723393 {
2325823394 printf("%s", "\n stack = newstack;");
2325923395 printf("%s", "\n // set stack-base & callee-address");
@@ -23260,9 +23396,9 @@
2326023396 printf("%s", "\n base = 4/*deloffset*/;");
2326123397 printf("%s", "\n label = ");
2326223398 // call printnr from ProcCall
23263- stack[base + 35LLU] = 1999LLU/*throw to this address*/;
23399+ stack[base + 35LLU] = 2015LLU/*throw to this address*/;
2326423400 stack[base + 36LLU] = base;
23265- stack[base + 37LLU] = 2000LLU;
23401+ stack[base + 37LLU] = 2016LLU;
2326623402 // arguments for call to printnr
2326723403 stack[base + 38LLU] = stack[base + 20]/*celabel*/;
2326823404 // set stack-base & callee-address
@@ -23270,20 +23406,20 @@
2327023406 label = 18446744073709551590LLU; // printnr
2327123407 break;
2327223408 }
23273- case 1999LLU: // copy-back deleter (printnr to ProcCall)
23409+ case 2015LLU: // copy-back deleter (printnr to ProcCall)
2327423410 {
2327523411 // copy mutable arguments back from call to printnr
23276- label = 1779LLU; // continue to roll stack
23412+ label = 1795LLU; // continue to roll stack
2327723413 break;
2327823414 }
23279- case 2000LLU: // return from printnr to ProcCall
23415+ case 2016LLU: // return from printnr to ProcCall
2328023416 {
2328123417 // copy mutable arguments back from call to printnr
2328223418 printf("%s", "LLU; // ");
2328323419 // call printid from ProcCall
23284- stack[base + 35LLU] = 2001LLU/*throw to this address*/;
23420+ stack[base + 35LLU] = 2017LLU/*throw to this address*/;
2328523421 stack[base + 36LLU] = base;
23286- stack[base + 37LLU] = 2002LLU;
23422+ stack[base + 37LLU] = 2018LLU;
2328723423 // arguments for call to printid
2328823424 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2328923425 // set stack-base & callee-address
@@ -23291,13 +23427,13 @@
2329123427 label = 18446744073709551587LLU; // printid
2329223428 break;
2329323429 }
23294- case 2001LLU: // copy-back deleter (printid to ProcCall)
23430+ case 2017LLU: // copy-back deleter (printid to ProcCall)
2329523431 {
2329623432 // copy mutable arguments back from call to printid
23297- label = 1779LLU; // continue to roll stack
23433+ label = 1795LLU; // continue to roll stack
2329823434 break;
2329923435 }
23300- case 2002LLU: // return from printid to ProcCall
23436+ case 2018LLU: // return from printid to ProcCall
2330123437 {
2330223438 // copy mutable arguments back from call to printid
2330323439 printf("%s", "\n break;");
@@ -23304,7 +23440,7 @@
2330423440 printf("%s", "\n }");
2330523441 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2330623442 {
23307- label = 2004LLU; // jump to alternative
23443+ label = 2020LLU; // jump to alternative
2330823444 break;
2330923445 }
2331023446
@@ -23314,9 +23450,9 @@
2331423450 // case
2331523451 printf("%s", "\n case ");
2331623452 // call printnr from ProcCall
23317- stack[base + 37LLU] = 2006LLU/*throw to this address*/;
23453+ stack[base + 37LLU] = 2022LLU/*throw to this address*/;
2331823454 stack[base + 38LLU] = base;
23319- stack[base + 39LLU] = 2007LLU;
23455+ stack[base + 39LLU] = 2023LLU;
2332023456 // arguments for call to printnr
2332123457 stack[base + 40LLU] = stack[base + 33]/*labelfail*/;
2332223458 // set stack-base & callee-address
@@ -23324,20 +23460,20 @@
2332423460 label = 18446744073709551590LLU; // printnr
2332523461 break;
2332623462 }
23327- case 2006LLU: // copy-back deleter (printnr to ProcCall)
23463+ case 2022LLU: // copy-back deleter (printnr to ProcCall)
2332823464 {
2332923465 // copy mutable arguments back from call to printnr
23330- label = 2005LLU; // continue to roll stack
23466+ label = 2021LLU; // continue to roll stack
2333123467 break;
2333223468 }
23333- case 2007LLU: // return from printnr to ProcCall
23469+ case 2023LLU: // return from printnr to ProcCall
2333423470 {
2333523471 // copy mutable arguments back from call to printnr
2333623472 printf("%s", "LLU: // copy-back deleter (");
2333723473 // call printid from ProcCall
23338- stack[base + 37LLU] = 2008LLU/*throw to this address*/;
23474+ stack[base + 37LLU] = 2024LLU/*throw to this address*/;
2333923475 stack[base + 38LLU] = base;
23340- stack[base + 39LLU] = 2009LLU;
23476+ stack[base + 39LLU] = 2025LLU;
2334123477 // arguments for call to printid
2334223478 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2334323479 // set stack-base & callee-address
@@ -23345,20 +23481,20 @@
2334523481 label = 18446744073709551587LLU; // printid
2334623482 break;
2334723483 }
23348- case 2008LLU: // copy-back deleter (printid to ProcCall)
23484+ case 2024LLU: // copy-back deleter (printid to ProcCall)
2334923485 {
2335023486 // copy mutable arguments back from call to printid
23351- label = 2005LLU; // continue to roll stack
23487+ label = 2021LLU; // continue to roll stack
2335223488 break;
2335323489 }
23354- case 2009LLU: // return from printid to ProcCall
23490+ case 2025LLU: // return from printid to ProcCall
2335523491 {
2335623492 // copy mutable arguments back from call to printid
2335723493 printf("%s", " to ");
2335823494 // call printid from ProcCall
23359- stack[base + 37LLU] = 2010LLU/*throw to this address*/;
23495+ stack[base + 37LLU] = 2026LLU/*throw to this address*/;
2336023496 stack[base + 38LLU] = base;
23361- stack[base + 39LLU] = 2011LLU;
23497+ stack[base + 39LLU] = 2027LLU;
2336223498 // arguments for call to printid
2336323499 stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2336423500 // set stack-base & callee-address
@@ -23366,13 +23502,13 @@
2336623502 label = 18446744073709551587LLU; // printid
2336723503 break;
2336823504 }
23369- case 2010LLU: // copy-back deleter (printid to ProcCall)
23505+ case 2026LLU: // copy-back deleter (printid to ProcCall)
2337023506 {
2337123507 // copy mutable arguments back from call to printid
23372- label = 2005LLU; // continue to roll stack
23508+ label = 2021LLU; // continue to roll stack
2337323509 break;
2337423510 }
23375- case 2011LLU: // return from printid to ProcCall
23511+ case 2027LLU: // return from printid to ProcCall
2337623512 {
2337723513 // copy mutable arguments back from call to printid
2337823514 printf("%s", ")");
@@ -23380,9 +23516,9 @@
2338023516 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2338123517 printf("%s", "\n // copy mutable arguments back from call to ");
2338223518 // call printid from ProcCall
23383- stack[base + 37LLU] = 2012LLU/*throw to this address*/;
23519+ stack[base + 37LLU] = 2028LLU/*throw to this address*/;
2338423520 stack[base + 38LLU] = base;
23385- stack[base + 39LLU] = 2013LLU;
23521+ stack[base + 39LLU] = 2029LLU;
2338623522 // arguments for call to printid
2338723523 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2338823524 // set stack-base & callee-address
@@ -23390,24 +23526,24 @@
2339023526 label = 18446744073709551587LLU; // printid
2339123527 break;
2339223528 }
23393- case 2012LLU: // copy-back deleter (printid to ProcCall)
23529+ case 2028LLU: // copy-back deleter (printid to ProcCall)
2339423530 {
2339523531 // copy mutable arguments back from call to printid
23396- label = 2005LLU; // continue to roll stack
23532+ label = 2021LLU; // continue to roll stack
2339723533 break;
2339823534 }
23399- case 2013LLU: // return from printid to ProcCall
23535+ case 2029LLU: // return from printid to ProcCall
2340023536 {
2340123537 // copy mutable arguments back from call to printid
2340223538 flippedassign(stack[base + 19]/*copyback*/, &stack[base + 37]);
23403- label = 2014LLU; // start to repeat
23539+ label = 2030LLU; // start to repeat
2340423540 break;
2340523541 }
23406- case 2014LLU: // repeat from here
23542+ case 2030LLU: // repeat from here
2340723543 {
2340823544 if(!stack[base + 37])
2340923545 {
23410- label = 2015LLU; // break loop
23546+ label = 2031LLU; // break loop
2341123547 break;
2341223548 }
2341323549
@@ -23417,7 +23553,7 @@
2341723553 stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->next);
2341823554 if(/*idnr*/0 != ((uint64_t *)(stack[base + 38]/*idnr*/))[0])
2341923555 {
23420- label = 2018LLU; // jump to alternative
23556+ label = 2034LLU; // jump to alternative
2342123557 break;
2342223558 }
2342323559
@@ -23427,9 +23563,9 @@
2342723563 // case
2342823564 printf("%s", "\n old");
2342923565 // call emitvar from ProcCall
23430- stack[base + 42LLU] = 2020LLU/*throw to this address*/;
23566+ stack[base + 42LLU] = 2036LLU/*throw to this address*/;
2343123567 stack[base + 43LLU] = base;
23432- stack[base + 44LLU] = 2021LLU;
23568+ stack[base + 44LLU] = 2037LLU;
2343323569 // arguments for call to emitvar
2343423570 stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2343523571 stack[base + 46LLU] = stack[base + 40]/*content*/;
@@ -23440,20 +23576,20 @@
2344023576 label = 749LLU; // emitvar
2344123577 break;
2344223578 }
23443- case 2020LLU: // copy-back deleter (emitvar to ProcCall)
23579+ case 2036LLU: // copy-back deleter (emitvar to ProcCall)
2344423580 {
2344523581 // copy mutable arguments back from call to emitvar
23446- label = 2019LLU; // continue to roll stack
23582+ label = 2035LLU; // continue to roll stack
2344723583 break;
2344823584 }
23449- case 2021LLU: // return from emitvar to ProcCall
23585+ case 2037LLU: // return from emitvar to ProcCall
2345023586 {
2345123587 // copy mutable arguments back from call to emitvar
2345223588 printf("%s", " = stack[");
2345323589 // call printnr from ProcCall
23454- stack[base + 42LLU] = 2022LLU/*throw to this address*/;
23590+ stack[base + 42LLU] = 2038LLU/*throw to this address*/;
2345523591 stack[base + 43LLU] = base;
23456- stack[base + 44LLU] = 2023LLU;
23592+ stack[base + 44LLU] = 2039LLU;
2345723593 // arguments for call to printnr
2345823594 stack[base + 45LLU] = stack[base + 41]/*sum*/;
2345923595 // set stack-base & callee-address
@@ -23461,52 +23597,52 @@
2346123597 label = 18446744073709551590LLU; // printnr
2346223598 break;
2346323599 }
23464- case 2022LLU: // copy-back deleter (printnr to ProcCall)
23600+ case 2038LLU: // copy-back deleter (printnr to ProcCall)
2346523601 {
2346623602 // copy mutable arguments back from call to printnr
23467- label = 2019LLU; // continue to roll stack
23603+ label = 2035LLU; // continue to roll stack
2346823604 break;
2346923605 }
23470- case 2023LLU: // return from printnr to ProcCall
23606+ case 2039LLU: // return from printnr to ProcCall
2347123607 {
2347223608 // copy mutable arguments back from call to printnr
2347323609 printf("%s", "LLU];");
2347423610 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2347523611 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23476- label = 2017LLU; // case complete
23612+ label = 2033LLU; // case complete
2347723613 break;
2347823614 }
23479- case 2019LLU: // copy-back deleter (switch)
23615+ case 2035LLU: // copy-back deleter (switch)
2348023616 {
2348123617 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2348223618 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23483- label = 2016LLU; // continue to unroll stack
23619+ label = 2032LLU; // continue to unroll stack
2348423620 break;
2348523621 }
23486- case 2018LLU: // try next case
23622+ case 2034LLU: // try next case
2348723623 {
2348823624 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2348923625 exit(-1);
2349023626 }
23491- case 2017LLU: // completed switch
23627+ case 2033LLU: // completed switch
2349223628 {
2349323629 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23494- label = 2014LLU; // repeat
23630+ label = 2030LLU; // repeat
2349523631 break;
2349623632 }
23497- case 2016LLU: // copy-back deleter for while next
23633+ case 2032LLU: // copy-back deleter for while next
2349823634 {
2349923635 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23500- label = 2005LLU; // continue to unroll stack
23636+ label = 2021LLU; // continue to unroll stack
2350123637 break;
2350223638 }
23503- case 2015LLU: // loop finished
23639+ case 2031LLU: // loop finished
2350423640 {
2350523641 printf("%s", "\n if(stack[");
2350623642 // call printnr from ProcCall
23507- stack[base + 40LLU] = 2024LLU/*throw to this address*/;
23643+ stack[base + 40LLU] = 2040LLU/*throw to this address*/;
2350823644 stack[base + 41LLU] = base;
23509- stack[base + 42LLU] = 2025LLU;
23645+ stack[base + 42LLU] = 2041LLU;
2351023646 // arguments for call to printnr
2351123647 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2351223648 // set stack-base & callee-address
@@ -23514,13 +23650,13 @@
2351423650 label = 18446744073709551590LLU; // printnr
2351523651 break;
2351623652 }
23517- case 2024LLU: // copy-back deleter (printnr to ProcCall)
23653+ case 2040LLU: // copy-back deleter (printnr to ProcCall)
2351823654 {
2351923655 // copy mutable arguments back from call to printnr
23520- label = 2005LLU; // continue to roll stack
23656+ label = 2021LLU; // continue to roll stack
2352123657 break;
2352223658 }
23523- case 2025LLU: // return from printnr to ProcCall
23659+ case 2041LLU: // return from printnr to ProcCall
2352423660 {
2352523661 // copy mutable arguments back from call to printnr
2352623662 printf("%s", "LLU] != 9876543210LLU)");
@@ -23527,9 +23663,9 @@
2352723663 printf("%s", "\n {");
2352823664 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2352923665 // call printid from ProcCall
23530- stack[base + 40LLU] = 2026LLU/*throw to this address*/;
23666+ stack[base + 40LLU] = 2042LLU/*throw to this address*/;
2353123667 stack[base + 41LLU] = base;
23532- stack[base + 42LLU] = 2027LLU;
23668+ stack[base + 42LLU] = 2043LLU;
2353323669 // arguments for call to printid
2353423670 stack[base + 43LLU] = stack[base + 24]/*ceid*/;
2353523671 // set stack-base & callee-address
@@ -23537,13 +23673,13 @@
2353723673 label = 18446744073709551587LLU; // printid
2353823674 break;
2353923675 }
23540- case 2026LLU: // copy-back deleter (printid to ProcCall)
23676+ case 2042LLU: // copy-back deleter (printid to ProcCall)
2354123677 {
2354223678 // copy mutable arguments back from call to printid
23543- label = 2005LLU; // continue to roll stack
23679+ label = 2021LLU; // continue to roll stack
2354423680 break;
2354523681 }
23546- case 2027LLU: // return from printid to ProcCall
23682+ case 2043LLU: // return from printid to ProcCall
2354723683 {
2354823684 // copy mutable arguments back from call to printid
2354923685 printf("%s", ")!\\n\");");
@@ -23551,9 +23687,9 @@
2355123687 printf("%s", "\n }");
2355223688 printf("%s", "\n Free(");
2355323689 // call printnr from ProcCall
23554- stack[base + 40LLU] = 2028LLU/*throw to this address*/;
23690+ stack[base + 40LLU] = 2044LLU/*throw to this address*/;
2355523691 stack[base + 41LLU] = base;
23556- stack[base + 42LLU] = 2029LLU;
23692+ stack[base + 42LLU] = 2045LLU;
2355723693 // arguments for call to printnr
2355823694 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2355923695 // set stack-base & callee-address
@@ -23561,13 +23697,13 @@
2356123697 label = 18446744073709551590LLU; // printnr
2356223698 break;
2356323699 }
23564- case 2028LLU: // copy-back deleter (printnr to ProcCall)
23700+ case 2044LLU: // copy-back deleter (printnr to ProcCall)
2356523701 {
2356623702 // copy mutable arguments back from call to printnr
23567- label = 2005LLU; // continue to roll stack
23703+ label = 2021LLU; // continue to roll stack
2356823704 break;
2356923705 }
23570- case 2029LLU: // return from printnr to ProcCall
23706+ case 2045LLU: // return from printnr to ProcCall
2357123707 {
2357223708 // copy mutable arguments back from call to printnr
2357323709 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
@@ -23574,9 +23710,9 @@
2357423710 printf("%s", "\n stack = oldstack;");
2357523711 printf("%s", "\n label = ");
2357623712 // call printnr from ProcCall
23577- stack[base + 40LLU] = 2030LLU/*throw to this address*/;
23713+ stack[base + 40LLU] = 2046LLU/*throw to this address*/;
2357823714 stack[base + 41LLU] = base;
23579- stack[base + 42LLU] = 2031LLU;
23715+ stack[base + 42LLU] = 2047LLU;
2358023716 // arguments for call to printnr
2358123717 stack[base + 43LLU] = stack[base + 35]/*labelthrow*/;
2358223718 // set stack-base & callee-address
@@ -23584,13 +23720,13 @@
2358423720 label = 18446744073709551590LLU; // printnr
2358523721 break;
2358623722 }
23587- case 2030LLU: // copy-back deleter (printnr to ProcCall)
23723+ case 2046LLU: // copy-back deleter (printnr to ProcCall)
2358823724 {
2358923725 // copy mutable arguments back from call to printnr
23590- label = 2005LLU; // continue to roll stack
23726+ label = 2021LLU; // continue to roll stack
2359123727 break;
2359223728 }
23593- case 2031LLU: // return from printnr to ProcCall
23729+ case 2047LLU: // return from printnr to ProcCall
2359423730 {
2359523731 // copy mutable arguments back from call to printnr
2359623732 printf("%s", "LLU; // continue to unroll stack");
@@ -23598,28 +23734,28 @@
2359823734 printf("%s", "\n }");
2359923735 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2360023736 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23601- label = 2003LLU; // case complete
23737+ label = 2019LLU; // case complete
2360223738 break;
2360323739 }
23604- case 2005LLU: // copy-back deleter (switch)
23740+ case 2021LLU: // copy-back deleter (switch)
2360523741 {
2360623742 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2360723743 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23608- label = 1779LLU; // continue to unroll stack
23744+ label = 1795LLU; // continue to unroll stack
2360923745 break;
2361023746 }
23611- case 2004LLU: // try next case
23747+ case 2020LLU: // try next case
2361223748 {
2361323749 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2361423750 exit(-1);
2361523751 }
23616- case 2003LLU: // completed switch
23752+ case 2019LLU: // completed switch
2361723753 {
2361823754 printf("%s", "\n case ");
2361923755 // call printnr from ProcCall
23620- stack[base + 35LLU] = 2032LLU/*throw to this address*/;
23756+ stack[base + 35LLU] = 2048LLU/*throw to this address*/;
2362123757 stack[base + 36LLU] = base;
23622- stack[base + 37LLU] = 2033LLU;
23758+ stack[base + 37LLU] = 2049LLU;
2362323759 // arguments for call to printnr
2362423760 stack[base + 38LLU] = stack[base + 17]/*label*/;
2362523761 // set stack-base & callee-address
@@ -23627,20 +23763,20 @@
2362723763 label = 18446744073709551590LLU; // printnr
2362823764 break;
2362923765 }
23630- case 2032LLU: // copy-back deleter (printnr to ProcCall)
23766+ case 2048LLU: // copy-back deleter (printnr to ProcCall)
2363123767 {
2363223768 // copy mutable arguments back from call to printnr
23633- label = 1779LLU; // continue to roll stack
23769+ label = 1795LLU; // continue to roll stack
2363423770 break;
2363523771 }
23636- case 2033LLU: // return from printnr to ProcCall
23772+ case 2049LLU: // return from printnr to ProcCall
2363723773 {
2363823774 // copy mutable arguments back from call to printnr
2363923775 printf("%s", "LLU: // return from ");
2364023776 // call printid from ProcCall
23641- stack[base + 35LLU] = 2034LLU/*throw to this address*/;
23777+ stack[base + 35LLU] = 2050LLU/*throw to this address*/;
2364223778 stack[base + 36LLU] = base;
23643- stack[base + 37LLU] = 2035LLU;
23779+ stack[base + 37LLU] = 2051LLU;
2364423780 // arguments for call to printid
2364523781 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2364623782 // set stack-base & callee-address
@@ -23648,20 +23784,20 @@
2364823784 label = 18446744073709551587LLU; // printid
2364923785 break;
2365023786 }
23651- case 2034LLU: // copy-back deleter (printid to ProcCall)
23787+ case 2050LLU: // copy-back deleter (printid to ProcCall)
2365223788 {
2365323789 // copy mutable arguments back from call to printid
23654- label = 1779LLU; // continue to roll stack
23790+ label = 1795LLU; // continue to roll stack
2365523791 break;
2365623792 }
23657- case 2035LLU: // return from printid to ProcCall
23793+ case 2051LLU: // return from printid to ProcCall
2365823794 {
2365923795 // copy mutable arguments back from call to printid
2366023796 printf("%s", " to ");
2366123797 // call printid from ProcCall
23662- stack[base + 35LLU] = 2036LLU/*throw to this address*/;
23798+ stack[base + 35LLU] = 2052LLU/*throw to this address*/;
2366323799 stack[base + 36LLU] = base;
23664- stack[base + 37LLU] = 2037LLU;
23800+ stack[base + 37LLU] = 2053LLU;
2366523801 // arguments for call to printid
2366623802 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2366723803 // set stack-base & callee-address
@@ -23669,13 +23805,13 @@
2366923805 label = 18446744073709551587LLU; // printid
2367023806 break;
2367123807 }
23672- case 2036LLU: // copy-back deleter (printid to ProcCall)
23808+ case 2052LLU: // copy-back deleter (printid to ProcCall)
2367323809 {
2367423810 // copy mutable arguments back from call to printid
23675- label = 1779LLU; // continue to roll stack
23811+ label = 1795LLU; // continue to roll stack
2367623812 break;
2367723813 }
23678- case 2037LLU: // return from printid to ProcCall
23814+ case 2053LLU: // return from printid to ProcCall
2367923815 {
2368023816 // copy mutable arguments back from call to printid
2368123817 printf("%s", "\n {");
@@ -23682,9 +23818,9 @@
2368223818 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2368323819 printf("%s", "\n // copy mutable arguments back from call to ");
2368423820 // call printid from ProcCall
23685- stack[base + 35LLU] = 2038LLU/*throw to this address*/;
23821+ stack[base + 35LLU] = 2054LLU/*throw to this address*/;
2368623822 stack[base + 36LLU] = base;
23687- stack[base + 37LLU] = 2039LLU;
23823+ stack[base + 37LLU] = 2055LLU;
2368823824 // arguments for call to printid
2368923825 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2369023826 // set stack-base & callee-address
@@ -23692,23 +23828,23 @@
2369223828 label = 18446744073709551587LLU; // printid
2369323829 break;
2369423830 }
23695- case 2038LLU: // copy-back deleter (printid to ProcCall)
23831+ case 2054LLU: // copy-back deleter (printid to ProcCall)
2369623832 {
2369723833 // copy mutable arguments back from call to printid
23698- label = 1779LLU; // continue to roll stack
23834+ label = 1795LLU; // continue to roll stack
2369923835 break;
2370023836 }
23701- case 2039LLU: // return from printid to ProcCall
23837+ case 2055LLU: // return from printid to ProcCall
2370223838 {
2370323839 // copy mutable arguments back from call to printid
23704- label = 2040LLU; // start to repeat
23840+ label = 2056LLU; // start to repeat
2370523841 break;
2370623842 }
23707- case 2040LLU: // repeat from here
23843+ case 2056LLU: // repeat from here
2370823844 {
2370923845 if(!stack[base + 19])
2371023846 {
23711- label = 2041LLU; // break loop
23847+ label = 2057LLU; // break loop
2371223848 break;
2371323849 }
2371423850
@@ -23721,7 +23857,7 @@
2372123857 }
2372223858 if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0])
2372323859 {
23724- label = 2044LLU; // jump to alternative
23860+ label = 2060LLU; // jump to alternative
2372523861 break;
2372623862 }
2372723863
@@ -23731,9 +23867,9 @@
2373123867 // case
2373223868 printf("%s", "\n old");
2373323869 // call emitvar from ProcCall
23734- stack[base + 38LLU] = 2046LLU/*throw to this address*/;
23870+ stack[base + 38LLU] = 2062LLU/*throw to this address*/;
2373523871 stack[base + 39LLU] = base;
23736- stack[base + 40LLU] = 2047LLU;
23872+ stack[base + 40LLU] = 2063LLU;
2373723873 // arguments for call to emitvar
2373823874 stack[base + 41LLU] = stack[base + 8]/*fnid*/;
2373923875 stack[base + 42LLU] = stack[base + 36]/*content*/;
@@ -23744,20 +23880,20 @@
2374423880 label = 749LLU; // emitvar
2374523881 break;
2374623882 }
23747- case 2046LLU: // copy-back deleter (emitvar to ProcCall)
23883+ case 2062LLU: // copy-back deleter (emitvar to ProcCall)
2374823884 {
2374923885 // copy mutable arguments back from call to emitvar
23750- label = 2045LLU; // continue to roll stack
23886+ label = 2061LLU; // continue to roll stack
2375123887 break;
2375223888 }
23753- case 2047LLU: // return from emitvar to ProcCall
23889+ case 2063LLU: // return from emitvar to ProcCall
2375423890 {
2375523891 // copy mutable arguments back from call to emitvar
2375623892 printf("%s", " = stack[");
2375723893 // call printnr from ProcCall
23758- stack[base + 38LLU] = 2048LLU/*throw to this address*/;
23894+ stack[base + 38LLU] = 2064LLU/*throw to this address*/;
2375923895 stack[base + 39LLU] = base;
23760- stack[base + 40LLU] = 2049LLU;
23896+ stack[base + 40LLU] = 2065LLU;
2376123897 // arguments for call to printnr
2376223898 stack[base + 41LLU] = stack[base + 37]/*sum*/;
2376323899 // set stack-base & callee-address
@@ -23765,34 +23901,34 @@
2376523901 label = 18446744073709551590LLU; // printnr
2376623902 break;
2376723903 }
23768- case 2048LLU: // copy-back deleter (printnr to ProcCall)
23904+ case 2064LLU: // copy-back deleter (printnr to ProcCall)
2376923905 {
2377023906 // copy mutable arguments back from call to printnr
23771- label = 2045LLU; // continue to roll stack
23907+ label = 2061LLU; // continue to roll stack
2377223908 break;
2377323909 }
23774- case 2049LLU: // return from printnr to ProcCall
23910+ case 2065LLU: // return from printnr to ProcCall
2377523911 {
2377623912 // copy mutable arguments back from call to printnr
2377723913 printf("%s", "LLU];");
2377823914 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2377923915 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23780- label = 2043LLU; // case complete
23916+ label = 2059LLU; // case complete
2378123917 break;
2378223918 }
23783- case 2045LLU: // copy-back deleter (switch)
23919+ case 2061LLU: // copy-back deleter (switch)
2378423920 {
2378523921 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2378623922 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23787- label = 2042LLU; // continue to unroll stack
23923+ label = 2058LLU; // continue to unroll stack
2378823924 break;
2378923925 }
23790- case 2044LLU: // try next case
23926+ case 2060LLU: // try next case
2379123927 {
2379223928 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2379323929 exit(-1);
2379423930 }
23795- case 2043LLU: // completed switch
23931+ case 2059LLU: // completed switch
2379623932 {
2379723933
2379823934 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23800,7 +23936,7 @@
2380023936 newstack[0] = (uint64_t)stack; // backup stack location
2380123937 newstack[1] = 1234567890;
2380223938 newstack[2] = base;
23803- newstack[3] = 2050LLU;
23939+ newstack[3] = 2066LLU;
2380423940 stack = newstack;
2380523941 // set stack-base & callee-address
2380623942 base = 4/*deloffset*/;
@@ -23807,16 +23943,16 @@
2380723943 label = 833LLU; // ~idnr
2380823944 break;
2380923945 }
23810- case 2050LLU: // return from ~idnr to ProcCall
23946+ case 2066LLU: // return from ~idnr to ProcCall
2381123947 {
2381223948 stack = (uint64_t *)stack[0];
2381323949 // releasing toplevel container
2381423950 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2381523951
23816- label = 2040LLU; // repeat
23952+ label = 2056LLU; // repeat
2381723953 break;
2381823954 }
23819- case 2042LLU: // copy-back deleter for while next
23955+ case 2058LLU: // copy-back deleter for while next
2382023956 {
2382123957
2382223958 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23824,7 +23960,7 @@
2382423960 newstack[0] = (uint64_t)stack; // backup stack location
2382523961 newstack[1] = 1234567890;
2382623962 newstack[2] = base;
23827- newstack[3] = 2051LLU;
23963+ newstack[3] = 2067LLU;
2382823964 stack = newstack;
2382923965 // set stack-base & callee-address
2383023966 base = 4/*deloffset*/;
@@ -23831,20 +23967,20 @@
2383123967 label = 833LLU; // ~idnr
2383223968 break;
2383323969 }
23834- case 2051LLU: // return from ~idnr to ProcCall
23970+ case 2067LLU: // return from ~idnr to ProcCall
2383523971 {
2383623972 stack = (uint64_t *)stack[0];
2383723973 // releasing toplevel container
2383823974 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2383923975
23840- label = 1779LLU; // continue to unroll stack
23976+ label = 1795LLU; // continue to unroll stack
2384123977 break;
2384223978 }
23843- case 2041LLU: // loop finished
23979+ case 2057LLU: // loop finished
2384423980 {
2384523981 if(!stack[base + 28]/*cerescount*/)
2384623982 {
23847- label = 2052LLU; // jump to alternative
23983+ label = 2068LLU; // jump to alternative
2384823984 break;
2384923985 }
2385023986
@@ -23851,9 +23987,9 @@
2385123987 // consequent
2385223988 printf("%s", "\n // copy back results provided by call to ");
2385323989 // call printid from ProcCall
23854- stack[base + 35LLU] = 2054LLU/*throw to this address*/;
23990+ stack[base + 35LLU] = 2070LLU/*throw to this address*/;
2385523991 stack[base + 36LLU] = base;
23856- stack[base + 37LLU] = 2055LLU;
23992+ stack[base + 37LLU] = 2071LLU;
2385723993 // arguments for call to printid
2385823994 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2385923995 // set stack-base & callee-address
@@ -23861,25 +23997,25 @@
2386123997 label = 18446744073709551587LLU; // printid
2386223998 break;
2386323999 }
23864- case 2054LLU: // copy-back deleter (printid to ProcCall)
24000+ case 2070LLU: // copy-back deleter (printid to ProcCall)
2386524001 {
2386624002 // copy mutable arguments back from call to printid
23867- label = 1779LLU; // continue to roll stack
24003+ label = 1795LLU; // continue to roll stack
2386824004 break;
2386924005 }
23870- case 2055LLU: // return from printid to ProcCall
24006+ case 2071LLU: // return from printid to ProcCall
2387124007 {
2387224008 // copy mutable arguments back from call to printid
2387324009 stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/;
2387424010 flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 35]);
23875- label = 2056LLU; // start to repeat
24011+ label = 2072LLU; // start to repeat
2387624012 break;
2387724013 }
23878- case 2056LLU: // repeat from here
24014+ case 2072LLU: // repeat from here
2387924015 {
2388024016 if(!stack[base + 35])
2388124017 {
23882- label = 2057LLU; // break loop
24018+ label = 2073LLU; // break loop
2388324019 break;
2388424020 }
2388524021
@@ -23888,9 +24024,9 @@
2388824024 stack[base + 37]/*previous*/ = stack[base + 35];
2388924025 stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next);
2389024026 // call sub from ProcCall
23891- stack[base + 38LLU] = 2059LLU/*throw to this address*/;
24027+ stack[base + 38LLU] = 2075LLU/*throw to this address*/;
2389224028 stack[base + 39LLU] = base;
23893- stack[base + 40LLU] = 2060LLU;
24029+ stack[base + 40LLU] = 2076LLU;
2389424030 // arguments for call to sub
2389524031 stack[base + 42LLU] = stack[base + 28]/*cerescount*/;
2389624032 stack[base + 43LLU] = stack[base + 31]/*n*/;
@@ -23899,21 +24035,21 @@
2389924035 label = 18446744073709551604LLU; // sub
2390024036 break;
2390124037 }
23902- case 2059LLU: // copy-back deleter (sub to ProcCall)
24038+ case 2075LLU: // copy-back deleter (sub to ProcCall)
2390324039 {
2390424040 // copy mutable arguments back from call to sub
23905- label = 2058LLU; // continue to roll stack
24041+ label = 2074LLU; // continue to roll stack
2390624042 break;
2390724043 }
23908- case 2060LLU: // return from sub to ProcCall
24044+ case 2076LLU: // return from sub to ProcCall
2390924045 {
2391024046 // copy mutable arguments back from call to sub
2391124047 // copy back results provided by call to sub
2391224048 stack[base + 32] = stack[base + 41LLU];
2391324049 // call sub from ProcCall
23914- stack[base + 38LLU] = 2061LLU/*throw to this address*/;
24050+ stack[base + 38LLU] = 2077LLU/*throw to this address*/;
2391524051 stack[base + 39LLU] = base;
23916- stack[base + 40LLU] = 2062LLU;
24052+ stack[base + 40LLU] = 2078LLU;
2391724053 // arguments for call to sub
2391824054 stack[base + 42LLU] = stack[base + 31]/*n*/;
2391924055 stack[base + 43LLU] = 1LLU;
@@ -23922,13 +24058,13 @@
2392224058 label = 18446744073709551604LLU; // sub
2392324059 break;
2392424060 }
23925- case 2061LLU: // copy-back deleter (sub to ProcCall)
24061+ case 2077LLU: // copy-back deleter (sub to ProcCall)
2392624062 {
2392724063 // copy mutable arguments back from call to sub
23928- label = 2058LLU; // continue to roll stack
24064+ label = 2074LLU; // continue to roll stack
2392924065 break;
2393024066 }
23931- case 2062LLU: // return from sub to ProcCall
24067+ case 2078LLU: // return from sub to ProcCall
2393224068 {
2393324069 // copy mutable arguments back from call to sub
2393424070 // copy back results provided by call to sub
@@ -23937,7 +24073,7 @@
2393724073 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
2393824074 if(!list)
2393924075 {
23940- label = 2063LLU; // jump to alternative
24076+ label = 2079LLU; // jump to alternative
2394124077 break;
2394224078 }
2394324079
@@ -23949,7 +24085,7 @@
2394924085 }
2395024086 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0])
2395124087 {
23952- label = 2067LLU; // jump to alternative
24088+ label = 2083LLU; // jump to alternative
2395324089 break;
2395424090 }
2395524091
@@ -23959,7 +24095,7 @@
2395924095 // case
2396024096 if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0])
2396124097 {
23962- label = 2070LLU; // jump to alternative
24098+ label = 2086LLU; // jump to alternative
2396324099 break;
2396424100 }
2396524101
@@ -23970,7 +24106,7 @@
2397024106 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2397124107 if(!newstack)
2397224108 {
23973- label = 2071LLU; // throw: begin to unroll stack
24109+ label = 2087LLU; // throw: begin to unroll stack
2397424110 break;
2397524111 }
2397624112
@@ -23977,9 +24113,9 @@
2397724113 newstack[15LLU] = 9876543210LLU; // overflow-marker
2397824114 // call equtype from ProcCall
2397924115 newstack[0] = (uint64_t)stack; // backup stack location
23980- newstack[1] = 2072LLU;
24116+ newstack[1] = 2088LLU;
2398124117 newstack[2] = base;
23982- newstack[3] = 2073LLU;
24118+ newstack[3] = 2089LLU;
2398324119 // arguments for call to equtype
2398424120 newstack[5LLU] = stack[base + 39]/*dsttype*/;
2398524121 newstack[6LLU] = stack[base + 41]/*srctype*/;
@@ -23989,7 +24125,7 @@
2398924125 label = 359LLU; // equtype
2399024126 break;
2399124127 }
23992- case 2072LLU: // copy-back deleter (equtype to ProcCall)
24128+ case 2088LLU: // copy-back deleter (equtype to ProcCall)
2399324129 {
2399424130 uint64_t *oldstack = (uint64_t *)stack[0];
2399524131 // copy mutable arguments back from call to equtype
@@ -24000,10 +24136,10 @@
2400024136 }
2400124137 Free(15LLU + 1, sizeof(uint64_t), stack);
2400224138 stack = oldstack;
24003- label = 2071LLU; // continue to unroll stack
24139+ label = 2087LLU; // continue to unroll stack
2400424140 break;
2400524141 }
24006- case 2073LLU: // return from equtype to ProcCall
24142+ case 2089LLU: // return from equtype to ProcCall
2400724143 {
2400824144 uint64_t *oldstack = (uint64_t *)stack[0];
2400924145 // copy mutable arguments back from call to equtype
@@ -24018,21 +24154,21 @@
2401824154 stack = oldstack;
2401924155 if(!stack[base + 18]/*isequal*/)
2402024156 {
24021- label = 2074LLU; // jump to alternative
24157+ label = 2090LLU; // jump to alternative
2402224158 break;
2402324159 }
2402424160
2402524161 // consequent
24026- label = 2075LLU; // consequent complete
24162+ label = 2091LLU; // consequent complete
2402724163 break;
2402824164 }
24029- case 2074LLU: // alternative
24165+ case 2090LLU: // alternative
2403024166 {
2403124167 fprintf(stderr, "%s", "in function ");
2403224168 // call reportid from ProcCall
24033- stack[base + 43LLU] = 2076LLU/*throw to this address*/;
24169+ stack[base + 43LLU] = 2092LLU/*throw to this address*/;
2403424170 stack[base + 44LLU] = base;
24035- stack[base + 45LLU] = 2077LLU;
24171+ stack[base + 45LLU] = 2093LLU;
2403624172 // arguments for call to reportid
2403724173 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2403824174 // set stack-base & callee-address
@@ -24040,20 +24176,20 @@
2404024176 label = 18446744073709551586LLU; // reportid
2404124177 break;
2404224178 }
24043- case 2076LLU: // copy-back deleter (reportid to ProcCall)
24179+ case 2092LLU: // copy-back deleter (reportid to ProcCall)
2404424180 {
2404524181 // copy mutable arguments back from call to reportid
24046- label = 2071LLU; // continue to roll stack
24182+ label = 2087LLU; // continue to roll stack
2404724183 break;
2404824184 }
24049- case 2077LLU: // return from reportid to ProcCall
24185+ case 2093LLU: // return from reportid to ProcCall
2405024186 {
2405124187 // copy mutable arguments back from call to reportid
2405224188 fprintf(stderr, "%s", " call to ");
2405324189 // call reportid from ProcCall
24054- stack[base + 43LLU] = 2078LLU/*throw to this address*/;
24190+ stack[base + 43LLU] = 2094LLU/*throw to this address*/;
2405524191 stack[base + 44LLU] = base;
24056- stack[base + 45LLU] = 2079LLU;
24192+ stack[base + 45LLU] = 2095LLU;
2405724193 // arguments for call to reportid
2405824194 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2405924195 // set stack-base & callee-address
@@ -24061,20 +24197,20 @@
2406124197 label = 18446744073709551586LLU; // reportid
2406224198 break;
2406324199 }
24064- case 2078LLU: // copy-back deleter (reportid to ProcCall)
24200+ case 2094LLU: // copy-back deleter (reportid to ProcCall)
2406524201 {
2406624202 // copy mutable arguments back from call to reportid
24067- label = 2071LLU; // continue to roll stack
24203+ label = 2087LLU; // continue to roll stack
2406824204 break;
2406924205 }
24070- case 2079LLU: // return from reportid to ProcCall
24206+ case 2095LLU: // return from reportid to ProcCall
2407124207 {
2407224208 // copy mutable arguments back from call to reportid
2407324209 fprintf(stderr, "%s", " at position ");
2407424210 // call reportnr from ProcCall
24075- stack[base + 43LLU] = 2080LLU/*throw to this address*/;
24211+ stack[base + 43LLU] = 2096LLU/*throw to this address*/;
2407624212 stack[base + 44LLU] = base;
24077- stack[base + 45LLU] = 2081LLU;
24213+ stack[base + 45LLU] = 2097LLU;
2407824214 // arguments for call to reportnr
2407924215 stack[base + 46LLU] = stack[base + 32]/*index*/;
2408024216 // set stack-base & callee-address
@@ -24082,13 +24218,13 @@
2408224218 label = 18446744073709551589LLU; // reportnr
2408324219 break;
2408424220 }
24085- case 2080LLU: // copy-back deleter (reportnr to ProcCall)
24221+ case 2096LLU: // copy-back deleter (reportnr to ProcCall)
2408624222 {
2408724223 // copy mutable arguments back from call to reportnr
24088- label = 2071LLU; // continue to roll stack
24224+ label = 2087LLU; // continue to roll stack
2408924225 break;
2409024226 }
24091- case 2081LLU: // return from reportnr to ProcCall
24227+ case 2097LLU: // return from reportnr to ProcCall
2409224228 {
2409324229 // copy mutable arguments back from call to reportnr
2409424230 fprintf(stderr, "%s", " cannot return source of type ");
@@ -24095,7 +24231,7 @@
2409524231 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2409624232 if(!newstack)
2409724233 {
24098- label = 2071LLU; // throw: begin to unroll stack
24234+ label = 2087LLU; // throw: begin to unroll stack
2409924235 break;
2410024236 }
2410124237
@@ -24102,9 +24238,9 @@
2410224238 newstack[10LLU] = 9876543210LLU; // overflow-marker
2410324239 // call reporttype from ProcCall
2410424240 newstack[0] = (uint64_t)stack; // backup stack location
24105- newstack[1] = 2082LLU;
24241+ newstack[1] = 2098LLU;
2410624242 newstack[2] = base;
24107- newstack[3] = 2083LLU;
24243+ newstack[3] = 2099LLU;
2410824244 // arguments for call to reporttype
2410924245 newstack[4LLU] = stack[base + 41]/*srctype*/;
2411024246 stack = newstack;
@@ -24113,7 +24249,7 @@
2411324249 label = 330LLU; // reporttype
2411424250 break;
2411524251 }
24116- case 2082LLU: // copy-back deleter (reporttype to ProcCall)
24252+ case 2098LLU: // copy-back deleter (reporttype to ProcCall)
2411724253 {
2411824254 uint64_t *oldstack = (uint64_t *)stack[0];
2411924255 // copy mutable arguments back from call to reporttype
@@ -24124,10 +24260,10 @@
2412424260 }
2412524261 Free(10LLU + 1, sizeof(uint64_t), stack);
2412624262 stack = oldstack;
24127- label = 2071LLU; // continue to unroll stack
24263+ label = 2087LLU; // continue to unroll stack
2412824264 break;
2412924265 }
24130- case 2083LLU: // return from reporttype to ProcCall
24266+ case 2099LLU: // return from reporttype to ProcCall
2413124267 {
2413224268 uint64_t *oldstack = (uint64_t *)stack[0];
2413324269 // copy mutable arguments back from call to reporttype
@@ -24142,7 +24278,7 @@
2414224278 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2414324279 if(!newstack)
2414424280 {
24145- label = 2071LLU; // throw: begin to unroll stack
24281+ label = 2087LLU; // throw: begin to unroll stack
2414624282 break;
2414724283 }
2414824284
@@ -24149,9 +24285,9 @@
2414924285 newstack[10LLU] = 9876543210LLU; // overflow-marker
2415024286 // call reporttype from ProcCall
2415124287 newstack[0] = (uint64_t)stack; // backup stack location
24152- newstack[1] = 2084LLU;
24288+ newstack[1] = 2100LLU;
2415324289 newstack[2] = base;
24154- newstack[3] = 2085LLU;
24290+ newstack[3] = 2101LLU;
2415524291 // arguments for call to reporttype
2415624292 newstack[4LLU] = stack[base + 39]/*dsttype*/;
2415724293 stack = newstack;
@@ -24160,7 +24296,7 @@
2416024296 label = 330LLU; // reporttype
2416124297 break;
2416224298 }
24163- case 2084LLU: // copy-back deleter (reporttype to ProcCall)
24299+ case 2100LLU: // copy-back deleter (reporttype to ProcCall)
2416424300 {
2416524301 uint64_t *oldstack = (uint64_t *)stack[0];
2416624302 // copy mutable arguments back from call to reporttype
@@ -24171,10 +24307,10 @@
2417124307 }
2417224308 Free(10LLU + 1, sizeof(uint64_t), stack);
2417324309 stack = oldstack;
24174- label = 2071LLU; // continue to unroll stack
24310+ label = 2087LLU; // continue to unroll stack
2417524311 break;
2417624312 }
24177- case 2085LLU: // return from reporttype to ProcCall
24313+ case 2101LLU: // return from reporttype to ProcCall
2417824314 {
2417924315 uint64_t *oldstack = (uint64_t *)stack[0];
2418024316 // copy mutable arguments back from call to reporttype
@@ -24187,20 +24323,20 @@
2418724323 stack = oldstack;
2418824324 fprintf(stderr, "%s", "\n");
2418924325 {
24190- label = 2071LLU; // throw: begin to unroll stack
24326+ label = 2087LLU; // throw: begin to unroll stack
2419124327 break;
2419224328 }
2419324329
24194- label = 2075LLU; // alternative complete
24330+ label = 2091LLU; // alternative complete
2419524331 break;
2419624332 }
24197- case 2075LLU: // completed if-then-else
24333+ case 2091LLU: // completed if-then-else
2419824334 {
2419924335 stack[base + 30]/*sum*/ = 0;
2420024336 // call add from ProcCall
24201- stack[base + 43LLU] = 2086LLU/*throw to this address*/;
24337+ stack[base + 43LLU] = 2102LLU/*throw to this address*/;
2420224338 stack[base + 44LLU] = base;
24203- stack[base + 45LLU] = 2087LLU;
24339+ stack[base + 45LLU] = 2103LLU;
2420424340 // arguments for call to add
2420524341 stack[base + 47LLU] = 4LLU;
2420624342 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24209,21 +24345,21 @@
2420924345 label = 18446744073709551605LLU; // add
2421024346 break;
2421124347 }
24212- case 2086LLU: // copy-back deleter (add to ProcCall)
24348+ case 2102LLU: // copy-back deleter (add to ProcCall)
2421324349 {
2421424350 // copy mutable arguments back from call to add
24215- label = 2071LLU; // continue to roll stack
24351+ label = 2087LLU; // continue to roll stack
2421624352 break;
2421724353 }
24218- case 2087LLU: // return from add to ProcCall
24354+ case 2103LLU: // return from add to ProcCall
2421924355 {
2422024356 // copy mutable arguments back from call to add
2422124357 // copy back results provided by call to add
2422224358 stack[base + 30] = stack[base + 46LLU];
2422324359 // call add from ProcCall
24224- stack[base + 43LLU] = 2088LLU/*throw to this address*/;
24360+ stack[base + 43LLU] = 2104LLU/*throw to this address*/;
2422524361 stack[base + 44LLU] = base;
24226- stack[base + 45LLU] = 2089LLU;
24362+ stack[base + 45LLU] = 2105LLU;
2422724363 // arguments for call to add
2422824364 stack[base + 47LLU] = stack[base + 32]/*index*/;
2422924365 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24232,13 +24368,13 @@
2423224368 label = 18446744073709551605LLU; // add
2423324369 break;
2423424370 }
24235- case 2088LLU: // copy-back deleter (add to ProcCall)
24371+ case 2104LLU: // copy-back deleter (add to ProcCall)
2423624372 {
2423724373 // copy mutable arguments back from call to add
24238- label = 2071LLU; // continue to roll stack
24374+ label = 2087LLU; // continue to roll stack
2423924375 break;
2424024376 }
24241- case 2089LLU: // return from add to ProcCall
24377+ case 2105LLU: // return from add to ProcCall
2424224378 {
2424324379 // copy mutable arguments back from call to add
2424424380 // copy back results provided by call to add
@@ -24245,9 +24381,9 @@
2424524381 stack[base + 30] = stack[base + 46LLU];
2424624382 printf("%s", "\n old");
2424724383 // call emitvaridx from ProcCall
24248- stack[base + 43LLU] = 2090LLU/*throw to this address*/;
24384+ stack[base + 43LLU] = 2106LLU/*throw to this address*/;
2424924385 stack[base + 44LLU] = base;
24250- stack[base + 45LLU] = 2091LLU;
24386+ stack[base + 45LLU] = 2107LLU;
2425124387 // arguments for call to emitvaridx
2425224388 stack[base + 46LLU] = stack[base + 40]/*INDEX*/;
2425324389 // set stack-base & callee-address
@@ -24255,20 +24391,20 @@
2425524391 label = 745LLU; // emitvaridx
2425624392 break;
2425724393 }
24258- case 2090LLU: // copy-back deleter (emitvaridx to ProcCall)
24394+ case 2106LLU: // copy-back deleter (emitvaridx to ProcCall)
2425924395 {
2426024396 // copy mutable arguments back from call to emitvaridx
24261- label = 2071LLU; // continue to roll stack
24397+ label = 2087LLU; // continue to roll stack
2426224398 break;
2426324399 }
24264- case 2091LLU: // return from emitvaridx to ProcCall
24400+ case 2107LLU: // return from emitvaridx to ProcCall
2426524401 {
2426624402 // copy mutable arguments back from call to emitvaridx
2426724403 printf("%s", " = stack[");
2426824404 // call printnr from ProcCall
24269- stack[base + 43LLU] = 2092LLU/*throw to this address*/;
24405+ stack[base + 43LLU] = 2108LLU/*throw to this address*/;
2427024406 stack[base + 44LLU] = base;
24271- stack[base + 45LLU] = 2093LLU;
24407+ stack[base + 45LLU] = 2109LLU;
2427224408 // arguments for call to printnr
2427324409 stack[base + 46LLU] = stack[base + 30]/*sum*/;
2427424410 // set stack-base & callee-address
@@ -24276,53 +24412,53 @@
2427624412 label = 18446744073709551590LLU; // printnr
2427724413 break;
2427824414 }
24279- case 2092LLU: // copy-back deleter (printnr to ProcCall)
24415+ case 2108LLU: // copy-back deleter (printnr to ProcCall)
2428024416 {
2428124417 // copy mutable arguments back from call to printnr
24282- label = 2071LLU; // continue to roll stack
24418+ label = 2087LLU; // continue to roll stack
2428324419 break;
2428424420 }
24285- case 2093LLU: // return from printnr to ProcCall
24421+ case 2109LLU: // return from printnr to ProcCall
2428624422 {
2428724423 // copy mutable arguments back from call to printnr
2428824424 printf("%s", "LLU];");
2428924425 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2429024426 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24291- label = 2069LLU; // case complete
24427+ label = 2085LLU; // case complete
2429224428 break;
2429324429 }
24294- case 2071LLU: // copy-back deleter (switch)
24430+ case 2087LLU: // copy-back deleter (switch)
2429524431 {
2429624432 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2429724433 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24298- label = 2068LLU; // continue to unroll stack
24434+ label = 2084LLU; // continue to unroll stack
2429924435 break;
2430024436 }
24301- case 2070LLU: // try next case
24437+ case 2086LLU: // try next case
2430224438 {
2430324439 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2430424440 exit(-1);
2430524441 }
24306- case 2069LLU: // completed switch
24442+ case 2085LLU: // completed switch
2430724443 {
2430824444 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2430924445 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24310- label = 2066LLU; // case complete
24446+ label = 2082LLU; // case complete
2431124447 break;
2431224448 }
24313- case 2068LLU: // copy-back deleter (switch)
24449+ case 2084LLU: // copy-back deleter (switch)
2431424450 {
2431524451 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2431624452 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24317- label = 2065LLU; // continue to unroll stack
24453+ label = 2081LLU; // continue to unroll stack
2431824454 break;
2431924455 }
24320- case 2067LLU: // try next case
24456+ case 2083LLU: // try next case
2432124457 {
2432224458 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2432324459 exit(-1);
2432424460 }
24325- case 2066LLU: // completed switch
24461+ case 2082LLU: // completed switch
2432624462 {
2432724463
2432824464 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24330,7 +24466,7 @@
2433024466 newstack[0] = (uint64_t)stack; // backup stack location
2433124467 newstack[1] = 1234567890;
2433224468 newstack[2] = base;
24333- newstack[3] = 2094LLU;
24469+ newstack[3] = 2110LLU;
2433424470 stack = newstack;
2433524471 // set stack-base & callee-address
2433624472 base = 4/*deloffset*/;
@@ -24337,16 +24473,16 @@
2433724473 label = 399LLU; // ~typeidx
2433824474 break;
2433924475 }
24340- case 2094LLU: // return from ~typeidx to ProcCall
24476+ case 2110LLU: // return from ~typeidx to ProcCall
2434124477 {
2434224478 stack = (uint64_t *)stack[0];
2434324479 // releasing toplevel container
2434424480 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2434524481
24346- label = 2064LLU; // consequent complete
24482+ label = 2080LLU; // consequent complete
2434724483 break;
2434824484 }
24349- case 2065LLU: // copy-back deleter (if pop)
24485+ case 2081LLU: // copy-back deleter (if pop)
2435024486 {
2435124487
2435224488 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24354,7 +24490,7 @@
2435424490 newstack[0] = (uint64_t)stack; // backup stack location
2435524491 newstack[1] = 1234567890;
2435624492 newstack[2] = base;
24357- newstack[3] = 2095LLU;
24493+ newstack[3] = 2111LLU;
2435824494 stack = newstack;
2435924495 // set stack-base & callee-address
2436024496 base = 4/*deloffset*/;
@@ -24361,22 +24497,22 @@
2436124497 label = 399LLU; // ~typeidx
2436224498 break;
2436324499 }
24364- case 2095LLU: // return from ~typeidx to ProcCall
24500+ case 2111LLU: // return from ~typeidx to ProcCall
2436524501 {
2436624502 stack = (uint64_t *)stack[0];
2436724503 // releasing toplevel container
2436824504 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2436924505
24370- label = 2058LLU; // consequent complete
24506+ label = 2074LLU; // consequent complete
2437124507 break;
2437224508 }
24373- case 2063LLU: // alternative
24509+ case 2079LLU: // alternative
2437424510 {
2437524511 fprintf(stderr, "%s", "in function ");
2437624512 // call reportid from ProcCall
24377- stack[base + 39LLU] = 2096LLU/*throw to this address*/;
24513+ stack[base + 39LLU] = 2112LLU/*throw to this address*/;
2437824514 stack[base + 40LLU] = base;
24379- stack[base + 41LLU] = 2097LLU;
24515+ stack[base + 41LLU] = 2113LLU;
2438024516 // arguments for call to reportid
2438124517 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2438224518 // set stack-base & callee-address
@@ -24384,20 +24520,20 @@
2438424520 label = 18446744073709551586LLU; // reportid
2438524521 break;
2438624522 }
24387- case 2096LLU: // copy-back deleter (reportid to ProcCall)
24523+ case 2112LLU: // copy-back deleter (reportid to ProcCall)
2438824524 {
2438924525 // copy mutable arguments back from call to reportid
24390- label = 2058LLU; // continue to roll stack
24526+ label = 2074LLU; // continue to roll stack
2439124527 break;
2439224528 }
24393- case 2097LLU: // return from reportid to ProcCall
24529+ case 2113LLU: // return from reportid to ProcCall
2439424530 {
2439524531 // copy mutable arguments back from call to reportid
2439624532 fprintf(stderr, "%s", " call to ");
2439724533 // call reportid from ProcCall
24398- stack[base + 39LLU] = 2098LLU/*throw to this address*/;
24534+ stack[base + 39LLU] = 2114LLU/*throw to this address*/;
2439924535 stack[base + 40LLU] = base;
24400- stack[base + 41LLU] = 2099LLU;
24536+ stack[base + 41LLU] = 2115LLU;
2440124537 // arguments for call to reportid
2440224538 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2440324539 // set stack-base & callee-address
@@ -24405,20 +24541,20 @@
2440524541 label = 18446744073709551586LLU; // reportid
2440624542 break;
2440724543 }
24408- case 2098LLU: // copy-back deleter (reportid to ProcCall)
24544+ case 2114LLU: // copy-back deleter (reportid to ProcCall)
2440924545 {
2441024546 // copy mutable arguments back from call to reportid
24411- label = 2058LLU; // continue to roll stack
24547+ label = 2074LLU; // continue to roll stack
2441224548 break;
2441324549 }
24414- case 2099LLU: // return from reportid to ProcCall
24550+ case 2115LLU: // return from reportid to ProcCall
2441524551 {
2441624552 // copy mutable arguments back from call to reportid
2441724553 fprintf(stderr, "%s", " at position ");
2441824554 // call reportnr from ProcCall
24419- stack[base + 39LLU] = 2100LLU/*throw to this address*/;
24555+ stack[base + 39LLU] = 2116LLU/*throw to this address*/;
2442024556 stack[base + 40LLU] = base;
24421- stack[base + 41LLU] = 2101LLU;
24557+ stack[base + 41LLU] = 2117LLU;
2442224558 // arguments for call to reportnr
2442324559 stack[base + 42LLU] = stack[base + 32]/*index*/;
2442424560 // set stack-base & callee-address
@@ -24426,54 +24562,54 @@
2442624562 label = 18446744073709551589LLU; // reportnr
2442724563 break;
2442824564 }
24429- case 2100LLU: // copy-back deleter (reportnr to ProcCall)
24565+ case 2116LLU: // copy-back deleter (reportnr to ProcCall)
2443024566 {
2443124567 // copy mutable arguments back from call to reportnr
24432- label = 2058LLU; // continue to roll stack
24568+ label = 2074LLU; // continue to roll stack
2443324569 break;
2443424570 }
24435- case 2101LLU: // return from reportnr to ProcCall
24571+ case 2117LLU: // return from reportnr to ProcCall
2443624572 {
2443724573 // copy mutable arguments back from call to reportnr
2443824574 fprintf(stderr, "%s", " not enough destination-variables for results");
2443924575 fprintf(stderr, "%s", "\n");
2444024576 {
24441- label = 2058LLU; // throw: begin to unroll stack
24577+ label = 2074LLU; // throw: begin to unroll stack
2444224578 break;
2444324579 }
2444424580
24445- label = 2064LLU; // alternative complete
24581+ label = 2080LLU; // alternative complete
2444624582 break;
2444724583 }
24448- case 2064LLU: // completed if-then-else
24584+ case 2080LLU: // completed if-then-else
2444924585 {
2445024586 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24451- label = 2056LLU; // repeat
24587+ label = 2072LLU; // repeat
2445224588 break;
2445324589 }
24454- case 2058LLU: // copy-back deleter for while next
24590+ case 2074LLU: // copy-back deleter for while next
2445524591 {
2445624592 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24457- label = 1779LLU; // continue to unroll stack
24593+ label = 1795LLU; // continue to unroll stack
2445824594 break;
2445924595 }
24460- case 2057LLU: // loop finished
24596+ case 2073LLU: // loop finished
2446124597 {
24462- label = 2053LLU; // consequent complete
24598+ label = 2069LLU; // consequent complete
2446324599 break;
2446424600 }
24465- case 2052LLU: // alternative
24601+ case 2068LLU: // alternative
2446624602 {
24467- label = 2053LLU; // alternative complete
24603+ label = 2069LLU; // alternative complete
2446824604 break;
2446924605 }
24470- case 2053LLU: // completed if-then-else
24606+ case 2069LLU: // completed if-then-else
2447124607 {
2447224608 printf("%s", "\n if(stack[");
2447324609 // call printnr from ProcCall
24474- stack[base + 35LLU] = 2102LLU/*throw to this address*/;
24610+ stack[base + 35LLU] = 2118LLU/*throw to this address*/;
2447524611 stack[base + 36LLU] = base;
24476- stack[base + 37LLU] = 2103LLU;
24612+ stack[base + 37LLU] = 2119LLU;
2447724613 // arguments for call to printnr
2447824614 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2447924615 // set stack-base & callee-address
@@ -24481,13 +24617,13 @@
2448124617 label = 18446744073709551590LLU; // printnr
2448224618 break;
2448324619 }
24484- case 2102LLU: // copy-back deleter (printnr to ProcCall)
24620+ case 2118LLU: // copy-back deleter (printnr to ProcCall)
2448524621 {
2448624622 // copy mutable arguments back from call to printnr
24487- label = 1779LLU; // continue to roll stack
24623+ label = 1795LLU; // continue to roll stack
2448824624 break;
2448924625 }
24490- case 2103LLU: // return from printnr to ProcCall
24626+ case 2119LLU: // return from printnr to ProcCall
2449124627 {
2449224628 // copy mutable arguments back from call to printnr
2449324629 printf("%s", "LLU] != 9876543210LLU)");
@@ -24494,9 +24630,9 @@
2449424630 printf("%s", "\n {");
2449524631 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2449624632 // call printid from ProcCall
24497- stack[base + 35LLU] = 2104LLU/*throw to this address*/;
24633+ stack[base + 35LLU] = 2120LLU/*throw to this address*/;
2449824634 stack[base + 36LLU] = base;
24499- stack[base + 37LLU] = 2105LLU;
24635+ stack[base + 37LLU] = 2121LLU;
2450024636 // arguments for call to printid
2450124637 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2450224638 // set stack-base & callee-address
@@ -24504,13 +24640,13 @@
2450424640 label = 18446744073709551587LLU; // printid
2450524641 break;
2450624642 }
24507- case 2104LLU: // copy-back deleter (printid to ProcCall)
24643+ case 2120LLU: // copy-back deleter (printid to ProcCall)
2450824644 {
2450924645 // copy mutable arguments back from call to printid
24510- label = 1779LLU; // continue to roll stack
24646+ label = 1795LLU; // continue to roll stack
2451124647 break;
2451224648 }
24513- case 2105LLU: // return from printid to ProcCall
24649+ case 2121LLU: // return from printid to ProcCall
2451424650 {
2451524651 // copy mutable arguments back from call to printid
2451624652 printf("%s", ")!\\n\");");
@@ -24518,9 +24654,9 @@
2451824654 printf("%s", "\n }");
2451924655 printf("%s", "\n Free(");
2452024656 // call printnr from ProcCall
24521- stack[base + 35LLU] = 2106LLU/*throw to this address*/;
24657+ stack[base + 35LLU] = 2122LLU/*throw to this address*/;
2452224658 stack[base + 36LLU] = base;
24523- stack[base + 37LLU] = 2107LLU;
24659+ stack[base + 37LLU] = 2123LLU;
2452424660 // arguments for call to printnr
2452524661 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2452624662 // set stack-base & callee-address
@@ -24528,26 +24664,26 @@
2452824664 label = 18446744073709551590LLU; // printnr
2452924665 break;
2453024666 }
24531- case 2106LLU: // copy-back deleter (printnr to ProcCall)
24667+ case 2122LLU: // copy-back deleter (printnr to ProcCall)
2453224668 {
2453324669 // copy mutable arguments back from call to printnr
24534- label = 1779LLU; // continue to roll stack
24670+ label = 1795LLU; // continue to roll stack
2453524671 break;
2453624672 }
24537- case 2107LLU: // return from printnr to ProcCall
24673+ case 2123LLU: // return from printnr to ProcCall
2453824674 {
2453924675 // copy mutable arguments back from call to printnr
2454024676 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
2454124677 printf("%s", "\n stack = oldstack;");
24542- label = 1768LLU; // consequent complete
24678+ label = 1784LLU; // consequent complete
2454324679 break;
2454424680 }
24545- case 1767LLU: // alternative
24681+ case 1783LLU: // alternative
2454624682 {
2454724683 // call add from ProcCall
24548- stack[base + 33LLU] = 2108LLU/*throw to this address*/;
24684+ stack[base + 33LLU] = 2124LLU/*throw to this address*/;
2454924685 stack[base + 34LLU] = base;
24550- stack[base + 35LLU] = 2109LLU;
24686+ stack[base + 35LLU] = 2125LLU;
2455124687 // arguments for call to add
2455224688 stack[base + 37LLU] = 1LLU;
2455324689 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -24556,39 +24692,39 @@
2455624692 label = 18446744073709551605LLU; // add
2455724693 break;
2455824694 }
24559- case 2108LLU: // copy-back deleter (add to ProcCall)
24695+ case 2124LLU: // copy-back deleter (add to ProcCall)
2456024696 {
2456124697 // copy mutable arguments back from call to add
24562- label = 1765LLU; // continue to roll stack
24698+ label = 1781LLU; // continue to roll stack
2456324699 break;
2456424700 }
24565- case 2109LLU: // return from add to ProcCall
24701+ case 2125LLU: // return from add to ProcCall
2456624702 {
2456724703 // copy mutable arguments back from call to add
2456824704 // copy back results provided by call to add
2456924705 stack[base + 17] = stack[base + 36LLU];
24570- label = 2111LLU; // skip deleter
24706+ label = 2127LLU; // skip deleter
2457124707 break;
2457224708 }
24573- case 2110LLU: // deleter
24709+ case 2126LLU: // deleter
2457424710 {
2457524711 // throw from ProcCall
2457624712 if(!stack[base + 33])
2457724713 {
24578- label = 1765LLU; // skip, variable already deleted/unscoped
24714+ label = 1781LLU; // skip, variable already deleted/unscoped
2457924715 break;
2458024716 }
24581- label = 1765LLU; // continue unrolling stack, delete next variable
24717+ label = 1781LLU; // continue unrolling stack, delete next variable
2458224718 break;
2458324719 }
24584- case 2111LLU: // skipped deleter
24720+ case 2127LLU: // skipped deleter
2458524721 {
2458624722 stack[base + 33] = stack[base + 17]/*label*/;
2458724723 printf("%s", "\n // call ");
2458824724 // call printid from ProcCall
24589- stack[base + 34LLU] = 2112LLU/*throw to this address*/;
24725+ stack[base + 34LLU] = 2128LLU/*throw to this address*/;
2459024726 stack[base + 35LLU] = base;
24591- stack[base + 36LLU] = 2113LLU;
24727+ stack[base + 36LLU] = 2129LLU;
2459224728 // arguments for call to printid
2459324729 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2459424730 // set stack-base & callee-address
@@ -24596,20 +24732,20 @@
2459624732 label = 18446744073709551587LLU; // printid
2459724733 break;
2459824734 }
24599- case 2112LLU: // copy-back deleter (printid to ProcCall)
24735+ case 2128LLU: // copy-back deleter (printid to ProcCall)
2460024736 {
2460124737 // copy mutable arguments back from call to printid
24602- label = 2110LLU; // continue to roll stack
24738+ label = 2126LLU; // continue to roll stack
2460324739 break;
2460424740 }
24605- case 2113LLU: // return from printid to ProcCall
24741+ case 2129LLU: // return from printid to ProcCall
2460624742 {
2460724743 // copy mutable arguments back from call to printid
2460824744 printf("%s", " from ");
2460924745 // call printid from ProcCall
24610- stack[base + 34LLU] = 2114LLU/*throw to this address*/;
24746+ stack[base + 34LLU] = 2130LLU/*throw to this address*/;
2461124747 stack[base + 35LLU] = base;
24612- stack[base + 36LLU] = 2115LLU;
24748+ stack[base + 36LLU] = 2131LLU;
2461324749 // arguments for call to printid
2461424750 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2461524751 // set stack-base & callee-address
@@ -24617,20 +24753,20 @@
2461724753 label = 18446744073709551587LLU; // printid
2461824754 break;
2461924755 }
24620- case 2114LLU: // copy-back deleter (printid to ProcCall)
24756+ case 2130LLU: // copy-back deleter (printid to ProcCall)</