• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1211 (tree)
Time2021-03-29 06:17:42
Authorjakobthomsen

Log Message

reserve keywords

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1210)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1211)
@@ -17714,7 +17714,7 @@
1771417714 {
1771517715 //#define res0 0
1771617716 //#define arg0 1
17717- if(712900230996426752 != stack[base + 1]/*id*/)
17717+ if(548522061983645696 != 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(787446707498516480 != stack[base + 1]/*id*/)
17751+ if(712900230996426752 != 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(788334650111033344 != stack[base + 1]/*id*/)
17785+ if(787446707498516480 != 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(819847183506341888 != stack[base + 1]/*id*/)
17819+ if(788334650111033344 != 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(819872884582252544 != stack[base + 1]/*id*/)
17853+ if(819847183506341888 != 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(856729206128640000 != stack[base + 1]/*id*/)
17887+ if(819872884582252544 != 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(842862180511514624 != stack[base + 1]/*id*/)
17921+ if(856729206128640000 != stack[base + 1]/*id*/)
1792217922 {
1792317923 label = 1528LLU; // jump to alternative
1792417924 break;
@@ -17952,11 +17952,79 @@
1795217952 }
1795317953 case 1528LLU: // try next case
1795417954 {
17955+ if(859571802316210176 != stack[base + 1]/*id*/)
17956+ {
17957+ label = 1532LLU; // jump to alternative
17958+ break;
17959+ }
17960+
17961+ // case
17962+ label = 1535LLU; // skip deleter
17963+ break;
17964+ }
17965+ case 1534LLU: // deleter
17966+ {
17967+ // throw from reservedfn
17968+ if(!stack[base + 0])
17969+ {
17970+ label = 1533LLU; // skip, variable already deleted/unscoped
17971+ break;
17972+ }
17973+ label = 1533LLU; // continue unrolling stack, delete next variable
17974+ break;
17975+ }
17976+ case 1535LLU: // skipped deleter
17977+ {
17978+ stack[base + 0] = 1;
17979+ label = 1503LLU; // case complete
17980+ break;
17981+ }
17982+ case 1533LLU: // copy-back deleter (switch)
17983+ {
17984+ label = 1502LLU; // continue to unroll stack
17985+ break;
17986+ }
17987+ case 1532LLU: // try next case
17988+ {
17989+ if(842862180511514624 != stack[base + 1]/*id*/)
17990+ {
17991+ label = 1536LLU; // jump to alternative
17992+ break;
17993+ }
17994+
17995+ // case
17996+ label = 1539LLU; // skip deleter
17997+ break;
17998+ }
17999+ case 1538LLU: // deleter
18000+ {
18001+ // throw from reservedfn
18002+ if(!stack[base + 0])
18003+ {
18004+ label = 1537LLU; // skip, variable already deleted/unscoped
18005+ break;
18006+ }
18007+ label = 1537LLU; // continue unrolling stack, delete next variable
18008+ break;
18009+ }
18010+ case 1539LLU: // skipped deleter
18011+ {
18012+ stack[base + 0] = 1;
18013+ label = 1503LLU; // case complete
18014+ break;
18015+ }
18016+ case 1537LLU: // copy-back deleter (switch)
18017+ {
18018+ label = 1502LLU; // continue to unroll stack
18019+ break;
18020+ }
18021+ case 1536LLU: // try next case
18022+ {
1795518023 // default
17956- label = 1533LLU; // skip deleter
18024+ label = 1541LLU; // skip deleter
1795718025 break;
1795818026 }
17959- case 1532LLU: // deleter
18027+ case 1540LLU: // deleter
1796018028 {
1796118029 // throw from reservedfn
1796218030 if(!stack[base + 0])
@@ -17967,7 +18035,7 @@
1796718035 label = 1502LLU; // continue unrolling stack, delete next variable
1796818036 break;
1796918037 }
17970- case 1533LLU: // skipped deleter
18038+ case 1541LLU: // skipped deleter
1797118039 {
1797218040 stack[base + 0] = 0;
1797318041 label = 1503LLU; // default complete
@@ -17980,38 +18048,38 @@
1798018048 base = stack[base - 2];
1798118049 break;
1798218050 }
17983- case 1535LLU: // function FindFn failed
18051+ case 1543LLU: // function FindFn failed
1798418052 {
1798518053 label = stack[base - 3];
1798618054 base = stack[base - 2];
1798718055 break;
1798818056 }
17989- case 1534LLU: // FindFn
18057+ case 1542LLU: // FindFn
1799018058 {
1799118059 //#define res0 0
1799218060 //#define arg0 1
1799318061 //#define arg1 2
1799418062 //#define arg2 3
17995- label = 1537LLU; // skip deleter
18063+ label = 1545LLU; // skip deleter
1799618064 break;
1799718065 }
17998- case 1536LLU: // deleter
18066+ case 1544LLU: // deleter
1799918067 {
1800018068 // throw from FindFn
1800118069 if(!stack[base + 4])
1800218070 {
18003- label = 1535LLU; // skip, variable already deleted/unscoped
18071+ label = 1543LLU; // skip, variable already deleted/unscoped
1800418072 break;
1800518073 }
18006- label = 1535LLU; // continue unrolling stack, delete next variable
18074+ label = 1543LLU; // continue unrolling stack, delete next variable
1800718075 break;
1800818076 }
18009- case 1537LLU: // skipped deleter
18077+ case 1545LLU: // skipped deleter
1801018078 {
1801118079 // call reservedfn from FindFn
18012- stack[base + 5LLU] = 1538LLU/*throw to this address*/;
18080+ stack[base + 5LLU] = 1546LLU/*throw to this address*/;
1801318081 stack[base + 6LLU] = base;
18014- stack[base + 7LLU] = 1539LLU;
18082+ stack[base + 7LLU] = 1547LLU;
1801518083 // arguments for call to reservedfn
1801618084 stack[base + 9LLU] = stack[base + 3]/*id*/;
1801718085 // set stack-base & callee-address
@@ -18019,13 +18087,13 @@
1801918087 label = 1501LLU; // reservedfn
1802018088 break;
1802118089 }
18022- case 1538LLU: // copy-back deleter (reservedfn to FindFn)
18090+ case 1546LLU: // copy-back deleter (reservedfn to FindFn)
1802318091 {
1802418092 // copy mutable arguments back from call to reservedfn
18025- label = 1535LLU; // continue to roll stack
18093+ label = 1543LLU; // continue to roll stack
1802618094 break;
1802718095 }
18028- case 1539LLU: // return from reservedfn to FindFn
18096+ case 1547LLU: // return from reservedfn to FindFn
1802918097 {
1803018098 // copy mutable arguments back from call to reservedfn
1803118099 // copy back results provided by call to reservedfn
@@ -18032,7 +18100,7 @@
1803218100 stack[base + 4] = stack[base + 8LLU];
1803318101 if(!stack[base + 4]/*found*/)
1803418102 {
18035- label = 1540LLU; // jump to alternative
18103+ label = 1548LLU; // jump to alternative
1803618104 break;
1803718105 }
1803818106
@@ -18039,9 +18107,9 @@
1803918107 // consequent
1804018108 fprintf(stderr, "%s", "in function ");
1804118109 // call reportid from FindFn
18042- stack[base + 5LLU] = 1542LLU/*throw to this address*/;
18110+ stack[base + 5LLU] = 1550LLU/*throw to this address*/;
1804318111 stack[base + 6LLU] = base;
18044- stack[base + 7LLU] = 1543LLU;
18112+ stack[base + 7LLU] = 1551LLU;
1804518113 // arguments for call to reportid
1804618114 stack[base + 8LLU] = stack[base + 1]/*fnid*/;
1804718115 // set stack-base & callee-address
@@ -18049,21 +18117,21 @@
1804918117 label = 18446744073709551586LLU; // reportid
1805018118 break;
1805118119 }
18052- case 1542LLU: // copy-back deleter (reportid to FindFn)
18120+ case 1550LLU: // copy-back deleter (reportid to FindFn)
1805318121 {
1805418122 // copy mutable arguments back from call to reportid
18055- label = 1536LLU; // continue to roll stack
18123+ label = 1544LLU; // continue to roll stack
1805618124 break;
1805718125 }
18058- case 1543LLU: // return from reportid to FindFn
18126+ case 1551LLU: // return from reportid to FindFn
1805918127 {
1806018128 // copy mutable arguments back from call to reportid
1806118129 fprintf(stderr, "%s", ": ");
1806218130 fprintf(stderr, "%s", "reserved function ");
1806318131 // call reportid from FindFn
18064- stack[base + 5LLU] = 1544LLU/*throw to this address*/;
18132+ stack[base + 5LLU] = 1552LLU/*throw to this address*/;
1806518133 stack[base + 6LLU] = base;
18066- stack[base + 7LLU] = 1545LLU;
18134+ stack[base + 7LLU] = 1553LLU;
1806718135 // arguments for call to reportid
1806818136 stack[base + 8LLU] = stack[base + 3]/*id*/;
1806918137 // set stack-base & callee-address
@@ -18071,40 +18139,40 @@
1807118139 label = 18446744073709551586LLU; // reportid
1807218140 break;
1807318141 }
18074- case 1544LLU: // copy-back deleter (reportid to FindFn)
18142+ case 1552LLU: // copy-back deleter (reportid to FindFn)
1807518143 {
1807618144 // copy mutable arguments back from call to reportid
18077- label = 1536LLU; // continue to roll stack
18145+ label = 1544LLU; // continue to roll stack
1807818146 break;
1807918147 }
18080- case 1545LLU: // return from reportid to FindFn
18148+ case 1553LLU: // return from reportid to FindFn
1808118149 {
1808218150 // copy mutable arguments back from call to reportid
1808318151 fprintf(stderr, "%s", " not called properly - check result-types & parameter-types\n");
1808418152 {
18085- label = 1536LLU; // throw: begin to unroll stack
18153+ label = 1544LLU; // throw: begin to unroll stack
1808618154 break;
1808718155 }
1808818156
18089- label = 1541LLU; // consequent complete
18157+ label = 1549LLU; // consequent complete
1809018158 break;
1809118159 }
18092- case 1540LLU: // alternative
18160+ case 1548LLU: // alternative
1809318161 {
18094- label = 1541LLU; // alternative complete
18162+ label = 1549LLU; // alternative complete
1809518163 break;
1809618164 }
18097- case 1541LLU: // completed if-then-else
18165+ case 1549LLU: // completed if-then-else
1809818166 {
18099- label = 1547LLU; // skip deleter
18167+ label = 1555LLU; // skip deleter
1810018168 break;
1810118169 }
18102- case 1546LLU: // deleter
18170+ case 1554LLU: // deleter
1810318171 {
1810418172 // throw from FindFn
1810518173 if(!stack[base + 5])
1810618174 {
18107- label = 1536LLU; // skip, variable already deleted/unscoped
18175+ label = 1544LLU; // skip, variable already deleted/unscoped
1810818176 break;
1810918177 }
1811018178
@@ -18113,7 +18181,7 @@
1811318181 newstack[0] = (uint64_t)stack; // backup stack location
1811418182 newstack[1] = 1234567890;
1811518183 newstack[2] = base;
18116- newstack[3] = 1548LLU;
18184+ newstack[3] = 1556LLU;
1811718185 stack = newstack;
1811818186 // set stack-base & callee-address
1811918187 base = 4/*deloffset*/;
@@ -18120,21 +18188,21 @@
1812018188 label = 1420LLU; // ~fndef
1812118189 break;
1812218190 }
18123- case 1548LLU: // return from ~fndef to FindFn
18191+ case 1556LLU: // return from ~fndef to FindFn
1812418192 {
1812518193 stack = (uint64_t *)stack[0];
1812618194 // releasing toplevel container
1812718195 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4));
1812818196
18129- label = 1536LLU; // continue unrolling stack, delete next variable
18197+ label = 1544LLU; // continue unrolling stack, delete next variable
1813018198 break;
1813118199 }
18132- case 1547LLU: // skipped deleter
18200+ case 1555LLU: // skipped deleter
1813318201 {
1813418202 // call mkfndummy from FindFn
18135- stack[base + 6LLU] = 1549LLU/*throw to this address*/;
18203+ stack[base + 6LLU] = 1557LLU/*throw to this address*/;
1813618204 stack[base + 7LLU] = base;
18137- stack[base + 8LLU] = 1550LLU;
18205+ stack[base + 8LLU] = 1558LLU;
1813818206 // arguments for call to mkfndummy
1813918207 // set stack-base & callee-address
1814018208 base += 9LLU;
@@ -18141,26 +18209,26 @@
1814118209 label = 1428LLU; // mkfndummy
1814218210 break;
1814318211 }
18144- case 1549LLU: // copy-back deleter (mkfndummy to FindFn)
18212+ case 1557LLU: // copy-back deleter (mkfndummy to FindFn)
1814518213 {
1814618214 // copy mutable arguments back from call to mkfndummy
18147- label = 1536LLU; // continue to roll stack
18215+ label = 1544LLU; // continue to roll stack
1814818216 break;
1814918217 }
18150- case 1550LLU: // return from mkfndummy to FindFn
18218+ case 1558LLU: // return from mkfndummy to FindFn
1815118219 {
1815218220 // copy mutable arguments back from call to mkfndummy
1815318221 // copy back results provided by call to mkfndummy
1815418222 stack[base + 5] = stack[base + 9LLU];
1815518223 flippedassign(stack[base + 2]/*fndefs*/, &stack[base + 6]);
18156- label = 1551LLU; // start to repeat
18224+ label = 1559LLU; // start to repeat
1815718225 break;
1815818226 }
18159- case 1551LLU: // repeat from here
18227+ case 1559LLU: // repeat from here
1816018228 {
1816118229 if(!stack[base + 6])
1816218230 {
18163- label = 1552LLU; // break loop
18231+ label = 1560LLU; // break loop
1816418232 break;
1816518233 }
1816618234
@@ -18170,19 +18238,19 @@
1817018238 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
1817118239 if(!stack[base + 4]/*found*/)
1817218240 {
18173- label = 1554LLU; // jump to alternative
18241+ label = 1562LLU; // jump to alternative
1817418242 break;
1817518243 }
1817618244
1817718245 // consequent
18178- label = 1555LLU; // consequent complete
18246+ label = 1563LLU; // consequent complete
1817918247 break;
1818018248 }
18181- case 1554LLU: // alternative
18249+ case 1562LLU: // alternative
1818218250 {
1818318251 if(/*fndef*/0 != ((uint64_t *)(stack[base + 7]/*fndef*/))[0])
1818418252 {
18185- label = 1557LLU; // jump to alternative
18253+ label = 1565LLU; // jump to alternative
1818618254 break;
1818718255 }
1818818256
@@ -18196,27 +18264,27 @@
1819618264 /*IO*/stack[base + 16] = ((uint64_t **)(stack[base + 7]/*fndef*/))[1][7]/*IO*/;
1819718265
1819818266 // case
18199- label = 1560LLU; // skip deleter
18267+ label = 1568LLU; // skip deleter
1820018268 break;
1820118269 }
18202- case 1559LLU: // deleter
18270+ case 1567LLU: // deleter
1820318271 {
1820418272 // throw from FindFn
1820518273 if(!stack[base + 17])
1820618274 {
18207- label = 1558LLU; // skip, variable already deleted/unscoped
18275+ label = 1566LLU; // skip, variable already deleted/unscoped
1820818276 break;
1820918277 }
18210- label = 1558LLU; // continue unrolling stack, delete next variable
18278+ label = 1566LLU; // continue unrolling stack, delete next variable
1821118279 break;
1821218280 }
18213- case 1560LLU: // skipped deleter
18281+ case 1568LLU: // skipped deleter
1821418282 {
1821518283 stack[base + 17] = 0;
1821618284 // call equ from FindFn
18217- stack[base + 18LLU] = 1561LLU/*throw to this address*/;
18285+ stack[base + 18LLU] = 1569LLU/*throw to this address*/;
1821818286 stack[base + 19LLU] = base;
18219- stack[base + 20LLU] = 1562LLU;
18287+ stack[base + 20LLU] = 1570LLU;
1822018288 // arguments for call to equ
1822118289 stack[base + 22LLU] = stack[base + 3]/*id*/;
1822218290 stack[base + 23LLU] = stack[base + 13]/*defid*/;
@@ -18225,13 +18293,13 @@
1822518293 label = 18446744073709551600LLU; // equ
1822618294 break;
1822718295 }
18228- case 1561LLU: // copy-back deleter (equ to FindFn)
18296+ case 1569LLU: // copy-back deleter (equ to FindFn)
1822918297 {
1823018298 // copy mutable arguments back from call to equ
18231- label = 1559LLU; // continue to roll stack
18299+ label = 1567LLU; // continue to roll stack
1823218300 break;
1823318301 }
18234- case 1562LLU: // return from equ to FindFn
18302+ case 1570LLU: // return from equ to FindFn
1823518303 {
1823618304 // copy mutable arguments back from call to equ
1823718305 // copy back results provided by call to equ
@@ -18238,20 +18306,20 @@
1823818306 stack[base + 17] = stack[base + 21LLU];
1823918307 if(!stack[base + 17]/*isequal*/)
1824018308 {
18241- label = 1563LLU; // jump to alternative
18309+ label = 1571LLU; // jump to alternative
1824218310 break;
1824318311 }
1824418312
1824518313 // consequent
18246- label = 1566LLU; // skip deleter
18314+ label = 1574LLU; // skip deleter
1824718315 break;
1824818316 }
18249- case 1565LLU: // deleter
18317+ case 1573LLU: // deleter
1825018318 {
1825118319 // throw from FindFn
1825218320 if(!stack[base + 18])
1825318321 {
18254- label = 1559LLU; // skip, variable already deleted/unscoped
18322+ label = 1567LLU; // skip, variable already deleted/unscoped
1825518323 break;
1825618324 }
1825718325
@@ -18260,7 +18328,7 @@
1826018328 newstack[0] = (uint64_t)stack; // backup stack location
1826118329 newstack[1] = 1234567890;
1826218330 newstack[2] = base;
18263- newstack[3] = 1567LLU;
18331+ newstack[3] = 1575LLU;
1826418332 stack = newstack;
1826518333 // set stack-base & callee-address
1826618334 base = 4/*deloffset*/;
@@ -18267,21 +18335,21 @@
1826718335 label = 1420LLU; // ~fndef
1826818336 break;
1826918337 }
18270- case 1567LLU: // return from ~fndef to FindFn
18338+ case 1575LLU: // return from ~fndef to FindFn
1827118339 {
1827218340 stack = (uint64_t *)stack[0];
1827318341 // releasing toplevel container
1827418342 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1827518343
18276- label = 1559LLU; // continue unrolling stack, delete next variable
18344+ label = 1567LLU; // continue unrolling stack, delete next variable
1827718345 break;
1827818346 }
18279- case 1566LLU: // skipped deleter
18347+ case 1574LLU: // skipped deleter
1828018348 {
1828118349 // call copyfndef from FindFn
18282- stack[base + 19LLU] = 1568LLU/*throw to this address*/;
18350+ stack[base + 19LLU] = 1576LLU/*throw to this address*/;
1828318351 stack[base + 20LLU] = base;
18284- stack[base + 21LLU] = 1569LLU;
18352+ stack[base + 21LLU] = 1577LLU;
1828518353 // arguments for call to copyfndef
1828618354 stack[base + 23LLU] = stack[base + 7]/*fndef*/;
1828718355 // set stack-base & callee-address
@@ -18289,13 +18357,13 @@
1828918357 label = 1455LLU; // copyfndef
1829018358 break;
1829118359 }
18292- case 1568LLU: // copy-back deleter (copyfndef to FindFn)
18360+ case 1576LLU: // copy-back deleter (copyfndef to FindFn)
1829318361 {
1829418362 // copy mutable arguments back from call to copyfndef
18295- label = 1559LLU; // continue to roll stack
18363+ label = 1567LLU; // continue to roll stack
1829618364 break;
1829718365 }
18298- case 1569LLU: // return from copyfndef to FindFn
18366+ case 1577LLU: // return from copyfndef to FindFn
1829918367 {
1830018368 // copy mutable arguments back from call to copyfndef
1830118369 // copy back results provided by call to copyfndef
@@ -18308,7 +18376,7 @@
1830818376 newstack[0] = (uint64_t)stack; // backup stack location
1830918377 newstack[1] = 1234567890;
1831018378 newstack[2] = base;
18311- newstack[3] = 1570LLU;
18379+ newstack[3] = 1578LLU;
1831218380 stack = newstack;
1831318381 // set stack-base & callee-address
1831418382 base = 4/*deloffset*/;
@@ -18315,21 +18383,21 @@
1831518383 label = 1420LLU; // ~fndef
1831618384 break;
1831718385 }
18318- case 1570LLU: // return from ~fndef to FindFn
18386+ case 1578LLU: // return from ~fndef to FindFn
1831918387 {
1832018388 stack = (uint64_t *)stack[0];
1832118389 // releasing toplevel container
1832218390 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
1832318391
18324- label = 1564LLU; // consequent complete
18392+ label = 1572LLU; // consequent complete
1832518393 break;
1832618394 }
18327- case 1563LLU: // alternative
18395+ case 1571LLU: // alternative
1832818396 {
18329- label = 1564LLU; // alternative complete
18397+ label = 1572LLU; // alternative complete
1833018398 break;
1833118399 }
18332- case 1564LLU: // completed if-then-else
18400+ case 1572LLU: // completed if-then-else
1833318401 {
1833418402 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1833518403 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18339,10 +18407,10 @@
1833918407 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1834018408 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1834118409 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18342- label = 1556LLU; // case complete
18410+ label = 1564LLU; // case complete
1834318411 break;
1834418412 }
18345- case 1558LLU: // copy-back deleter (switch)
18413+ case 1566LLU: // copy-back deleter (switch)
1834618414 {
1834718415 ((uint64_t **)(stack[base + 7]))[1][7] = stack[base + 16];
1834818416 ((uint64_t **)(stack[base + 7]))[1][6] = stack[base + 15];
@@ -18352,50 +18420,50 @@
1835218420 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
1835318421 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
1835418422 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
18355- label = 1553LLU; // continue to unroll stack
18423+ label = 1561LLU; // continue to unroll stack
1835618424 break;
1835718425 }
18358- case 1557LLU: // try next case
18426+ case 1565LLU: // try next case
1835918427 {
1836018428 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1836118429 exit(-1);
1836218430 }
18363- case 1556LLU: // completed switch
18431+ case 1564LLU: // completed switch
1836418432 {
18365- label = 1555LLU; // alternative complete
18433+ label = 1563LLU; // alternative complete
1836618434 break;
1836718435 }
18368- case 1555LLU: // completed if-then-else
18436+ case 1563LLU: // completed if-then-else
1836918437 {
1837018438 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18371- label = 1551LLU; // repeat
18439+ label = 1559LLU; // repeat
1837218440 break;
1837318441 }
18374- case 1553LLU: // copy-back deleter for while next
18442+ case 1561LLU: // copy-back deleter for while next
1837518443 {
1837618444 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
18377- label = 1546LLU; // continue to unroll stack
18445+ label = 1554LLU; // continue to unroll stack
1837818446 break;
1837918447 }
18380- case 1552LLU: // loop finished
18448+ case 1560LLU: // loop finished
1838118449 {
1838218450 if(!stack[base + 4]/*found*/)
1838318451 {
18384- label = 1571LLU; // jump to alternative
18452+ label = 1579LLU; // jump to alternative
1838518453 break;
1838618454 }
1838718455
1838818456 // consequent
18389- label = 1572LLU; // consequent complete
18457+ label = 1580LLU; // consequent complete
1839018458 break;
1839118459 }
18392- case 1571LLU: // alternative
18460+ case 1579LLU: // alternative
1839318461 {
1839418462 fprintf(stderr, "%s", "in function ");
1839518463 // call reportid from FindFn
18396- stack[base + 9LLU] = 1573LLU/*throw to this address*/;
18464+ stack[base + 9LLU] = 1581LLU/*throw to this address*/;
1839718465 stack[base + 10LLU] = base;
18398- stack[base + 11LLU] = 1574LLU;
18466+ stack[base + 11LLU] = 1582LLU;
1839918467 // arguments for call to reportid
1840018468 stack[base + 12LLU] = stack[base + 1]/*fnid*/;
1840118469 // set stack-base & callee-address
@@ -18403,21 +18471,21 @@
1840318471 label = 18446744073709551586LLU; // reportid
1840418472 break;
1840518473 }
18406- case 1573LLU: // copy-back deleter (reportid to FindFn)
18474+ case 1581LLU: // copy-back deleter (reportid to FindFn)
1840718475 {
1840818476 // copy mutable arguments back from call to reportid
18409- label = 1546LLU; // continue to roll stack
18477+ label = 1554LLU; // continue to roll stack
1841018478 break;
1841118479 }
18412- case 1574LLU: // return from reportid to FindFn
18480+ case 1582LLU: // return from reportid to FindFn
1841318481 {
1841418482 // copy mutable arguments back from call to reportid
1841518483 fprintf(stderr, "%s", ": ");
1841618484 fprintf(stderr, "%s", "function ");
1841718485 // call reportid from FindFn
18418- stack[base + 9LLU] = 1575LLU/*throw to this address*/;
18486+ stack[base + 9LLU] = 1583LLU/*throw to this address*/;
1841918487 stack[base + 10LLU] = base;
18420- stack[base + 11LLU] = 1576LLU;
18488+ stack[base + 11LLU] = 1584LLU;
1842118489 // arguments for call to reportid
1842218490 stack[base + 12LLU] = stack[base + 3]/*id*/;
1842318491 // set stack-base & callee-address
@@ -18425,35 +18493,35 @@
1842518493 label = 18446744073709551586LLU; // reportid
1842618494 break;
1842718495 }
18428- case 1575LLU: // copy-back deleter (reportid to FindFn)
18496+ case 1583LLU: // copy-back deleter (reportid to FindFn)
1842918497 {
1843018498 // copy mutable arguments back from call to reportid
18431- label = 1546LLU; // continue to roll stack
18499+ label = 1554LLU; // continue to roll stack
1843218500 break;
1843318501 }
18434- case 1576LLU: // return from reportid to FindFn
18502+ case 1584LLU: // return from reportid to FindFn
1843518503 {
1843618504 // copy mutable arguments back from call to reportid
1843718505 fprintf(stderr, "%s", " not defined\n");
1843818506 {
18439- label = 1546LLU; // throw: begin to unroll stack
18507+ label = 1554LLU; // throw: begin to unroll stack
1844018508 break;
1844118509 }
1844218510
18443- label = 1572LLU; // alternative complete
18511+ label = 1580LLU; // alternative complete
1844418512 break;
1844518513 }
18446- case 1572LLU: // completed if-then-else
18514+ case 1580LLU: // completed if-then-else
1844718515 {
18448- label = 1578LLU; // skip deleter
18516+ label = 1586LLU; // skip deleter
1844918517 break;
1845018518 }
18451- case 1577LLU: // deleter
18519+ case 1585LLU: // deleter
1845218520 {
1845318521 // throw from FindFn
1845418522 if(!stack[base + 0])
1845518523 {
18456- label = 1546LLU; // skip, variable already deleted/unscoped
18524+ label = 1554LLU; // skip, variable already deleted/unscoped
1845718525 break;
1845818526 }
1845918527
@@ -18462,7 +18530,7 @@
1846218530 newstack[0] = (uint64_t)stack; // backup stack location
1846318531 newstack[1] = 1234567890;
1846418532 newstack[2] = base;
18465- newstack[3] = 1579LLU;
18533+ newstack[3] = 1587LLU;
1846618534 stack = newstack;
1846718535 // set stack-base & callee-address
1846818536 base = 4/*deloffset*/;
@@ -18469,16 +18537,16 @@
1846918537 label = 1420LLU; // ~fndef
1847018538 break;
1847118539 }
18472- case 1579LLU: // return from ~fndef to FindFn
18540+ case 1587LLU: // return from ~fndef to FindFn
1847318541 {
1847418542 stack = (uint64_t *)stack[0];
1847518543 // releasing toplevel container
1847618544 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1847718545
18478- label = 1546LLU; // continue unrolling stack, delete next variable
18546+ label = 1554LLU; // continue unrolling stack, delete next variable
1847918547 break;
1848018548 }
18481- case 1578LLU: // skipped deleter
18549+ case 1586LLU: // skipped deleter
1848218550 {
1848318551 INIT(&stack[base + 0], &stack[base + 5]/*copy*/);
1848418552 // return from FindFn
@@ -18486,37 +18554,37 @@
1848618554 base = stack[base - 2];
1848718555 break;
1848818556 }
18489- case 1581LLU: // function existsfn failed
18557+ case 1589LLU: // function existsfn failed
1849018558 {
1849118559 label = stack[base - 3];
1849218560 base = stack[base - 2];
1849318561 break;
1849418562 }
18495- case 1580LLU: // existsfn
18563+ case 1588LLU: // existsfn
1849618564 {
1849718565 //#define res0 0
1849818566 //#define arg0 1
1849918567 //#define arg1 2
18500- label = 1583LLU; // skip deleter
18568+ label = 1591LLU; // skip deleter
1850118569 break;
1850218570 }
18503- case 1582LLU: // deleter
18571+ case 1590LLU: // deleter
1850418572 {
1850518573 // throw from existsfn
1850618574 if(!stack[base + 3])
1850718575 {
18508- label = 1581LLU; // skip, variable already deleted/unscoped
18576+ label = 1589LLU; // skip, variable already deleted/unscoped
1850918577 break;
1851018578 }
18511- label = 1581LLU; // continue unrolling stack, delete next variable
18579+ label = 1589LLU; // continue unrolling stack, delete next variable
1851218580 break;
1851318581 }
18514- case 1583LLU: // skipped deleter
18582+ case 1591LLU: // skipped deleter
1851518583 {
1851618584 // call reservedfn from existsfn
18517- stack[base + 4LLU] = 1584LLU/*throw to this address*/;
18585+ stack[base + 4LLU] = 1592LLU/*throw to this address*/;
1851818586 stack[base + 5LLU] = base;
18519- stack[base + 6LLU] = 1585LLU;
18587+ stack[base + 6LLU] = 1593LLU;
1852018588 // arguments for call to reservedfn
1852118589 stack[base + 8LLU] = stack[base + 2]/*id*/;
1852218590 // set stack-base & callee-address
@@ -18524,26 +18592,26 @@
1852418592 label = 1501LLU; // reservedfn
1852518593 break;
1852618594 }
18527- case 1584LLU: // copy-back deleter (reservedfn to existsfn)
18595+ case 1592LLU: // copy-back deleter (reservedfn to existsfn)
1852818596 {
1852918597 // copy mutable arguments back from call to reservedfn
18530- label = 1581LLU; // continue to roll stack
18598+ label = 1589LLU; // continue to roll stack
1853118599 break;
1853218600 }
18533- case 1585LLU: // return from reservedfn to existsfn
18601+ case 1593LLU: // return from reservedfn to existsfn
1853418602 {
1853518603 // copy mutable arguments back from call to reservedfn
1853618604 // copy back results provided by call to reservedfn
1853718605 stack[base + 3] = stack[base + 7LLU];
1853818606 flippedassign(stack[base + 1]/*fndefs*/, &stack[base + 4]);
18539- label = 1586LLU; // start to repeat
18607+ label = 1594LLU; // start to repeat
1854018608 break;
1854118609 }
18542- case 1586LLU: // repeat from here
18610+ case 1594LLU: // repeat from here
1854318611 {
1854418612 if(!stack[base + 4])
1854518613 {
18546- label = 1587LLU; // break loop
18614+ label = 1595LLU; // break loop
1854718615 break;
1854818616 }
1854918617
@@ -18553,19 +18621,19 @@
1855318621 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1855418622 if(!stack[base + 3]/*found*/)
1855518623 {
18556- label = 1589LLU; // jump to alternative
18624+ label = 1597LLU; // jump to alternative
1855718625 break;
1855818626 }
1855918627
1856018628 // consequent
18561- label = 1590LLU; // consequent complete
18629+ label = 1598LLU; // consequent complete
1856218630 break;
1856318631 }
18564- case 1589LLU: // alternative
18632+ case 1597LLU: // alternative
1856518633 {
1856618634 if(/*fndef*/0 != ((uint64_t *)(stack[base + 5]/*fndef*/))[0])
1856718635 {
18568- label = 1592LLU; // jump to alternative
18636+ label = 1600LLU; // jump to alternative
1856918637 break;
1857018638 }
1857118639
@@ -18579,27 +18647,27 @@
1857918647 /*IO*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*fndef*/))[1][7]/*IO*/;
1858018648
1858118649 // case
18582- label = 1595LLU; // skip deleter
18650+ label = 1603LLU; // skip deleter
1858318651 break;
1858418652 }
18585- case 1594LLU: // deleter
18653+ case 1602LLU: // deleter
1858618654 {
1858718655 // throw from existsfn
1858818656 if(!stack[base + 15])
1858918657 {
18590- label = 1593LLU; // skip, variable already deleted/unscoped
18658+ label = 1601LLU; // skip, variable already deleted/unscoped
1859118659 break;
1859218660 }
18593- label = 1593LLU; // continue unrolling stack, delete next variable
18661+ label = 1601LLU; // continue unrolling stack, delete next variable
1859418662 break;
1859518663 }
18596- case 1595LLU: // skipped deleter
18664+ case 1603LLU: // skipped deleter
1859718665 {
1859818666 stack[base + 15] = 0;
1859918667 // call equ from existsfn
18600- stack[base + 16LLU] = 1596LLU/*throw to this address*/;
18668+ stack[base + 16LLU] = 1604LLU/*throw to this address*/;
1860118669 stack[base + 17LLU] = base;
18602- stack[base + 18LLU] = 1597LLU;
18670+ stack[base + 18LLU] = 1605LLU;
1860318671 // arguments for call to equ
1860418672 stack[base + 20LLU] = stack[base + 2]/*id*/;
1860518673 stack[base + 21LLU] = stack[base + 11]/*defid*/;
@@ -18608,13 +18676,13 @@
1860818676 label = 18446744073709551600LLU; // equ
1860918677 break;
1861018678 }
18611- case 1596LLU: // copy-back deleter (equ to existsfn)
18679+ case 1604LLU: // copy-back deleter (equ to existsfn)
1861218680 {
1861318681 // copy mutable arguments back from call to equ
18614- label = 1594LLU; // continue to roll stack
18682+ label = 1602LLU; // continue to roll stack
1861518683 break;
1861618684 }
18617- case 1597LLU: // return from equ to existsfn
18685+ case 1605LLU: // return from equ to existsfn
1861818686 {
1861918687 // copy mutable arguments back from call to equ
1862018688 // copy back results provided by call to equ
@@ -18621,21 +18689,21 @@
1862118689 stack[base + 15] = stack[base + 19LLU];
1862218690 if(!stack[base + 15]/*isequal*/)
1862318691 {
18624- label = 1598LLU; // jump to alternative
18692+ label = 1606LLU; // jump to alternative
1862518693 break;
1862618694 }
1862718695
1862818696 // consequent
1862918697 stack[base + 3]/*found*/ = 1;
18630- label = 1599LLU; // consequent complete
18698+ label = 1607LLU; // consequent complete
1863118699 break;
1863218700 }
18633- case 1598LLU: // alternative
18701+ case 1606LLU: // alternative
1863418702 {
18635- label = 1599LLU; // alternative complete
18703+ label = 1607LLU; // alternative complete
1863618704 break;
1863718705 }
18638- case 1599LLU: // completed if-then-else
18706+ case 1607LLU: // completed if-then-else
1863918707 {
1864018708 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1864118709 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18645,10 +18713,10 @@
1864518713 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1864618714 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1864718715 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18648- label = 1591LLU; // case complete
18716+ label = 1599LLU; // case complete
1864918717 break;
1865018718 }
18651- case 1593LLU: // copy-back deleter (switch)
18719+ case 1601LLU: // copy-back deleter (switch)
1865218720 {
1865318721 ((uint64_t **)(stack[base + 5]))[1][7] = stack[base + 14];
1865418722 ((uint64_t **)(stack[base + 5]))[1][6] = stack[base + 13];
@@ -18658,48 +18726,48 @@
1865818726 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
1865918727 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1866018728 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18661- label = 1588LLU; // continue to unroll stack
18729+ label = 1596LLU; // continue to unroll stack
1866218730 break;
1866318731 }
18664- case 1592LLU: // try next case
18732+ case 1600LLU: // try next case
1866518733 {
1866618734 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1866718735 exit(-1);
1866818736 }
18669- case 1591LLU: // completed switch
18737+ case 1599LLU: // completed switch
1867018738 {
18671- label = 1590LLU; // alternative complete
18739+ label = 1598LLU; // alternative complete
1867218740 break;
1867318741 }
18674- case 1590LLU: // completed if-then-else
18742+ case 1598LLU: // completed if-then-else
1867518743 {
1867618744 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18677- label = 1586LLU; // repeat
18745+ label = 1594LLU; // repeat
1867818746 break;
1867918747 }
18680- case 1588LLU: // copy-back deleter for while next
18748+ case 1596LLU: // copy-back deleter for while next
1868118749 {
1868218750 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18683- label = 1582LLU; // continue to unroll stack
18751+ label = 1590LLU; // continue to unroll stack
1868418752 break;
1868518753 }
18686- case 1587LLU: // loop finished
18754+ case 1595LLU: // loop finished
1868718755 {
18688- label = 1601LLU; // skip deleter
18756+ label = 1609LLU; // skip deleter
1868918757 break;
1869018758 }
18691- case 1600LLU: // deleter
18759+ case 1608LLU: // deleter
1869218760 {
1869318761 // throw from existsfn
1869418762 if(!stack[base + 0])
1869518763 {
18696- label = 1582LLU; // skip, variable already deleted/unscoped
18764+ label = 1590LLU; // skip, variable already deleted/unscoped
1869718765 break;
1869818766 }
18699- label = 1582LLU; // continue unrolling stack, delete next variable
18767+ label = 1590LLU; // continue unrolling stack, delete next variable
1870018768 break;
1870118769 }
18702- case 1601LLU: // skipped deleter
18770+ case 1609LLU: // skipped deleter
1870318771 {
1870418772 stack[base + 0] = stack[base + 3]/*found*/;
1870518773 // return from existsfn
@@ -18707,7 +18775,7 @@
1870718775 base = stack[base - 2];
1870818776 break;
1870918777 }
18710- case 1602LLU: // ~idfndef
18778+ case 1610LLU: // ~idfndef
1871118779 {
1871218780 if(stack[base + 0]/*variant-nr*/ >= 1)
1871318781 {
@@ -18714,10 +18782,10 @@
1871418782 fprintf(stderr, "in ~idfndef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1871518783 exit(-1);
1871618784 }
18717- label = 1602LLU + 1LLU + stack[base + 0]/*variant-nr*/;
18785+ label = 1610LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1871818786 break;
1871918787 }
18720- case 1602LLU + 1LLU + 0LLU: // ~idfndef.idfndef
18788+ case 1610LLU + 1LLU + 0LLU: // ~idfndef.idfndef
1872118789 {
1872218790 // release element id
1872318791 // release element fndef
@@ -18728,7 +18796,7 @@
1872818796 newstack[0] = (uint64_t)stack; // backup stack location
1872918797 newstack[1] = 1234567890;
1873018798 newstack[2] = base;
18731- newstack[3] = 1604LLU;
18799+ newstack[3] = 1612LLU;
1873218800 stack = newstack;
1873318801 // set stack-base & callee-address
1873418802 base = 4/*deloffset*/;
@@ -18735,7 +18803,7 @@
1873518803 label = 1420LLU; // ~fndef
1873618804 break;
1873718805 }
18738- case 1604LLU: // return from ~fndef to idfndef
18806+ case 1612LLU: // return from ~fndef to idfndef
1873918807 {
1874018808 stack = (uint64_t *)stack[0];
1874118809 // releasing toplevel container
@@ -18747,43 +18815,43 @@
1874718815 base = stack[base - 2];
1874818816 break;
1874918817 }
18750- case 1606LLU: // function existsidfn failed
18818+ case 1614LLU: // function existsidfn failed
1875118819 {
1875218820 label = stack[base - 3];
1875318821 base = stack[base - 2];
1875418822 break;
1875518823 }
18756- case 1605LLU: // existsidfn
18824+ case 1613LLU: // existsidfn
1875718825 {
1875818826 //#define res0 0
1875918827 //#define arg0 1
1876018828 //#define arg1 2
18761- label = 1608LLU; // skip deleter
18829+ label = 1616LLU; // skip deleter
1876218830 break;
1876318831 }
18764- case 1607LLU: // deleter
18832+ case 1615LLU: // deleter
1876518833 {
1876618834 // throw from existsidfn
1876718835 if(!stack[base + 3])
1876818836 {
18769- label = 1606LLU; // skip, variable already deleted/unscoped
18837+ label = 1614LLU; // skip, variable already deleted/unscoped
1877018838 break;
1877118839 }
18772- label = 1606LLU; // continue unrolling stack, delete next variable
18840+ label = 1614LLU; // continue unrolling stack, delete next variable
1877318841 break;
1877418842 }
18775- case 1608LLU: // skipped deleter
18843+ case 1616LLU: // skipped deleter
1877618844 {
1877718845 stack[base + 3] = 0;
1877818846 flippedassign(stack[base + 1]/*idfndefs*/, &stack[base + 4]);
18779- label = 1609LLU; // start to repeat
18847+ label = 1617LLU; // start to repeat
1878018848 break;
1878118849 }
18782- case 1609LLU: // repeat from here
18850+ case 1617LLU: // repeat from here
1878318851 {
1878418852 if(!stack[base + 4])
1878518853 {
18786- label = 1610LLU; // break loop
18854+ label = 1618LLU; // break loop
1878718855 break;
1878818856 }
1878918857
@@ -18793,19 +18861,19 @@
1879318861 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
1879418862 if(!stack[base + 3]/*found*/)
1879518863 {
18796- label = 1612LLU; // jump to alternative
18864+ label = 1620LLU; // jump to alternative
1879718865 break;
1879818866 }
1879918867
1880018868 // consequent
18801- label = 1613LLU; // consequent complete
18869+ label = 1621LLU; // consequent complete
1880218870 break;
1880318871 }
18804- case 1612LLU: // alternative
18872+ case 1620LLU: // alternative
1880518873 {
1880618874 if(/*idfndef*/0 != ((uint64_t *)(stack[base + 5]/*idfndef*/))[0])
1880718875 {
18808- label = 1615LLU; // jump to alternative
18876+ label = 1623LLU; // jump to alternative
1880918877 break;
1881018878 }
1881118879
@@ -18813,27 +18881,27 @@
1881318881 /*fndef*/stack[base + 8] = ((uint64_t **)(stack[base + 5]/*idfndef*/))[1][1]/*fndef*/;
1881418882
1881518883 // case
18816- label = 1618LLU; // skip deleter
18884+ label = 1626LLU; // skip deleter
1881718885 break;
1881818886 }
18819- case 1617LLU: // deleter
18887+ case 1625LLU: // deleter
1882018888 {
1882118889 // throw from existsidfn
1882218890 if(!stack[base + 9])
1882318891 {
18824- label = 1616LLU; // skip, variable already deleted/unscoped
18892+ label = 1624LLU; // skip, variable already deleted/unscoped
1882518893 break;
1882618894 }
18827- label = 1616LLU; // continue unrolling stack, delete next variable
18895+ label = 1624LLU; // continue unrolling stack, delete next variable
1882818896 break;
1882918897 }
18830- case 1618LLU: // skipped deleter
18898+ case 1626LLU: // skipped deleter
1883118899 {
1883218900 stack[base + 9] = 0;
1883318901 // call equ from existsidfn
18834- stack[base + 10LLU] = 1619LLU/*throw to this address*/;
18902+ stack[base + 10LLU] = 1627LLU/*throw to this address*/;
1883518903 stack[base + 11LLU] = base;
18836- stack[base + 12LLU] = 1620LLU;
18904+ stack[base + 12LLU] = 1628LLU;
1883718905 // arguments for call to equ
1883818906 stack[base + 14LLU] = stack[base + 7]/*id*/;
1883918907 stack[base + 15LLU] = stack[base + 2]/*searchid*/;
@@ -18842,13 +18910,13 @@
1884218910 label = 18446744073709551600LLU; // equ
1884318911 break;
1884418912 }
18845- case 1619LLU: // copy-back deleter (equ to existsidfn)
18913+ case 1627LLU: // copy-back deleter (equ to existsidfn)
1884618914 {
1884718915 // copy mutable arguments back from call to equ
18848- label = 1617LLU; // continue to roll stack
18916+ label = 1625LLU; // continue to roll stack
1884918917 break;
1885018918 }
18851- case 1620LLU: // return from equ to existsidfn
18919+ case 1628LLU: // return from equ to existsidfn
1885218920 {
1885318921 // copy mutable arguments back from call to equ
1885418922 // copy back results provided by call to equ
@@ -18855,73 +18923,73 @@
1885518923 stack[base + 9] = stack[base + 13LLU];
1885618924 if(!stack[base + 9]/*isequal*/)
1885718925 {
18858- label = 1621LLU; // jump to alternative
18926+ label = 1629LLU; // jump to alternative
1885918927 break;
1886018928 }
1886118929
1886218930 // consequent
1886318931 stack[base + 3]/*found*/ = 1;
18864- label = 1622LLU; // consequent complete
18932+ label = 1630LLU; // consequent complete
1886518933 break;
1886618934 }
18867- case 1621LLU: // alternative
18935+ case 1629LLU: // alternative
1886818936 {
18869- label = 1622LLU; // alternative complete
18937+ label = 1630LLU; // alternative complete
1887018938 break;
1887118939 }
18872- case 1622LLU: // completed if-then-else
18940+ case 1630LLU: // completed if-then-else
1887318941 {
1887418942 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1887518943 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18876- label = 1614LLU; // case complete
18944+ label = 1622LLU; // case complete
1887718945 break;
1887818946 }
18879- case 1616LLU: // copy-back deleter (switch)
18947+ case 1624LLU: // copy-back deleter (switch)
1888018948 {
1888118949 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
1888218950 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
18883- label = 1611LLU; // continue to unroll stack
18951+ label = 1619LLU; // continue to unroll stack
1888418952 break;
1888518953 }
18886- case 1615LLU: // try next case
18954+ case 1623LLU: // try next case
1888718955 {
1888818956 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1888918957 exit(-1);
1889018958 }
18891- case 1614LLU: // completed switch
18959+ case 1622LLU: // completed switch
1889218960 {
18893- label = 1613LLU; // alternative complete
18961+ label = 1621LLU; // alternative complete
1889418962 break;
1889518963 }
18896- case 1613LLU: // completed if-then-else
18964+ case 1621LLU: // completed if-then-else
1889718965 {
1889818966 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18899- label = 1609LLU; // repeat
18967+ label = 1617LLU; // repeat
1890018968 break;
1890118969 }
18902- case 1611LLU: // copy-back deleter for while next
18970+ case 1619LLU: // copy-back deleter for while next
1890318971 {
1890418972 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
18905- label = 1607LLU; // continue to unroll stack
18973+ label = 1615LLU; // continue to unroll stack
1890618974 break;
1890718975 }
18908- case 1610LLU: // loop finished
18976+ case 1618LLU: // loop finished
1890918977 {
18910- label = 1624LLU; // skip deleter
18978+ label = 1632LLU; // skip deleter
1891118979 break;
1891218980 }
18913- case 1623LLU: // deleter
18981+ case 1631LLU: // deleter
1891418982 {
1891518983 // throw from existsidfn
1891618984 if(!stack[base + 0])
1891718985 {
18918- label = 1607LLU; // skip, variable already deleted/unscoped
18986+ label = 1615LLU; // skip, variable already deleted/unscoped
1891918987 break;
1892018988 }
18921- label = 1607LLU; // continue unrolling stack, delete next variable
18989+ label = 1615LLU; // continue unrolling stack, delete next variable
1892218990 break;
1892318991 }
18924- case 1624LLU: // skipped deleter
18992+ case 1632LLU: // skipped deleter
1892518993 {
1892618994 stack[base + 0] = stack[base + 3]/*found*/;
1892718995 // return from existsidfn
@@ -18929,21 +18997,21 @@
1892918997 base = stack[base - 2];
1893018998 break;
1893118999 }
18932- case 1626LLU: // function emitcase failed
19000+ case 1634LLU: // function emitcase failed
1893319001 {
1893419002 label = stack[base - 3];
1893519003 base = stack[base - 2];
1893619004 break;
1893719005 }
18938- case 1625LLU: // emitcase
19006+ case 1633LLU: // emitcase
1893919007 {
1894019008 //#define arg0 0
1894119009 //#define arg1 1
1894219010 printf("%s", "\n case -");
1894319011 // call printnr from emitcase
18944- stack[base + 2LLU] = 1627LLU/*throw to this address*/;
19012+ stack[base + 2LLU] = 1635LLU/*throw to this address*/;
1894519013 stack[base + 3LLU] = base;
18946- stack[base + 4LLU] = 1628LLU;
19014+ stack[base + 4LLU] = 1636LLU;
1894719015 // arguments for call to printnr
1894819016 stack[base + 5LLU] = stack[base + 0]/*label*/;
1894919017 // set stack-base & callee-address
@@ -18951,20 +19019,20 @@
1895119019 label = 18446744073709551590LLU; // printnr
1895219020 break;
1895319021 }
18954- case 1627LLU: // copy-back deleter (printnr to emitcase)
19022+ case 1635LLU: // copy-back deleter (printnr to emitcase)
1895519023 {
1895619024 // copy mutable arguments back from call to printnr
18957- label = 1626LLU; // continue to roll stack
19025+ label = 1634LLU; // continue to roll stack
1895819026 break;
1895919027 }
18960- case 1628LLU: // return from printnr to emitcase
19028+ case 1636LLU: // return from printnr to emitcase
1896119029 {
1896219030 // copy mutable arguments back from call to printnr
1896319031 printf("%s", ": // ");
1896419032 // call printid from emitcase
18965- stack[base + 2LLU] = 1629LLU/*throw to this address*/;
19033+ stack[base + 2LLU] = 1637LLU/*throw to this address*/;
1896619034 stack[base + 3LLU] = base;
18967- stack[base + 4LLU] = 1630LLU;
19035+ stack[base + 4LLU] = 1638LLU;
1896819036 // arguments for call to printid
1896919037 stack[base + 5LLU] = stack[base + 1]/*defid*/;
1897019038 // set stack-base & callee-address
@@ -18972,13 +19040,13 @@
1897219040 label = 18446744073709551587LLU; // printid
1897319041 break;
1897419042 }
18975- case 1629LLU: // copy-back deleter (printid to emitcase)
19043+ case 1637LLU: // copy-back deleter (printid to emitcase)
1897619044 {
1897719045 // copy mutable arguments back from call to printid
18978- label = 1626LLU; // continue to roll stack
19046+ label = 1634LLU; // continue to roll stack
1897919047 break;
1898019048 }
18981- case 1630LLU: // return from printid to emitcase
19049+ case 1638LLU: // return from printid to emitcase
1898219050 {
1898319051 // copy mutable arguments back from call to printid
1898419052 printf("%s", "\n {");
@@ -18987,13 +19055,13 @@
1898719055 base = stack[base - 2];
1898819056 break;
1898919057 }
18990- case 1632LLU: // function emitreturn failed
19058+ case 1640LLU: // function emitreturn failed
1899119059 {
1899219060 label = stack[base - 3];
1899319061 base = stack[base - 2];
1899419062 break;
1899519063 }
18996- case 1631LLU: // emitreturn
19064+ case 1639LLU: // emitreturn
1899719065 {
1899819066 printf("%s", "\n");
1899919067 printf("%s", "\n label = stack[base - 1];");
@@ -19005,13 +19073,13 @@
1900519073 base = stack[base - 2];
1900619074 break;
1900719075 }
19008- case 1634LLU: // function EMITTHROW failed
19076+ case 1642LLU: // function EMITTHROW failed
1900919077 {
1901019078 label = stack[base - 3];
1901119079 base = stack[base - 2];
1901219080 break;
1901319081 }
19014- case 1633LLU: // EMITTHROW
19082+ case 1641LLU: // EMITTHROW
1901519083 {
1901619084 printf("%s", "\n label = stack[base - 3];");
1901719085 printf("%s", "\n base = stack[base - 2];");
@@ -19022,38 +19090,38 @@
1902219090 base = stack[base - 2];
1902319091 break;
1902419092 }
19025- case 1636LLU: // function isparam failed
19093+ case 1644LLU: // function isparam failed
1902619094 {
1902719095 label = stack[base - 3];
1902819096 base = stack[base - 2];
1902919097 break;
1903019098 }
19031- case 1635LLU: // isparam
19099+ case 1643LLU: // isparam
1903219100 {
1903319101 //#define res0 0
1903419102 //#define arg0 1
1903519103 //#define arg1 2
1903619104 //#define arg2 3
19037- label = 1638LLU; // skip deleter
19105+ label = 1646LLU; // skip deleter
1903819106 break;
1903919107 }
19040- case 1637LLU: // deleter
19108+ case 1645LLU: // deleter
1904119109 {
1904219110 // throw from isparam
1904319111 if(!stack[base + 4])
1904419112 {
19045- label = 1636LLU; // skip, variable already deleted/unscoped
19113+ label = 1644LLU; // skip, variable already deleted/unscoped
1904619114 break;
1904719115 }
19048- label = 1636LLU; // continue unrolling stack, delete next variable
19116+ label = 1644LLU; // continue unrolling stack, delete next variable
1904919117 break;
1905019118 }
19051- case 1638LLU: // skipped deleter
19119+ case 1646LLU: // skipped deleter
1905219120 {
1905319121 // call add from isparam
19054- stack[base + 5LLU] = 1639LLU/*throw to this address*/;
19122+ stack[base + 5LLU] = 1647LLU/*throw to this address*/;
1905519123 stack[base + 6LLU] = base;
19056- stack[base + 7LLU] = 1640LLU;
19124+ stack[base + 7LLU] = 1648LLU;
1905719125 // arguments for call to add
1905819126 stack[base + 9LLU] = stack[base + 1]/*rescount*/;
1905919127 stack[base + 10LLU] = stack[base + 2]/*argcount*/;
@@ -19062,21 +19130,21 @@
1906219130 label = 18446744073709551605LLU; // add
1906319131 break;
1906419132 }
19065- case 1639LLU: // copy-back deleter (add to isparam)
19133+ case 1647LLU: // copy-back deleter (add to isparam)
1906619134 {
1906719135 // copy mutable arguments back from call to add
19068- label = 1636LLU; // continue to roll stack
19136+ label = 1644LLU; // continue to roll stack
1906919137 break;
1907019138 }
19071- case 1640LLU: // return from add to isparam
19139+ case 1648LLU: // return from add to isparam
1907219140 {
1907319141 // copy mutable arguments back from call to add
1907419142 // copy back results provided by call to add
1907519143 stack[base + 4] = stack[base + 8LLU];
1907619144 // call lss from isparam
19077- stack[base + 5LLU] = 1641LLU/*throw to this address*/;
19145+ stack[base + 5LLU] = 1649LLU/*throw to this address*/;
1907819146 stack[base + 6LLU] = base;
19079- stack[base + 7LLU] = 1642LLU;
19147+ stack[base + 7LLU] = 1650LLU;
1908019148 // arguments for call to lss
1908119149 stack[base + 9LLU] = stack[base + 3]/*index*/;
1908219150 stack[base + 10LLU] = stack[base + 4]/*varbase*/;
@@ -19085,13 +19153,13 @@
1908519153 label = 18446744073709551597LLU; // lss
1908619154 break;
1908719155 }
19088- case 1641LLU: // copy-back deleter (lss to isparam)
19156+ case 1649LLU: // copy-back deleter (lss to isparam)
1908919157 {
1909019158 // copy mutable arguments back from call to lss
19091- label = 1637LLU; // continue to roll stack
19159+ label = 1645LLU; // continue to roll stack
1909219160 break;
1909319161 }
19094- case 1642LLU: // return from lss to isparam
19162+ case 1650LLU: // return from lss to isparam
1909519163 {
1909619164 // copy mutable arguments back from call to lss
1909719165 // copy back results provided by call to lss
@@ -19101,13 +19169,13 @@
1910119169 base = stack[base - 2];
1910219170 break;
1910319171 }
19104- case 1644LLU: // function REGISTER failed
19172+ case 1652LLU: // function REGISTER failed
1910519173 {
1910619174 label = stack[base - 3];
1910719175 base = stack[base - 2];
1910819176 break;
1910919177 }
19110- case 1643LLU: // REGISTER
19178+ case 1651LLU: // REGISTER
1911119179 {
1911219180 //#define arg0 0
1911319181 //#define arg1 1
@@ -19117,26 +19185,26 @@
1911719185 //#define arg5 5
1911819186 //#define arg6 6
1911919187 //#define arg7 7
19120- label = 1646LLU; // skip deleter
19188+ label = 1654LLU; // skip deleter
1912119189 break;
1912219190 }
19123- case 1645LLU: // deleter
19191+ case 1653LLU: // deleter
1912419192 {
1912519193 // throw from REGISTER
1912619194 if(!stack[base + 8])
1912719195 {
19128- label = 1644LLU; // skip, variable already deleted/unscoped
19196+ label = 1652LLU; // skip, variable already deleted/unscoped
1912919197 break;
1913019198 }
1913119199 // delete list
19132- label = 1647LLU; // start to repeat
19200+ label = 1655LLU; // start to repeat
1913319201 break;
1913419202 }
19135- case 1647LLU: // repeat from here
19203+ case 1655LLU: // repeat from here
1913619204 {
1913719205 if(!stack[base + 8])
1913819206 {
19139- label = 1648LLU; // break loop
19207+ label = 1656LLU; // break loop
1914019208 break;
1914119209 }
1914219210
@@ -19147,7 +19215,7 @@
1914719215 newstack[0] = (uint64_t)stack; // backup stack location
1914819216 newstack[1] = 1234567890;
1914919217 newstack[2] = base;
19150- newstack[3] = 1649LLU;
19218+ newstack[3] = 1657LLU;
1915119219 stack = newstack;
1915219220 // set stack-base & callee-address
1915319221 base = 4/*deloffset*/;
@@ -19154,7 +19222,7 @@
1915419222 label = 417LLU; // ~result
1915519223 break;
1915619224 }
19157- case 1649LLU: // return from ~result to REGISTER
19225+ case 1657LLU: // return from ~result to REGISTER
1915819226 {
1915919227 stack = (uint64_t *)stack[0];
1916019228 // releasing toplevel container
@@ -19165,40 +19233,40 @@
1916519233 stack[base + 8] = (uint64_t)list->next;
1916619234 Free(1, sizeof(struct listnode), list);
1916719235 }
19168- label = 1647LLU; // repeat
19236+ label = 1655LLU; // repeat
1916919237 break;
1917019238 }
19171- case 1648LLU: // loop finished
19239+ case 1656LLU: // loop finished
1917219240 {
19173- label = 1644LLU; // continue unrolling stack, delete next variable
19241+ label = 1652LLU; // continue unrolling stack, delete next variable
1917419242 break;
1917519243 }
19176- case 1646LLU: // skipped deleter
19244+ case 1654LLU: // skipped deleter
1917719245 {
1917819246 stack[base + 8] = 0;
1917919247 stack[base + 9] = stack[base + 0]/*rescount*/;
1918019248
19181- label = 1650LLU; // start to repeat
19249+ label = 1658LLU; // start to repeat
1918219250 break;
1918319251 }
19184- case 1650LLU: // repeat from here
19252+ case 1658LLU: // repeat from here
1918519253 {
1918619254 if(!stack[base + 9]--)
1918719255 {
19188- label = 1651LLU; // break loop
19256+ label = 1659LLU; // break loop
1918919257 break;
1919019258 }
1919119259
1919219260 // loop body
19193- label = 1653LLU; // skip deleter
19261+ label = 1661LLU; // skip deleter
1919419262 break;
1919519263 }
19196- case 1652LLU: // deleter
19264+ case 1660LLU: // deleter
1919719265 {
1919819266 // throw from REGISTER
1919919267 if(!stack[base + 10])
1920019268 {
19201- label = 1645LLU; // skip, variable already deleted/unscoped
19269+ label = 1653LLU; // skip, variable already deleted/unscoped
1920219270 break;
1920319271 }
1920419272
@@ -19207,7 +19275,7 @@
1920719275 newstack[0] = (uint64_t)stack; // backup stack location
1920819276 newstack[1] = 1234567890;
1920919277 newstack[2] = base;
19210- newstack[3] = 1654LLU;
19278+ newstack[3] = 1662LLU;
1921119279 stack = newstack;
1921219280 // set stack-base & callee-address
1921319281 base = 4/*deloffset*/;
@@ -19214,21 +19282,21 @@
1921419282 label = 310LLU; // ~type
1921519283 break;
1921619284 }
19217- case 1654LLU: // return from ~type to REGISTER
19285+ case 1662LLU: // return from ~type to REGISTER
1921819286 {
1921919287 stack = (uint64_t *)stack[0];
1922019288 // releasing toplevel container
1922119289 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 10] - sizeof(uint64_t) * 4));
1922219290
19223- label = 1645LLU; // continue unrolling stack, delete next variable
19291+ label = 1653LLU; // continue unrolling stack, delete next variable
1922419292 break;
1922519293 }
19226- case 1653LLU: // skipped deleter
19294+ case 1661LLU: // skipped deleter
1922719295 {
1922819296 // call mktypedata from REGISTER
19229- stack[base + 11LLU] = 1655LLU/*throw to this address*/;
19297+ stack[base + 11LLU] = 1663LLU/*throw to this address*/;
1923019298 stack[base + 12LLU] = base;
19231- stack[base + 13LLU] = 1656LLU;
19299+ stack[base + 13LLU] = 1664LLU;
1923219300 // arguments for call to mktypedata
1923319301 stack[base + 15LLU] = 881834713755418624LLU;
1923419302 // set stack-base & callee-address
@@ -19236,43 +19304,43 @@
1923619304 label = 314LLU; // mktypedata
1923719305 break;
1923819306 }
19239- case 1655LLU: // copy-back deleter (mktypedata to REGISTER)
19307+ case 1663LLU: // copy-back deleter (mktypedata to REGISTER)
1924019308 {
1924119309 // copy mutable arguments back from call to mktypedata
19242- label = 1645LLU; // continue to roll stack
19310+ label = 1653LLU; // continue to roll stack
1924319311 break;
1924419312 }
19245- case 1656LLU: // return from mktypedata to REGISTER
19313+ case 1664LLU: // return from mktypedata to REGISTER
1924619314 {
1924719315 // copy mutable arguments back from call to mktypedata
1924819316 // copy back results provided by call to mktypedata
1924919317 stack[base + 10] = stack[base + 14LLU];
19250- label = 1658LLU; // skip deleter
19318+ label = 1666LLU; // skip deleter
1925119319 break;
1925219320 }
19253- case 1657LLU: // deleter
19321+ case 1665LLU: // deleter
1925419322 {
1925519323 // throw from REGISTER
1925619324 if(!stack[base + 11])
1925719325 {
19258- label = 1652LLU; // skip, variable already deleted/unscoped
19326+ label = 1660LLU; // skip, variable already deleted/unscoped
1925919327 break;
1926019328 }
19261- label = 1652LLU; // continue unrolling stack, delete next variable
19329+ label = 1660LLU; // continue unrolling stack, delete next variable
1926219330 break;
1926319331 }
19264- case 1658LLU: // skipped deleter
19332+ case 1666LLU: // skipped deleter
1926519333 {
1926619334 stack[base + 11] = 1;
19267- label = 1660LLU; // skip deleter
19335+ label = 1668LLU; // skip deleter
1926819336 break;
1926919337 }
19270- case 1659LLU: // deleter
19338+ case 1667LLU: // deleter
1927119339 {
1927219340 // throw from REGISTER
1927319341 if(!stack[base + 12])
1927419342 {
19275- label = 1657LLU; // skip, variable already deleted/unscoped
19343+ label = 1665LLU; // skip, variable already deleted/unscoped
1927619344 break;
1927719345 }
1927819346
@@ -19281,7 +19349,7 @@
1928119349 newstack[0] = (uint64_t)stack; // backup stack location
1928219350 newstack[1] = 1234567890;
1928319351 newstack[2] = base;
19284- newstack[3] = 1661LLU;
19352+ newstack[3] = 1669LLU;
1928519353 stack = newstack;
1928619354 // set stack-base & callee-address
1928719355 base = 4/*deloffset*/;
@@ -19288,21 +19356,21 @@
1928819356 label = 417LLU; // ~result
1928919357 break;
1929019358 }
19291- case 1661LLU: // return from ~result to REGISTER
19359+ case 1669LLU: // return from ~result to REGISTER
1929219360 {
1929319361 stack = (uint64_t *)stack[0];
1929419362 // releasing toplevel container
1929519363 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1929619364
19297- label = 1657LLU; // continue unrolling stack, delete next variable
19365+ label = 1665LLU; // continue unrolling stack, delete next variable
1929819366 break;
1929919367 }
19300- case 1660LLU: // skipped deleter
19368+ case 1668LLU: // skipped deleter
1930119369 {
1930219370 // construct result.result
1930319371 if(!(stack[base + 12] = construct(2)))
1930419372 {
19305- label = 1657LLU; // throw: begin to unroll stack
19373+ label = 1665LLU; // throw: begin to unroll stack
1930619374 break;
1930719375 }
1930819376
@@ -19323,31 +19391,31 @@
1932319391 /*fnrestypes*/stack[base + 8] = (uint64_t)list;
1932419392 MOVE(&list->data, &stack[base + 12]/*result*/);
1932519393 }
19326- label = 1650LLU; // repeat
19394+ label = 1658LLU; // repeat
1932719395 break;
1932819396 }
19329- case 1651LLU: // loop finished
19397+ case 1659LLU: // loop finished
1933019398 {
19331- label = 1663LLU; // skip deleter
19399+ label = 1671LLU; // skip deleter
1933219400 break;
1933319401 }
19334- case 1662LLU: // deleter
19402+ case 1670LLU: // deleter
1933519403 {
1933619404 // throw from REGISTER
1933719405 if(!stack[base + 10])
1933819406 {
19339- label = 1645LLU; // skip, variable already deleted/unscoped
19407+ label = 1653LLU; // skip, variable already deleted/unscoped
1934019408 break;
1934119409 }
1934219410 // delete list
19343- label = 1664LLU; // start to repeat
19411+ label = 1672LLU; // start to repeat
1934419412 break;
1934519413 }
19346- case 1664LLU: // repeat from here
19414+ case 1672LLU: // repeat from here
1934719415 {
1934819416 if(!stack[base + 10])
1934919417 {
19350- label = 1665LLU; // break loop
19418+ label = 1673LLU; // break loop
1935119419 break;
1935219420 }
1935319421
@@ -19358,7 +19426,7 @@
1935819426 newstack[0] = (uint64_t)stack; // backup stack location
1935919427 newstack[1] = 1234567890;
1936019428 newstack[2] = base;
19361- newstack[3] = 1666LLU;
19429+ newstack[3] = 1674LLU;
1936219430 stack = newstack;
1936319431 // set stack-base & callee-address
1936419432 base = 4/*deloffset*/;
@@ -19365,7 +19433,7 @@
1936519433 label = 440LLU; // ~param
1936619434 break;
1936719435 }
19368- case 1666LLU: // return from ~param to REGISTER
19436+ case 1674LLU: // return from ~param to REGISTER
1936919437 {
1937019438 stack = (uint64_t *)stack[0];
1937119439 // releasing toplevel container
@@ -19376,40 +19444,40 @@
1937619444 stack[base + 10] = (uint64_t)list->next;
1937719445 Free(1, sizeof(struct listnode), list);
1937819446 }
19379- label = 1664LLU; // repeat
19447+ label = 1672LLU; // repeat
1938019448 break;
1938119449 }
19382- case 1665LLU: // loop finished
19450+ case 1673LLU: // loop finished
1938319451 {
19384- label = 1645LLU; // continue unrolling stack, delete next variable
19452+ label = 1653LLU; // continue unrolling stack, delete next variable
1938519453 break;
1938619454 }
19387- case 1663LLU: // skipped deleter
19455+ case 1671LLU: // skipped deleter
1938819456 {
1938919457 stack[base + 10] = 0;
1939019458 stack[base + 11] = stack[base + 1]/*argcount*/;
1939119459
19392- label = 1667LLU; // start to repeat
19460+ label = 1675LLU; // start to repeat
1939319461 break;
1939419462 }
19395- case 1667LLU: // repeat from here
19463+ case 1675LLU: // repeat from here
1939619464 {
1939719465 if(!stack[base + 11]--)
1939819466 {
19399- label = 1668LLU; // break loop
19467+ label = 1676LLU; // break loop
1940019468 break;
1940119469 }
1940219470
1940319471 // loop body
19404- label = 1670LLU; // skip deleter
19472+ label = 1678LLU; // skip deleter
1940519473 break;
1940619474 }
19407- case 1669LLU: // deleter
19475+ case 1677LLU: // deleter
1940819476 {
1940919477 // throw from REGISTER
1941019478 if(!stack[base + 12])
1941119479 {
19412- label = 1662LLU; // skip, variable already deleted/unscoped
19480+ label = 1670LLU; // skip, variable already deleted/unscoped
1941319481 break;
1941419482 }
1941519483
@@ -19418,7 +19486,7 @@
1941819486 newstack[0] = (uint64_t)stack; // backup stack location
1941919487 newstack[1] = 1234567890;
1942019488 newstack[2] = base;
19421- newstack[3] = 1671LLU;
19489+ newstack[3] = 1679LLU;
1942219490 stack = newstack;
1942319491 // set stack-base & callee-address
1942419492 base = 4/*deloffset*/;
@@ -19425,21 +19493,21 @@
1942519493 label = 310LLU; // ~type
1942619494 break;
1942719495 }
19428- case 1671LLU: // return from ~type to REGISTER
19496+ case 1679LLU: // return from ~type to REGISTER
1942919497 {
1943019498 stack = (uint64_t *)stack[0];
1943119499 // releasing toplevel container
1943219500 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
1943319501
19434- label = 1662LLU; // continue unrolling stack, delete next variable
19502+ label = 1670LLU; // continue unrolling stack, delete next variable
1943519503 break;
1943619504 }
19437- case 1670LLU: // skipped deleter
19505+ case 1678LLU: // skipped deleter
1943819506 {
1943919507 // call mktypedata from REGISTER
19440- stack[base + 13LLU] = 1672LLU/*throw to this address*/;
19508+ stack[base + 13LLU] = 1680LLU/*throw to this address*/;
1944119509 stack[base + 14LLU] = base;
19442- stack[base + 15LLU] = 1673LLU;
19510+ stack[base + 15LLU] = 1681LLU;
1944319511 // arguments for call to mktypedata
1944419512 stack[base + 17LLU] = 881834713755418624LLU;
1944519513 // set stack-base & callee-address
@@ -19447,37 +19515,37 @@
1944719515 label = 314LLU; // mktypedata
1944819516 break;
1944919517 }
19450- case 1672LLU: // copy-back deleter (mktypedata to REGISTER)
19518+ case 1680LLU: // copy-back deleter (mktypedata to REGISTER)
1945119519 {
1945219520 // copy mutable arguments back from call to mktypedata
19453- label = 1662LLU; // continue to roll stack
19521+ label = 1670LLU; // continue to roll stack
1945419522 break;
1945519523 }
19456- case 1673LLU: // return from mktypedata to REGISTER
19524+ case 1681LLU: // return from mktypedata to REGISTER
1945719525 {
1945819526 // copy mutable arguments back from call to mktypedata
1945919527 // copy back results provided by call to mktypedata
1946019528 stack[base + 12] = stack[base + 16LLU];
19461- label = 1675LLU; // skip deleter
19529+ label = 1683LLU; // skip deleter
1946219530 break;
1946319531 }
19464- case 1674LLU: // deleter
19532+ case 1682LLU: // deleter
1946519533 {
1946619534 // throw from REGISTER
1946719535 if(!stack[base + 13])
1946819536 {
19469- label = 1669LLU; // skip, variable already deleted/unscoped
19537+ label = 1677LLU; // skip, variable already deleted/unscoped
1947019538 break;
1947119539 }
19472- label = 1669LLU; // continue unrolling stack, delete next variable
19540+ label = 1677LLU; // continue unrolling stack, delete next variable
1947319541 break;
1947419542 }
19475- case 1675LLU: // skipped deleter
19543+ case 1683LLU: // skipped deleter
1947619544 {
1947719545 // call idwithnr from REGISTER
19478- stack[base + 14LLU] = 1676LLU/*throw to this address*/;
19546+ stack[base + 14LLU] = 1684LLU/*throw to this address*/;
1947919547 stack[base + 15LLU] = base;
19480- stack[base + 16LLU] = 1677LLU;
19548+ stack[base + 16LLU] = 1685LLU;
1948119549 // arguments for call to idwithnr
1948219550 stack[base + 18LLU] = 517219065798852608LLU;
1948319551 stack[base + 19LLU] = stack[base + 11]/*ARGCOUNT*/;
@@ -19486,26 +19554,26 @@
1948619554 label = 18446744073709551579LLU; // idwithnr
1948719555 break;
1948819556 }
19489- case 1676LLU: // copy-back deleter (idwithnr to REGISTER)
19557+ case 1684LLU: // copy-back deleter (idwithnr to REGISTER)
1949019558 {
1949119559 // copy mutable arguments back from call to idwithnr
19492- label = 1669LLU; // continue to roll stack
19560+ label = 1677LLU; // continue to roll stack
1949319561 break;
1949419562 }
19495- case 1677LLU: // return from idwithnr to REGISTER
19563+ case 1685LLU: // return from idwithnr to REGISTER
1949619564 {
1949719565 // copy mutable arguments back from call to idwithnr
1949819566 // copy back results provided by call to idwithnr
1949919567 stack[base + 13] = stack[base + 17LLU];
19500- label = 1679LLU; // skip deleter
19568+ label = 1687LLU; // skip deleter
1950119569 break;
1950219570 }
19503- case 1678LLU: // deleter
19571+ case 1686LLU: // deleter
1950419572 {
1950519573 // throw from REGISTER
1950619574 if(!stack[base + 14])
1950719575 {
19508- label = 1674LLU; // skip, variable already deleted/unscoped
19576+ label = 1682LLU; // skip, variable already deleted/unscoped
1950919577 break;
1951019578 }
1951119579
@@ -19514,7 +19582,7 @@
1951419582 newstack[0] = (uint64_t)stack; // backup stack location
1951519583 newstack[1] = 1234567890;
1951619584 newstack[2] = base;
19517- newstack[3] = 1680LLU;
19585+ newstack[3] = 1688LLU;
1951819586 stack = newstack;
1951919587 // set stack-base & callee-address
1952019588 base = 4/*deloffset*/;
@@ -19521,21 +19589,21 @@
1952119589 label = 372LLU; // ~typeid
1952219590 break;
1952319591 }
19524- case 1680LLU: // return from ~typeid to REGISTER
19592+ case 1688LLU: // return from ~typeid to REGISTER
1952519593 {
1952619594 stack = (uint64_t *)stack[0];
1952719595 // releasing toplevel container
1952819596 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1952919597
19530- label = 1674LLU; // continue unrolling stack, delete next variable
19598+ label = 1682LLU; // continue unrolling stack, delete next variable
1953119599 break;
1953219600 }
19533- case 1679LLU: // skipped deleter
19601+ case 1687LLU: // skipped deleter
1953419602 {
1953519603 // construct typeid.typeid
1953619604 if(!(stack[base + 14] = construct(2)))
1953719605 {
19538- label = 1674LLU; // throw: begin to unroll stack
19606+ label = 1682LLU; // throw: begin to unroll stack
1953919607 break;
1954019608 }
1954119609
@@ -19543,32 +19611,32 @@
1954319611 ((uint64_t *)stack[base + 14])[0] = 0;
1954419612 INIT(&(((uint64_t **)(stack[base + 14]))[1][0]), &stack[base + 12]/*type*/);
1954519613 (((uint64_t **)(stack[base + 14]))[1][1]) = stack[base + 13]/*id*/;
19546- label = 1682LLU; // skip deleter
19614+ label = 1690LLU; // skip deleter
1954719615 break;
1954819616 }
19549- case 1681LLU: // deleter
19617+ case 1689LLU: // deleter
1955019618 {
1955119619 // throw from REGISTER
1955219620 if(!stack[base + 15])
1955319621 {
19554- label = 1678LLU; // skip, variable already deleted/unscoped
19622+ label = 1686LLU; // skip, variable already deleted/unscoped
1955519623 break;
1955619624 }
19557- label = 1678LLU; // continue unrolling stack, delete next variable
19625+ label = 1686LLU; // continue unrolling stack, delete next variable
1955819626 break;
1955919627 }
19560- case 1682LLU: // skipped deleter
19628+ case 1690LLU: // skipped deleter
1956119629 {
1956219630 stack[base + 15] = 0;
19563- label = 1684LLU; // skip deleter
19631+ label = 1692LLU; // skip deleter
1956419632 break;
1956519633 }
19566- case 1683LLU: // deleter
19634+ case 1691LLU: // deleter
1956719635 {
1956819636 // throw from REGISTER
1956919637 if(!stack[base + 16])
1957019638 {
19571- label = 1681LLU; // skip, variable already deleted/unscoped
19639+ label = 1689LLU; // skip, variable already deleted/unscoped
1957219640 break;
1957319641 }
1957419642
@@ -19577,7 +19645,7 @@
1957719645 newstack[0] = (uint64_t)stack; // backup stack location
1957819646 newstack[1] = 1234567890;
1957919647 newstack[2] = base;
19580- newstack[3] = 1685LLU;
19648+ newstack[3] = 1693LLU;
1958119649 stack = newstack;
1958219650 // set stack-base & callee-address
1958319651 base = 4/*deloffset*/;
@@ -19584,21 +19652,21 @@
1958419652 label = 440LLU; // ~param
1958519653 break;
1958619654 }
19587- case 1685LLU: // return from ~param to REGISTER
19655+ case 1693LLU: // return from ~param to REGISTER
1958819656 {
1958919657 stack = (uint64_t *)stack[0];
1959019658 // releasing toplevel container
1959119659 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
1959219660
19593- label = 1681LLU; // continue unrolling stack, delete next variable
19661+ label = 1689LLU; // continue unrolling stack, delete next variable
1959419662 break;
1959519663 }
19596- case 1684LLU: // skipped deleter
19664+ case 1692LLU: // skipped deleter
1959719665 {
1959819666 // construct param.param
1959919667 if(!(stack[base + 16] = construct(2)))
1960019668 {
19601- label = 1681LLU; // throw: begin to unroll stack
19669+ label = 1689LLU; // throw: begin to unroll stack
1960219670 break;
1960319671 }
1960419672
@@ -19619,49 +19687,49 @@
1961919687 /*fnargtypes*/stack[base + 10] = (uint64_t)list;
1962019688 MOVE(&list->data, &stack[base + 16]/*param*/);
1962119689 }
19622- label = 1667LLU; // repeat
19690+ label = 1675LLU; // repeat
1962319691 break;
1962419692 }
19625- case 1668LLU: // loop finished
19693+ case 1676LLU: // loop finished
1962619694 {
19627- label = 1687LLU; // skip deleter
19695+ label = 1695LLU; // skip deleter
1962819696 break;
1962919697 }
19630- case 1686LLU: // deleter
19698+ case 1694LLU: // deleter
1963119699 {
1963219700 // throw from REGISTER
1963319701 if(!stack[base + 12])
1963419702 {
19635- label = 1662LLU; // skip, variable already deleted/unscoped
19703+ label = 1670LLU; // skip, variable already deleted/unscoped
1963619704 break;
1963719705 }
19638- label = 1662LLU; // continue unrolling stack, delete next variable
19706+ label = 1670LLU; // continue unrolling stack, delete next variable
1963919707 break;
1964019708 }
19641- case 1687LLU: // skipped deleter
19709+ case 1695LLU: // skipped deleter
1964219710 {
1964319711 stack[base + 12] = 0;
19644- label = 1689LLU; // skip deleter
19712+ label = 1697LLU; // skip deleter
1964519713 break;
1964619714 }
19647- case 1688LLU: // deleter
19715+ case 1696LLU: // deleter
1964819716 {
1964919717 // throw from REGISTER
1965019718 if(!stack[base + 13])
1965119719 {
19652- label = 1686LLU; // skip, variable already deleted/unscoped
19720+ label = 1694LLU; // skip, variable already deleted/unscoped
1965319721 break;
1965419722 }
19655- label = 1686LLU; // continue unrolling stack, delete next variable
19723+ label = 1694LLU; // continue unrolling stack, delete next variable
1965619724 break;
1965719725 }
19658- case 1689LLU: // skipped deleter
19726+ case 1697LLU: // skipped deleter
1965919727 {
1966019728 stack[base + 13] = 0;
1966119729 // call sub from REGISTER
19662- stack[base + 14LLU] = 1690LLU/*throw to this address*/;
19730+ stack[base + 14LLU] = 1698LLU/*throw to this address*/;
1966319731 stack[base + 15LLU] = base;
19664- stack[base + 16LLU] = 1691LLU;
19732+ stack[base + 16LLU] = 1699LLU;
1966519733 // arguments for call to sub
1966619734 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1966719735 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
@@ -19670,21 +19738,21 @@
1967019738 label = 18446744073709551604LLU; // sub
1967119739 break;
1967219740 }
19673- case 1690LLU: // copy-back deleter (sub to REGISTER)
19741+ case 1698LLU: // copy-back deleter (sub to REGISTER)
1967419742 {
1967519743 // copy mutable arguments back from call to sub
19676- label = 1688LLU; // continue to roll stack
19744+ label = 1696LLU; // continue to roll stack
1967719745 break;
1967819746 }
19679- case 1691LLU: // return from sub to REGISTER
19747+ case 1699LLU: // return from sub to REGISTER
1968019748 {
1968119749 // copy mutable arguments back from call to sub
1968219750 // copy back results provided by call to sub
1968319751 stack[base + 13] = stack[base + 17LLU];
1968419752 // call sub from REGISTER
19685- stack[base + 14LLU] = 1692LLU/*throw to this address*/;
19753+ stack[base + 14LLU] = 1700LLU/*throw to this address*/;
1968619754 stack[base + 15LLU] = base;
19687- stack[base + 16LLU] = 1693LLU;
19755+ stack[base + 16LLU] = 1701LLU;
1968819756 // arguments for call to sub
1968919757 stack[base + 18LLU] = stack[base + 13]/*fnlabel*/;
1969019758 stack[base + 19LLU] = 1LLU;
@@ -19693,26 +19761,26 @@
1969319761 label = 18446744073709551604LLU; // sub
1969419762 break;
1969519763 }
19696- case 1692LLU: // copy-back deleter (sub to REGISTER)
19764+ case 1700LLU: // copy-back deleter (sub to REGISTER)
1969719765 {
1969819766 // copy mutable arguments back from call to sub
19699- label = 1688LLU; // continue to roll stack
19767+ label = 1696LLU; // continue to roll stack
1970019768 break;
1970119769 }
19702- case 1693LLU: // return from sub to REGISTER
19770+ case 1701LLU: // return from sub to REGISTER
1970319771 {
1970419772 // copy mutable arguments back from call to sub
1970519773 // copy back results provided by call to sub
1970619774 stack[base + 13] = stack[base + 17LLU];
19707- label = 1695LLU; // skip deleter
19775+ label = 1703LLU; // skip deleter
1970819776 break;
1970919777 }
19710- case 1694LLU: // deleter
19778+ case 1702LLU: // deleter
1971119779 {
1971219780 // throw from REGISTER
1971319781 if(!stack[base + 14])
1971419782 {
19715- label = 1688LLU; // skip, variable already deleted/unscoped
19783+ label = 1696LLU; // skip, variable already deleted/unscoped
1971619784 break;
1971719785 }
1971819786
@@ -19721,7 +19789,7 @@
1972119789 newstack[0] = (uint64_t)stack; // backup stack location
1972219790 newstack[1] = 1234567890;
1972319791 newstack[2] = base;
19724- newstack[3] = 1696LLU;
19792+ newstack[3] = 1704LLU;
1972519793 stack = newstack;
1972619794 // set stack-base & callee-address
1972719795 base = 4/*deloffset*/;
@@ -19728,21 +19796,21 @@
1972819796 label = 1420LLU; // ~fndef
1972919797 break;
1973019798 }
19731- case 1696LLU: // return from ~fndef to REGISTER
19799+ case 1704LLU: // return from ~fndef to REGISTER
1973219800 {
1973319801 stack = (uint64_t *)stack[0];
1973419802 // releasing toplevel container
1973519803 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4));
1973619804
19737- label = 1688LLU; // continue unrolling stack, delete next variable
19805+ label = 1696LLU; // continue unrolling stack, delete next variable
1973819806 break;
1973919807 }
19740- case 1695LLU: // skipped deleter
19808+ case 1703LLU: // skipped deleter
1974119809 {
1974219810 // construct fndef.fndef
1974319811 if(!(stack[base + 14] = construct(8)))
1974419812 {
19745- label = 1688LLU; // throw: begin to unroll stack
19813+ label = 1696LLU; // throw: begin to unroll stack
1974619814 break;
1974719815 }
1974819816
@@ -19770,9 +19838,9 @@
1977019838 MOVE(&list->data, &stack[base + 14]/*fndef*/);
1977119839 }
1977219840 // call add from REGISTER
19773- stack[base + 15LLU] = 1697LLU/*throw to this address*/;
19841+ stack[base + 15LLU] = 1705LLU/*throw to this address*/;
1977419842 stack[base + 16LLU] = base;
19775- stack[base + 17LLU] = 1698LLU;
19843+ stack[base + 17LLU] = 1706LLU;
1977619844 // arguments for call to add
1977719845 stack[base + 19LLU] = stack[base + 5]/*defcount*/;
1977819846 stack[base + 20LLU] = 1LLU;
@@ -19781,13 +19849,13 @@
1978119849 label = 18446744073709551605LLU; // add
1978219850 break;
1978319851 }
19784- case 1697LLU: // copy-back deleter (add to REGISTER)
19852+ case 1705LLU: // copy-back deleter (add to REGISTER)
1978519853 {
1978619854 // copy mutable arguments back from call to add
19787- label = 1694LLU; // continue to roll stack
19855+ label = 1702LLU; // continue to roll stack
1978819856 break;
1978919857 }
19790- case 1698LLU: // return from add to REGISTER
19858+ case 1706LLU: // return from add to REGISTER
1979119859 {
1979219860 // copy mutable arguments back from call to add
1979319861 // copy back results provided by call to add
@@ -19797,13 +19865,13 @@
1979719865 base = stack[base - 2];
1979819866 break;
1979919867 }
19800- case 1700LLU: // function register failed
19868+ case 1708LLU: // function register failed
1980119869 {
1980219870 label = stack[base - 3];
1980319871 base = stack[base - 2];
1980419872 break;
1980519873 }
19806- case 1699LLU: // register
19874+ case 1707LLU: // register
1980719875 {
1980819876 //#define arg0 0
1980919877 //#define arg1 1
@@ -19814,28 +19882,28 @@
1981419882 //#define arg6 6
1981519883 //#define arg7 7
1981619884 // call emitreturn from register
19817- stack[base + 8LLU] = 1701LLU/*throw to this address*/;
19885+ stack[base + 8LLU] = 1709LLU/*throw to this address*/;
1981819886 stack[base + 9LLU] = base;
19819- stack[base + 10LLU] = 1702LLU;
19887+ stack[base + 10LLU] = 1710LLU;
1982019888 // arguments for call to emitreturn
1982119889 // set stack-base & callee-address
1982219890 base += 11LLU;
19823- label = 1631LLU; // emitreturn
19891+ label = 1639LLU; // emitreturn
1982419892 break;
1982519893 }
19826- case 1701LLU: // copy-back deleter (emitreturn to register)
19894+ case 1709LLU: // copy-back deleter (emitreturn to register)
1982719895 {
1982819896 // copy mutable arguments back from call to emitreturn
19829- label = 1700LLU; // continue to roll stack
19897+ label = 1708LLU; // continue to roll stack
1983019898 break;
1983119899 }
19832- case 1702LLU: // return from emitreturn to register
19900+ case 1710LLU: // return from emitreturn to register
1983319901 {
1983419902 // copy mutable arguments back from call to emitreturn
1983519903 // call REGISTER from register
19836- stack[base + 8LLU] = 1703LLU/*throw to this address*/;
19904+ stack[base + 8LLU] = 1711LLU/*throw to this address*/;
1983719905 stack[base + 9LLU] = base;
19838- stack[base + 10LLU] = 1704LLU;
19906+ stack[base + 10LLU] = 1712LLU;
1983919907 // arguments for call to REGISTER
1984019908 stack[base + 11LLU] = stack[base + 0]/*rescount*/;
1984119909 stack[base + 12LLU] = stack[base + 1]/*argcount*/;
@@ -19847,41 +19915,41 @@
1984719915 stack[base + 18LLU] = stack[base + 7]/*IO*/;
1984819916 // set stack-base & callee-address
1984919917 base += 11LLU;
19850- label = 1643LLU; // REGISTER
19918+ label = 1651LLU; // REGISTER
1985119919 break;
1985219920 }
19853- case 1703LLU: // copy-back deleter (REGISTER to register)
19921+ case 1711LLU: // copy-back deleter (REGISTER to register)
1985419922 {
1985519923 // copy mutable arguments back from call to REGISTER
1985619924 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
1985719925 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
19858- label = 1700LLU; // continue to roll stack
19926+ label = 1708LLU; // continue to roll stack
1985919927 break;
1986019928 }
19861- case 1704LLU: // return from REGISTER to register
19929+ case 1712LLU: // return from REGISTER to register
1986219930 {
1986319931 // copy mutable arguments back from call to REGISTER
1986419932 stack[base + 5]/*defcount*/ = stack[base + 16LLU];
1986519933 stack[base + 4]/*fndefs*/ = stack[base + 15LLU];
1986619934 // call emitcase from register
19867- stack[base + 8LLU] = 1705LLU/*throw to this address*/;
19935+ stack[base + 8LLU] = 1713LLU/*throw to this address*/;
1986819936 stack[base + 9LLU] = base;
19869- stack[base + 10LLU] = 1706LLU;
19937+ stack[base + 10LLU] = 1714LLU;
1987019938 // arguments for call to emitcase
1987119939 stack[base + 11LLU] = stack[base + 5]/*defcount*/;
1987219940 stack[base + 12LLU] = stack[base + 3]/*fnid*/;
1987319941 // set stack-base & callee-address
1987419942 base += 11LLU;
19875- label = 1625LLU; // emitcase
19943+ label = 1633LLU; // emitcase
1987619944 break;
1987719945 }
19878- case 1705LLU: // copy-back deleter (emitcase to register)
19946+ case 1713LLU: // copy-back deleter (emitcase to register)
1987919947 {
1988019948 // copy mutable arguments back from call to emitcase
19881- label = 1700LLU; // continue to roll stack
19949+ label = 1708LLU; // continue to roll stack
1988219950 break;
1988319951 }
19884- case 1706LLU: // return from emitcase to register
19952+ case 1714LLU: // return from emitcase to register
1988519953 {
1988619954 // copy mutable arguments back from call to emitcase
1988719955 // return from register
@@ -19889,19 +19957,19 @@
1988919957 base = stack[base - 2];
1989019958 break;
1989119959 }
19892- case 1708LLU: // function linkthrow failed
19960+ case 1716LLU: // function linkthrow failed
1989319961 {
1989419962 label = stack[base - 3];
1989519963 base = stack[base - 2];
1989619964 break;
1989719965 }
19898- case 1707LLU: // linkthrow
19966+ case 1715LLU: // linkthrow
1989919967 {
1990019968 //#define arg0 0
1990119969 //#define arg1 1
1990219970 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
1990319971 {
19904- label = 1710LLU; // jump to alternative
19972+ label = 1718LLU; // jump to alternative
1990519973 break;
1990619974 }
1990719975
@@ -19912,22 +19980,22 @@
1991219980 stack[base + 2]/*labelthrow*/ = stack[base + 1]/*labelfail*/;
1991319981 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
1991419982 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
19915- label = 1709LLU; // case complete
19983+ label = 1717LLU; // case complete
1991619984 break;
1991719985 }
19918- case 1711LLU: // copy-back deleter (switch)
19986+ case 1719LLU: // copy-back deleter (switch)
1991919987 {
1992019988 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 3];
1992119989 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 2];
19922- label = 1708LLU; // continue to unroll stack
19990+ label = 1716LLU; // continue to unroll stack
1992319991 break;
1992419992 }
19925- case 1710LLU: // try next case
19993+ case 1718LLU: // try next case
1992619994 {
1992719995 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1992819996 exit(-1);
1992919997 }
19930- case 1709LLU: // completed switch
19998+ case 1717LLU: // completed switch
1993119999 {
1993220000 // return from linkthrow
1993320001 label = stack[base - 1];
@@ -19934,19 +20002,19 @@
1993420002 base = stack[base - 2];
1993520003 break;
1993620004 }
19937- case 1713LLU: // function emitthrow failed
20005+ case 1721LLU: // function emitthrow failed
1993820006 {
1993920007 label = stack[base - 3];
1994020008 base = stack[base - 2];
1994120009 break;
1994220010 }
19943- case 1712LLU: // emitthrow
20011+ case 1720LLU: // emitthrow
1994420012 {
1994520013 //#define arg0 0
1994620014 printf("%s", "\n {");
1994720015 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
1994820016 {
19949- label = 1715LLU; // jump to alternative
20017+ label = 1723LLU; // jump to alternative
1995020018 break;
1995120019 }
1995220020
@@ -19956,9 +20024,9 @@
1995620024 // case
1995720025 printf("%s", "\n label = ");
1995820026 // call printnr from emitthrow
19959- stack[base + 3LLU] = 1717LLU/*throw to this address*/;
20027+ stack[base + 3LLU] = 1725LLU/*throw to this address*/;
1996020028 stack[base + 4LLU] = base;
19961- stack[base + 5LLU] = 1718LLU;
20029+ stack[base + 5LLU] = 1726LLU;
1996220030 // arguments for call to printnr
1996320031 stack[base + 6LLU] = stack[base + 1]/*labelthrow*/;
1996420032 // set stack-base & callee-address
@@ -19966,34 +20034,34 @@
1996620034 label = 18446744073709551590LLU; // printnr
1996720035 break;
1996820036 }
19969- case 1717LLU: // copy-back deleter (printnr to emitthrow)
20037+ case 1725LLU: // copy-back deleter (printnr to emitthrow)
1997020038 {
1997120039 // copy mutable arguments back from call to printnr
19972- label = 1716LLU; // continue to roll stack
20040+ label = 1724LLU; // continue to roll stack
1997320041 break;
1997420042 }
19975- case 1718LLU: // return from printnr to emitthrow
20043+ case 1726LLU: // return from printnr to emitthrow
1997620044 {
1997720045 // copy mutable arguments back from call to printnr
1997820046 printf("%s", "LLU; // throw: begin to unroll stack");
1997920047 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
1998020048 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
19981- label = 1714LLU; // case complete
20049+ label = 1722LLU; // case complete
1998220050 break;
1998320051 }
19984- case 1716LLU: // copy-back deleter (switch)
20052+ case 1724LLU: // copy-back deleter (switch)
1998520053 {
1998620054 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
1998720055 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
19988- label = 1713LLU; // continue to unroll stack
20056+ label = 1721LLU; // continue to unroll stack
1998920057 break;
1999020058 }
19991- case 1715LLU: // try next case
20059+ case 1723LLU: // try next case
1999220060 {
1999320061 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1999420062 exit(-1);
1999520063 }
19996- case 1714LLU: // completed switch
20064+ case 1722LLU: // completed switch
1999720065 {
1999820066 printf("%s", "\n break;");
1999920067 printf("%s", "\n }");
@@ -20003,13 +20071,13 @@
2000320071 base = stack[base - 2];
2000420072 break;
2000520073 }
20006- case 1720LLU: // function ProcCall failed
20074+ case 1728LLU: // function ProcCall failed
2000720075 {
2000820076 label = stack[base - 3];
2000920077 base = stack[base - 2];
2001020078 break;
2001120079 }
20012- case 1719LLU: // ProcCall
20080+ case 1727LLU: // ProcCall
2001320081 {
2001420082 //#define arg0 0
2001520083 //#define arg1 1
@@ -20029,43 +20097,43 @@
2002920097 //#define arg15 15
2003020098 //#define arg16 16
2003120099 //#define arg17 17
20032- label = 1722LLU; // skip deleter
20100+ label = 1730LLU; // skip deleter
2003320101 break;
2003420102 }
20035- case 1721LLU: // deleter
20103+ case 1729LLU: // deleter
2003620104 {
2003720105 // throw from ProcCall
2003820106 if(!stack[base + 18])
2003920107 {
20040- label = 1720LLU; // skip, variable already deleted/unscoped
20108+ label = 1728LLU; // skip, variable already deleted/unscoped
2004120109 break;
2004220110 }
20043- label = 1720LLU; // continue unrolling stack, delete next variable
20111+ label = 1728LLU; // continue unrolling stack, delete next variable
2004420112 break;
2004520113 }
20046- case 1722LLU: // skipped deleter
20114+ case 1730LLU: // skipped deleter
2004720115 {
2004820116 stack[base + 18] = 0;
20049- label = 1724LLU; // skip deleter
20117+ label = 1732LLU; // skip deleter
2005020118 break;
2005120119 }
20052- case 1723LLU: // deleter
20120+ case 1731LLU: // deleter
2005320121 {
2005420122 // throw from ProcCall
2005520123 if(!stack[base + 19])
2005620124 {
20057- label = 1721LLU; // skip, variable already deleted/unscoped
20125+ label = 1729LLU; // skip, variable already deleted/unscoped
2005820126 break;
2005920127 }
2006020128 // delete list
20061- label = 1725LLU; // start to repeat
20129+ label = 1733LLU; // start to repeat
2006220130 break;
2006320131 }
20064- case 1725LLU: // repeat from here
20132+ case 1733LLU: // repeat from here
2006520133 {
2006620134 if(!stack[base + 19])
2006720135 {
20068- label = 1726LLU; // break loop
20136+ label = 1734LLU; // break loop
2006920137 break;
2007020138 }
2007120139
@@ -20076,7 +20144,7 @@
2007620144 newstack[0] = (uint64_t)stack; // backup stack location
2007720145 newstack[1] = 1234567890;
2007820146 newstack[2] = base;
20079- newstack[3] = 1727LLU;
20147+ newstack[3] = 1735LLU;
2008020148 stack = newstack;
2008120149 // set stack-base & callee-address
2008220150 base = 4/*deloffset*/;
@@ -20083,7 +20151,7 @@
2008320151 label = 833LLU; // ~idnr
2008420152 break;
2008520153 }
20086- case 1727LLU: // return from ~idnr to ProcCall
20154+ case 1735LLU: // return from ~idnr to ProcCall
2008720155 {
2008820156 stack = (uint64_t *)stack[0];
2008920157 // releasing toplevel container
@@ -20094,20 +20162,20 @@
2009420162 stack[base + 19] = (uint64_t)list->next;
2009520163 Free(1, sizeof(struct listnode), list);
2009620164 }
20097- label = 1725LLU; // repeat
20165+ label = 1733LLU; // repeat
2009820166 break;
2009920167 }
20100- case 1726LLU: // loop finished
20168+ case 1734LLU: // loop finished
2010120169 {
20102- label = 1721LLU; // continue unrolling stack, delete next variable
20170+ label = 1729LLU; // continue unrolling stack, delete next variable
2010320171 break;
2010420172 }
20105- case 1724LLU: // skipped deleter
20173+ case 1732LLU: // skipped deleter
2010620174 {
2010720175 stack[base + 19] = 0;
2010820176 if(/*fndef*/0 != ((uint64_t *)(stack[base + 13]/*calleedef*/))[0])
2010920177 {
20110- label = 1729LLU; // jump to alternative
20178+ label = 1737LLU; // jump to alternative
2011120179 break;
2011220180 }
2011320181
@@ -20123,19 +20191,19 @@
2012320191 // case
2012420192 if(!stack[base + 6]/*fncanthrow*/)
2012520193 {
20126- label = 1731LLU; // jump to alternative
20194+ label = 1739LLU; // jump to alternative
2012720195 break;
2012820196 }
2012920197
2013020198 // consequent
20131- label = 1732LLU; // consequent complete
20199+ label = 1740LLU; // consequent complete
2013220200 break;
2013320201 }
20134- case 1731LLU: // alternative
20202+ case 1739LLU: // alternative
2013520203 {
2013620204 if(!stack[base + 26]/*cecanthrow*/)
2013720205 {
20138- label = 1733LLU; // jump to alternative
20206+ label = 1741LLU; // jump to alternative
2013920207 break;
2014020208 }
2014120209
@@ -20142,9 +20210,9 @@
2014220210 // consequent
2014320211 fprintf(stderr, "%s", "in function ");
2014420212 // call reportid from ProcCall
20145- stack[base + 28LLU] = 1735LLU/*throw to this address*/;
20213+ stack[base + 28LLU] = 1743LLU/*throw to this address*/;
2014620214 stack[base + 29LLU] = base;
20147- stack[base + 30LLU] = 1736LLU;
20215+ stack[base + 30LLU] = 1744LLU;
2014820216 // arguments for call to reportid
2014920217 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2015020218 // set stack-base & callee-address
@@ -20152,20 +20220,20 @@
2015220220 label = 18446744073709551586LLU; // reportid
2015320221 break;
2015420222 }
20155- case 1735LLU: // copy-back deleter (reportid to ProcCall)
20223+ case 1743LLU: // copy-back deleter (reportid to ProcCall)
2015620224 {
2015720225 // copy mutable arguments back from call to reportid
20158- label = 1730LLU; // continue to roll stack
20226+ label = 1738LLU; // continue to roll stack
2015920227 break;
2016020228 }
20161- case 1736LLU: // return from reportid to ProcCall
20229+ case 1744LLU: // return from reportid to ProcCall
2016220230 {
2016320231 // copy mutable arguments back from call to reportid
2016420232 fprintf(stderr, "%s", ": call to function ");
2016520233 // call reportid from ProcCall
20166- stack[base + 28LLU] = 1737LLU/*throw to this address*/;
20234+ stack[base + 28LLU] = 1745LLU/*throw to this address*/;
2016720235 stack[base + 29LLU] = base;
20168- stack[base + 30LLU] = 1738LLU;
20236+ stack[base + 30LLU] = 1746LLU;
2016920237 // arguments for call to reportid
2017020238 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2017120239 // set stack-base & callee-address
@@ -20173,51 +20241,51 @@
2017320241 label = 18446744073709551586LLU; // reportid
2017420242 break;
2017520243 }
20176- case 1737LLU: // copy-back deleter (reportid to ProcCall)
20244+ case 1745LLU: // copy-back deleter (reportid to ProcCall)
2017720245 {
2017820246 // copy mutable arguments back from call to reportid
20179- label = 1730LLU; // continue to roll stack
20247+ label = 1738LLU; // continue to roll stack
2018020248 break;
2018120249 }
20182- case 1738LLU: // return from reportid to ProcCall
20250+ case 1746LLU: // return from reportid to ProcCall
2018320251 {
2018420252 // copy mutable arguments back from call to reportid
2018520253 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2018620254 {
20187- label = 1730LLU; // throw: begin to unroll stack
20255+ label = 1738LLU; // throw: begin to unroll stack
2018820256 break;
2018920257 }
2019020258
20191- label = 1734LLU; // consequent complete
20259+ label = 1742LLU; // consequent complete
2019220260 break;
2019320261 }
20194- case 1733LLU: // alternative
20262+ case 1741LLU: // alternative
2019520263 {
20196- label = 1734LLU; // alternative complete
20264+ label = 1742LLU; // alternative complete
2019720265 break;
2019820266 }
20199- case 1734LLU: // completed if-then-else
20267+ case 1742LLU: // completed if-then-else
2020020268 {
20201- label = 1732LLU; // alternative complete
20269+ label = 1740LLU; // alternative complete
2020220270 break;
2020320271 }
20204- case 1732LLU: // completed if-then-else
20272+ case 1740LLU: // completed if-then-else
2020520273 {
2020620274 if(!stack[base + 7]/*fnIO*/)
2020720275 {
20208- label = 1739LLU; // jump to alternative
20276+ label = 1747LLU; // jump to alternative
2020920277 break;
2021020278 }
2021120279
2021220280 // consequent
20213- label = 1740LLU; // consequent complete
20281+ label = 1748LLU; // consequent complete
2021420282 break;
2021520283 }
20216- case 1739LLU: // alternative
20284+ case 1747LLU: // alternative
2021720285 {
2021820286 if(!stack[base + 27]/*ceIO*/)
2021920287 {
20220- label = 1741LLU; // jump to alternative
20288+ label = 1749LLU; // jump to alternative
2022120289 break;
2022220290 }
2022320291
@@ -20224,9 +20292,9 @@
2022420292 // consequent
2022520293 fprintf(stderr, "%s", "in function ");
2022620294 // call reportid from ProcCall
20227- stack[base + 28LLU] = 1743LLU/*throw to this address*/;
20295+ stack[base + 28LLU] = 1751LLU/*throw to this address*/;
2022820296 stack[base + 29LLU] = base;
20229- stack[base + 30LLU] = 1744LLU;
20297+ stack[base + 30LLU] = 1752LLU;
2023020298 // arguments for call to reportid
2023120299 stack[base + 31LLU] = stack[base + 8]/*fnid*/;
2023220300 // set stack-base & callee-address
@@ -20234,20 +20302,20 @@
2023420302 label = 18446744073709551586LLU; // reportid
2023520303 break;
2023620304 }
20237- case 1743LLU: // copy-back deleter (reportid to ProcCall)
20305+ case 1751LLU: // copy-back deleter (reportid to ProcCall)
2023820306 {
2023920307 // copy mutable arguments back from call to reportid
20240- label = 1730LLU; // continue to roll stack
20308+ label = 1738LLU; // continue to roll stack
2024120309 break;
2024220310 }
20243- case 1744LLU: // return from reportid to ProcCall
20311+ case 1752LLU: // return from reportid to ProcCall
2024420312 {
2024520313 // copy mutable arguments back from call to reportid
2024620314 fprintf(stderr, "%s", ": call to IO-function ");
2024720315 // call reportid from ProcCall
20248- stack[base + 28LLU] = 1745LLU/*throw to this address*/;
20316+ stack[base + 28LLU] = 1753LLU/*throw to this address*/;
2024920317 stack[base + 29LLU] = base;
20250- stack[base + 30LLU] = 1746LLU;
20318+ stack[base + 30LLU] = 1754LLU;
2025120319 // arguments for call to reportid
2025220320 stack[base + 31LLU] = stack[base + 24]/*ceid*/;
2025320321 // set stack-base & callee-address
@@ -20255,147 +20323,147 @@
2025520323 label = 18446744073709551586LLU; // reportid
2025620324 break;
2025720325 }
20258- case 1745LLU: // copy-back deleter (reportid to ProcCall)
20326+ case 1753LLU: // copy-back deleter (reportid to ProcCall)
2025920327 {
2026020328 // copy mutable arguments back from call to reportid
20261- label = 1730LLU; // continue to roll stack
20329+ label = 1738LLU; // continue to roll stack
2026220330 break;
2026320331 }
20264- case 1746LLU: // return from reportid to ProcCall
20332+ case 1754LLU: // return from reportid to ProcCall
2026520333 {
2026620334 // copy mutable arguments back from call to reportid
2026720335 fprintf(stderr, "%s", " in non-IO environment\n");
2026820336 {
20269- label = 1730LLU; // throw: begin to unroll stack
20337+ label = 1738LLU; // throw: begin to unroll stack
2027020338 break;
2027120339 }
2027220340
20273- label = 1742LLU; // consequent complete
20341+ label = 1750LLU; // consequent complete
2027420342 break;
2027520343 }
20276- case 1741LLU: // alternative
20344+ case 1749LLU: // alternative
2027720345 {
20278- label = 1742LLU; // alternative complete
20346+ label = 1750LLU; // alternative complete
2027920347 break;
2028020348 }
20281- case 1742LLU: // completed if-then-else
20349+ case 1750LLU: // completed if-then-else
2028220350 {
20283- label = 1740LLU; // alternative complete
20351+ label = 1748LLU; // alternative complete
2028420352 break;
2028520353 }
20286- case 1740LLU: // completed if-then-else
20354+ case 1748LLU: // completed if-then-else
2028720355 {
20288- label = 1748LLU; // skip deleter
20356+ label = 1756LLU; // skip deleter
2028920357 break;
2029020358 }
20291- case 1747LLU: // deleter
20359+ case 1755LLU: // deleter
2029220360 {
2029320361 // throw from ProcCall
2029420362 if(!stack[base + 28])
2029520363 {
20296- label = 1730LLU; // skip, variable already deleted/unscoped
20364+ label = 1738LLU; // skip, variable already deleted/unscoped
2029720365 break;
2029820366 }
20299- label = 1730LLU; // continue unrolling stack, delete next variable
20367+ label = 1738LLU; // continue unrolling stack, delete next variable
2030020368 break;
2030120369 }
20302- case 1748LLU: // skipped deleter
20370+ case 1756LLU: // skipped deleter
2030320371 {
2030420372 stack[base + 28] = list_size(((struct listnode *)(stack[base + 21]/*cerestypes*/)));
20305- label = 1750LLU; // skip deleter
20373+ label = 1758LLU; // skip deleter
2030620374 break;
2030720375 }
20308- case 1749LLU: // deleter
20376+ case 1757LLU: // deleter
2030920377 {
2031020378 // throw from ProcCall
2031120379 if(!stack[base + 29])
2031220380 {
20313- label = 1747LLU; // skip, variable already deleted/unscoped
20381+ label = 1755LLU; // skip, variable already deleted/unscoped
2031420382 break;
2031520383 }
20316- label = 1747LLU; // continue unrolling stack, delete next variable
20384+ label = 1755LLU; // continue unrolling stack, delete next variable
2031720385 break;
2031820386 }
20319- case 1750LLU: // skipped deleter
20387+ case 1758LLU: // skipped deleter
2032020388 {
2032120389 stack[base + 29] = list_size(((struct listnode *)(stack[base + 22]/*ceargtypes*/)));
2032220390 if(!stack[base + 20]/*celabel*/)
2032320391 {
20324- label = 1751LLU; // jump to alternative
20392+ label = 1759LLU; // jump to alternative
2032520393 break;
2032620394 }
2032720395
2032820396 // consequent
20329- label = 1752LLU; // consequent complete
20397+ label = 1760LLU; // consequent complete
2033020398 break;
2033120399 }
20332- case 1751LLU: // alternative
20400+ case 1759LLU: // alternative
2033320401 {
2033420402 fprintf(stderr, "%s", " NULL-label!\n");
2033520403 {
20336- label = 1749LLU; // throw: begin to unroll stack
20404+ label = 1757LLU; // throw: begin to unroll stack
2033720405 break;
2033820406 }
2033920407
20340- label = 1752LLU; // alternative complete
20408+ label = 1760LLU; // alternative complete
2034120409 break;
2034220410 }
20343- case 1752LLU: // completed if-then-else
20411+ case 1760LLU: // completed if-then-else
2034420412 {
20345- label = 1754LLU; // skip deleter
20413+ label = 1762LLU; // skip deleter
2034620414 break;
2034720415 }
20348- case 1753LLU: // deleter
20416+ case 1761LLU: // deleter
2034920417 {
2035020418 // throw from ProcCall
2035120419 if(!stack[base + 30])
2035220420 {
20353- label = 1749LLU; // skip, variable already deleted/unscoped
20421+ label = 1757LLU; // skip, variable already deleted/unscoped
2035420422 break;
2035520423 }
20356- label = 1749LLU; // continue unrolling stack, delete next variable
20424+ label = 1757LLU; // continue unrolling stack, delete next variable
2035720425 break;
2035820426 }
20359- case 1754LLU: // skipped deleter
20427+ case 1762LLU: // skipped deleter
2036020428 {
2036120429 stack[base + 30] = 0;
20362- label = 1756LLU; // skip deleter
20430+ label = 1764LLU; // skip deleter
2036320431 break;
2036420432 }
20365- case 1755LLU: // deleter
20433+ case 1763LLU: // deleter
2036620434 {
2036720435 // throw from ProcCall
2036820436 if(!stack[base + 31])
2036920437 {
20370- label = 1753LLU; // skip, variable already deleted/unscoped
20438+ label = 1761LLU; // skip, variable already deleted/unscoped
2037120439 break;
2037220440 }
20373- label = 1753LLU; // continue unrolling stack, delete next variable
20441+ label = 1761LLU; // continue unrolling stack, delete next variable
2037420442 break;
2037520443 }
20376- case 1756LLU: // skipped deleter
20444+ case 1764LLU: // skipped deleter
2037720445 {
2037820446 stack[base + 31] = 0;
20379- label = 1758LLU; // skip deleter
20447+ label = 1766LLU; // skip deleter
2038020448 break;
2038120449 }
20382- case 1757LLU: // deleter
20450+ case 1765LLU: // deleter
2038320451 {
2038420452 // throw from ProcCall
2038520453 if(!stack[base + 32])
2038620454 {
20387- label = 1755LLU; // skip, variable already deleted/unscoped
20455+ label = 1763LLU; // skip, variable already deleted/unscoped
2038820456 break;
2038920457 }
20390- label = 1755LLU; // continue unrolling stack, delete next variable
20458+ label = 1763LLU; // continue unrolling stack, delete next variable
2039120459 break;
2039220460 }
20393- case 1758LLU: // skipped deleter
20461+ case 1766LLU: // skipped deleter
2039420462 {
2039520463 stack[base + 32] = 0;
2039620464 if(!stack[base + 25]/*cerec*/)
2039720465 {
20398- label = 1759LLU; // jump to alternative
20466+ label = 1767LLU; // jump to alternative
2039920467 break;
2040020468 }
2040120469
@@ -20402,21 +20470,21 @@
2040220470 // consequent
2040320471 if(!stack[base + 6]/*fncanthrow*/)
2040420472 {
20405- label = 1761LLU; // jump to alternative
20473+ label = 1769LLU; // jump to alternative
2040620474 break;
2040720475 }
2040820476
2040920477 // consequent
20410- label = 1762LLU; // consequent complete
20478+ label = 1770LLU; // consequent complete
2041120479 break;
2041220480 }
20413- case 1761LLU: // alternative
20481+ case 1769LLU: // alternative
2041420482 {
2041520483 fprintf(stderr, "%s", "in function ");
2041620484 // call reportid from ProcCall
20417- stack[base + 33LLU] = 1763LLU/*throw to this address*/;
20485+ stack[base + 33LLU] = 1771LLU/*throw to this address*/;
2041820486 stack[base + 34LLU] = base;
20419- stack[base + 35LLU] = 1764LLU;
20487+ stack[base + 35LLU] = 1772LLU;
2042020488 // arguments for call to reportid
2042120489 stack[base + 36LLU] = stack[base + 8]/*fnid*/;
2042220490 // set stack-base & callee-address
@@ -20424,20 +20492,20 @@
2042420492 label = 18446744073709551586LLU; // reportid
2042520493 break;
2042620494 }
20427- case 1763LLU: // copy-back deleter (reportid to ProcCall)
20495+ case 1771LLU: // copy-back deleter (reportid to ProcCall)
2042820496 {
2042920497 // copy mutable arguments back from call to reportid
20430- label = 1757LLU; // continue to roll stack
20498+ label = 1765LLU; // continue to roll stack
2043120499 break;
2043220500 }
20433- case 1764LLU: // return from reportid to ProcCall
20501+ case 1772LLU: // return from reportid to ProcCall
2043420502 {
2043520503 // copy mutable arguments back from call to reportid
2043620504 fprintf(stderr, "%s", ": call to recursive function ");
2043720505 // call reportid from ProcCall
20438- stack[base + 33LLU] = 1765LLU/*throw to this address*/;
20506+ stack[base + 33LLU] = 1773LLU/*throw to this address*/;
2043920507 stack[base + 34LLU] = base;
20440- stack[base + 35LLU] = 1766LLU;
20508+ stack[base + 35LLU] = 1774LLU;
2044120509 // arguments for call to reportid
2044220510 stack[base + 36LLU] = stack[base + 24]/*ceid*/;
2044320511 // set stack-base & callee-address
@@ -20445,30 +20513,30 @@
2044520513 label = 18446744073709551586LLU; // reportid
2044620514 break;
2044720515 }
20448- case 1765LLU: // copy-back deleter (reportid to ProcCall)
20516+ case 1773LLU: // copy-back deleter (reportid to ProcCall)
2044920517 {
2045020518 // copy mutable arguments back from call to reportid
20451- label = 1757LLU; // continue to roll stack
20519+ label = 1765LLU; // continue to roll stack
2045220520 break;
2045320521 }
20454- case 1766LLU: // return from reportid to ProcCall
20522+ case 1774LLU: // return from reportid to ProcCall
2045520523 {
2045620524 // copy mutable arguments back from call to reportid
2045720525 fprintf(stderr, "%s", " in no-throw environment\n");
2045820526 {
20459- label = 1757LLU; // throw: begin to unroll stack
20527+ label = 1765LLU; // throw: begin to unroll stack
2046020528 break;
2046120529 }
2046220530
20463- label = 1762LLU; // alternative complete
20531+ label = 1770LLU; // alternative complete
2046420532 break;
2046520533 }
20466- case 1762LLU: // completed if-then-else
20534+ case 1770LLU: // completed if-then-else
2046720535 {
2046820536 // call add from ProcCall
20469- stack[base + 33LLU] = 1767LLU/*throw to this address*/;
20537+ stack[base + 33LLU] = 1775LLU/*throw to this address*/;
2047020538 stack[base + 34LLU] = base;
20471- stack[base + 35LLU] = 1768LLU;
20539+ stack[base + 35LLU] = 1776LLU;
2047220540 // arguments for call to add
2047320541 stack[base + 37LLU] = 1LLU;
2047420542 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -20477,56 +20545,56 @@
2047720545 label = 18446744073709551605LLU; // add
2047820546 break;
2047920547 }
20480- case 1767LLU: // copy-back deleter (add to ProcCall)
20548+ case 1775LLU: // copy-back deleter (add to ProcCall)
2048120549 {
2048220550 // copy mutable arguments back from call to add
20483- label = 1757LLU; // continue to roll stack
20551+ label = 1765LLU; // continue to roll stack
2048420552 break;
2048520553 }
20486- case 1768LLU: // return from add to ProcCall
20554+ case 1776LLU: // return from add to ProcCall
2048720555 {
2048820556 // copy mutable arguments back from call to add
2048920557 // copy back results provided by call to add
2049020558 stack[base + 17] = stack[base + 36LLU];
20491- label = 1770LLU; // skip deleter
20559+ label = 1778LLU; // skip deleter
2049220560 break;
2049320561 }
20494- case 1769LLU: // deleter
20562+ case 1777LLU: // deleter
2049520563 {
2049620564 // throw from ProcCall
2049720565 if(!stack[base + 33])
2049820566 {
20499- label = 1757LLU; // skip, variable already deleted/unscoped
20567+ label = 1765LLU; // skip, variable already deleted/unscoped
2050020568 break;
2050120569 }
20502- label = 1757LLU; // continue unrolling stack, delete next variable
20570+ label = 1765LLU; // continue unrolling stack, delete next variable
2050320571 break;
2050420572 }
20505- case 1770LLU: // skipped deleter
20573+ case 1778LLU: // skipped deleter
2050620574 {
2050720575 stack[base + 33] = stack[base + 17]/*label*/;
20508- label = 1772LLU; // skip deleter
20576+ label = 1780LLU; // skip deleter
2050920577 break;
2051020578 }
20511- case 1771LLU: // deleter
20579+ case 1779LLU: // deleter
2051220580 {
2051320581 // throw from ProcCall
2051420582 if(!stack[base + 34])
2051520583 {
20516- label = 1769LLU; // skip, variable already deleted/unscoped
20584+ label = 1777LLU; // skip, variable already deleted/unscoped
2051720585 break;
2051820586 }
20519- label = 1769LLU; // continue unrolling stack, delete next variable
20587+ label = 1777LLU; // continue unrolling stack, delete next variable
2052020588 break;
2052120589 }
20522- case 1772LLU: // skipped deleter
20590+ case 1780LLU: // skipped deleter
2052320591 {
2052420592 stack[base + 34] = 0;
2052520593 stack[base + 34]/*recsztotal*/ = 0;
2052620594 // call add from ProcCall
20527- stack[base + 35LLU] = 1773LLU/*throw to this address*/;
20595+ stack[base + 35LLU] = 1781LLU/*throw to this address*/;
2052820596 stack[base + 36LLU] = base;
20529- stack[base + 37LLU] = 1774LLU;
20597+ stack[base + 37LLU] = 1782LLU;
2053020598 // arguments for call to add
2053120599 stack[base + 39LLU] = 4LLU;
2053220600 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20535,21 +20603,21 @@
2053520603 label = 18446744073709551605LLU; // add
2053620604 break;
2053720605 }
20538- case 1773LLU: // copy-back deleter (add to ProcCall)
20606+ case 1781LLU: // copy-back deleter (add to ProcCall)
2053920607 {
2054020608 // copy mutable arguments back from call to add
20541- label = 1771LLU; // continue to roll stack
20609+ label = 1779LLU; // continue to roll stack
2054220610 break;
2054320611 }
20544- case 1774LLU: // return from add to ProcCall
20612+ case 1782LLU: // return from add to ProcCall
2054520613 {
2054620614 // copy mutable arguments back from call to add
2054720615 // copy back results provided by call to add
2054820616 stack[base + 34] = stack[base + 38LLU];
2054920617 // call add from ProcCall
20550- stack[base + 35LLU] = 1775LLU/*throw to this address*/;
20618+ stack[base + 35LLU] = 1783LLU/*throw to this address*/;
2055120619 stack[base + 36LLU] = base;
20552- stack[base + 37LLU] = 1776LLU;
20620+ stack[base + 37LLU] = 1784LLU;
2055320621 // arguments for call to add
2055420622 stack[base + 39LLU] = stack[base + 28]/*cerescount*/;
2055520623 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20558,21 +20626,21 @@
2055820626 label = 18446744073709551605LLU; // add
2055920627 break;
2056020628 }
20561- case 1775LLU: // copy-back deleter (add to ProcCall)
20629+ case 1783LLU: // copy-back deleter (add to ProcCall)
2056220630 {
2056320631 // copy mutable arguments back from call to add
20564- label = 1771LLU; // continue to roll stack
20632+ label = 1779LLU; // continue to roll stack
2056520633 break;
2056620634 }
20567- case 1776LLU: // return from add to ProcCall
20635+ case 1784LLU: // return from add to ProcCall
2056820636 {
2056920637 // copy mutable arguments back from call to add
2057020638 // copy back results provided by call to add
2057120639 stack[base + 34] = stack[base + 38LLU];
2057220640 // call add from ProcCall
20573- stack[base + 35LLU] = 1777LLU/*throw to this address*/;
20641+ stack[base + 35LLU] = 1785LLU/*throw to this address*/;
2057420642 stack[base + 36LLU] = base;
20575- stack[base + 37LLU] = 1778LLU;
20643+ stack[base + 37LLU] = 1786LLU;
2057620644 // arguments for call to add
2057720645 stack[base + 39LLU] = stack[base + 29]/*ceargcount*/;
2057820646 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20581,21 +20649,21 @@
2058120649 label = 18446744073709551605LLU; // add
2058220650 break;
2058320651 }
20584- case 1777LLU: // copy-back deleter (add to ProcCall)
20652+ case 1785LLU: // copy-back deleter (add to ProcCall)
2058520653 {
2058620654 // copy mutable arguments back from call to add
20587- label = 1771LLU; // continue to roll stack
20655+ label = 1779LLU; // continue to roll stack
2058820656 break;
2058920657 }
20590- case 1778LLU: // return from add to ProcCall
20658+ case 1786LLU: // return from add to ProcCall
2059120659 {
2059220660 // copy mutable arguments back from call to add
2059320661 // copy back results provided by call to add
2059420662 stack[base + 34] = stack[base + 38LLU];
2059520663 // call add from ProcCall
20596- stack[base + 35LLU] = 1779LLU/*throw to this address*/;
20664+ stack[base + 35LLU] = 1787LLU/*throw to this address*/;
2059720665 stack[base + 36LLU] = base;
20598- stack[base + 37LLU] = 1780LLU;
20666+ stack[base + 37LLU] = 1788LLU;
2059920667 // arguments for call to add
2060020668 stack[base + 39LLU] = stack[base + 23]/*cemaxcount*/;
2060120669 stack[base + 40LLU] = stack[base + 34]/*recsztotal*/;
@@ -20604,13 +20672,13 @@
2060420672 label = 18446744073709551605LLU; // add
2060520673 break;
2060620674 }
20607- case 1779LLU: // copy-back deleter (add to ProcCall)
20675+ case 1787LLU: // copy-back deleter (add to ProcCall)
2060820676 {
2060920677 // copy mutable arguments back from call to add
20610- label = 1771LLU; // continue to roll stack
20678+ label = 1779LLU; // continue to roll stack
2061120679 break;
2061220680 }
20613- case 1780LLU: // return from add to ProcCall
20681+ case 1788LLU: // return from add to ProcCall
2061420682 {
2061520683 // copy mutable arguments back from call to add
2061620684 // copy back results provided by call to add
@@ -20617,9 +20685,9 @@
2061720685 stack[base + 34] = stack[base + 38LLU];
2061820686 printf("%s", "\n uint64_t *newstack = (uint64_t *)Calloc(");
2061920687 // call printnr from ProcCall
20620- stack[base + 35LLU] = 1781LLU/*throw to this address*/;
20688+ stack[base + 35LLU] = 1789LLU/*throw to this address*/;
2062120689 stack[base + 36LLU] = base;
20622- stack[base + 37LLU] = 1782LLU;
20690+ stack[base + 37LLU] = 1790LLU;
2062320691 // arguments for call to printnr
2062420692 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2062520693 // set stack-base & callee-address
@@ -20627,42 +20695,42 @@
2062720695 label = 18446744073709551590LLU; // printnr
2062820696 break;
2062920697 }
20630- case 1781LLU: // copy-back deleter (printnr to ProcCall)
20698+ case 1789LLU: // copy-back deleter (printnr to ProcCall)
2063120699 {
2063220700 // copy mutable arguments back from call to printnr
20633- label = 1771LLU; // continue to roll stack
20701+ label = 1779LLU; // continue to roll stack
2063420702 break;
2063520703 }
20636- case 1782LLU: // return from printnr to ProcCall
20704+ case 1790LLU: // return from printnr to ProcCall
2063720705 {
2063820706 // copy mutable arguments back from call to printnr
2063920707 printf("%s", "LLU + 1, sizeof(uint64_t));");
2064020708 printf("%s", "\n if(!newstack)");
2064120709 // call emitthrow from ProcCall
20642- stack[base + 35LLU] = 1783LLU/*throw to this address*/;
20710+ stack[base + 35LLU] = 1791LLU/*throw to this address*/;
2064320711 stack[base + 36LLU] = base;
20644- stack[base + 37LLU] = 1784LLU;
20712+ stack[base + 37LLU] = 1792LLU;
2064520713 // arguments for call to emitthrow
2064620714 stack[base + 38LLU] = stack[base + 3]/*scope*/;
2064720715 // set stack-base & callee-address
2064820716 base += 38LLU;
20649- label = 1712LLU; // emitthrow
20717+ label = 1720LLU; // emitthrow
2065020718 break;
2065120719 }
20652- case 1783LLU: // copy-back deleter (emitthrow to ProcCall)
20720+ case 1791LLU: // copy-back deleter (emitthrow to ProcCall)
2065320721 {
2065420722 // copy mutable arguments back from call to emitthrow
20655- label = 1771LLU; // continue to roll stack
20723+ label = 1779LLU; // continue to roll stack
2065620724 break;
2065720725 }
20658- case 1784LLU: // return from emitthrow to ProcCall
20726+ case 1792LLU: // return from emitthrow to ProcCall
2065920727 {
2066020728 // copy mutable arguments back from call to emitthrow
2066120729 printf("%s", "\n newstack[");
2066220730 // call printnr from ProcCall
20663- stack[base + 35LLU] = 1785LLU/*throw to this address*/;
20731+ stack[base + 35LLU] = 1793LLU/*throw to this address*/;
2066420732 stack[base + 36LLU] = base;
20665- stack[base + 37LLU] = 1786LLU;
20733+ stack[base + 37LLU] = 1794LLU;
2066620734 // arguments for call to printnr
2066720735 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2066820736 // set stack-base & callee-address
@@ -20670,21 +20738,21 @@
2067020738 label = 18446744073709551590LLU; // printnr
2067120739 break;
2067220740 }
20673- case 1785LLU: // copy-back deleter (printnr to ProcCall)
20741+ case 1793LLU: // copy-back deleter (printnr to ProcCall)
2067420742 {
2067520743 // copy mutable arguments back from call to printnr
20676- label = 1771LLU; // continue to roll stack
20744+ label = 1779LLU; // continue to roll stack
2067720745 break;
2067820746 }
20679- case 1786LLU: // return from printnr to ProcCall
20747+ case 1794LLU: // return from printnr to ProcCall
2068020748 {
2068120749 // copy mutable arguments back from call to printnr
2068220750 printf("%s", "LLU] = 9876543210LLU; // overflow-marker");
2068320751 printf("%s", "\n // call ");
2068420752 // call printid from ProcCall
20685- stack[base + 35LLU] = 1787LLU/*throw to this address*/;
20753+ stack[base + 35LLU] = 1795LLU/*throw to this address*/;
2068620754 stack[base + 36LLU] = base;
20687- stack[base + 37LLU] = 1788LLU;
20755+ stack[base + 37LLU] = 1796LLU;
2068820756 // arguments for call to printid
2068920757 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2069020758 // set stack-base & callee-address
@@ -20692,20 +20760,20 @@
2069220760 label = 18446744073709551587LLU; // printid
2069320761 break;
2069420762 }
20695- case 1787LLU: // copy-back deleter (printid to ProcCall)
20763+ case 1795LLU: // copy-back deleter (printid to ProcCall)
2069620764 {
2069720765 // copy mutable arguments back from call to printid
20698- label = 1771LLU; // continue to roll stack
20766+ label = 1779LLU; // continue to roll stack
2069920767 break;
2070020768 }
20701- case 1788LLU: // return from printid to ProcCall
20769+ case 1796LLU: // return from printid to ProcCall
2070220770 {
2070320771 // copy mutable arguments back from call to printid
2070420772 printf("%s", " from ");
2070520773 // call printid from ProcCall
20706- stack[base + 35LLU] = 1789LLU/*throw to this address*/;
20774+ stack[base + 35LLU] = 1797LLU/*throw to this address*/;
2070720775 stack[base + 36LLU] = base;
20708- stack[base + 37LLU] = 1790LLU;
20776+ stack[base + 37LLU] = 1798LLU;
2070920777 // arguments for call to printid
2071020778 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2071120779 // set stack-base & callee-address
@@ -20713,21 +20781,21 @@
2071320781 label = 18446744073709551587LLU; // printid
2071420782 break;
2071520783 }
20716- case 1789LLU: // copy-back deleter (printid to ProcCall)
20784+ case 1797LLU: // copy-back deleter (printid to ProcCall)
2071720785 {
2071820786 // copy mutable arguments back from call to printid
20719- label = 1771LLU; // continue to roll stack
20787+ label = 1779LLU; // continue to roll stack
2072020788 break;
2072120789 }
20722- case 1790LLU: // return from printid to ProcCall
20790+ case 1798LLU: // return from printid to ProcCall
2072320791 {
2072420792 // copy mutable arguments back from call to printid
2072520793 printf("%s", "\n newstack[0] = (uint64_t)stack; // backup stack location");
2072620794 printf("%s", "\n newstack[1] = ");
2072720795 // call printnr from ProcCall
20728- stack[base + 35LLU] = 1791LLU/*throw to this address*/;
20796+ stack[base + 35LLU] = 1799LLU/*throw to this address*/;
2072920797 stack[base + 36LLU] = base;
20730- stack[base + 37LLU] = 1792LLU;
20798+ stack[base + 37LLU] = 1800LLU;
2073120799 // arguments for call to printnr
2073220800 stack[base + 38LLU] = stack[base + 33]/*labelfail*/;
2073320801 // set stack-base & callee-address
@@ -20735,21 +20803,21 @@
2073520803 label = 18446744073709551590LLU; // printnr
2073620804 break;
2073720805 }
20738- case 1791LLU: // copy-back deleter (printnr to ProcCall)
20806+ case 1799LLU: // copy-back deleter (printnr to ProcCall)
2073920807 {
2074020808 // copy mutable arguments back from call to printnr
20741- label = 1771LLU; // continue to roll stack
20809+ label = 1779LLU; // continue to roll stack
2074220810 break;
2074320811 }
20744- case 1792LLU: // return from printnr to ProcCall
20812+ case 1800LLU: // return from printnr to ProcCall
2074520813 {
2074620814 // copy mutable arguments back from call to printnr
2074720815 printf("%s", "LLU;");
2074820816 printf("%s", "\n newstack[2] = base;");
2074920817 // call add from ProcCall
20750- stack[base + 35LLU] = 1793LLU/*throw to this address*/;
20818+ stack[base + 35LLU] = 1801LLU/*throw to this address*/;
2075120819 stack[base + 36LLU] = base;
20752- stack[base + 37LLU] = 1794LLU;
20820+ stack[base + 37LLU] = 1802LLU;
2075320821 // arguments for call to add
2075420822 stack[base + 39LLU] = 1LLU;
2075520823 stack[base + 40LLU] = stack[base + 17]/*label*/;
@@ -20758,13 +20826,13 @@
2075820826 label = 18446744073709551605LLU; // add
2075920827 break;
2076020828 }
20761- case 1793LLU: // copy-back deleter (add to ProcCall)
20829+ case 1801LLU: // copy-back deleter (add to ProcCall)
2076220830 {
2076320831 // copy mutable arguments back from call to add
20764- label = 1771LLU; // continue to roll stack
20832+ label = 1779LLU; // continue to roll stack
2076520833 break;
2076620834 }
20767- case 1794LLU: // return from add to ProcCall
20835+ case 1802LLU: // return from add to ProcCall
2076820836 {
2076920837 // copy mutable arguments back from call to add
2077020838 // copy back results provided by call to add
@@ -20771,9 +20839,9 @@
2077120839 stack[base + 17] = stack[base + 38LLU];
2077220840 printf("%s", "\n newstack[3] = ");
2077320841 // call printnr from ProcCall
20774- stack[base + 35LLU] = 1795LLU/*throw to this address*/;
20842+ stack[base + 35LLU] = 1803LLU/*throw to this address*/;
2077520843 stack[base + 36LLU] = base;
20776- stack[base + 37LLU] = 1796LLU;
20844+ stack[base + 37LLU] = 1804LLU;
2077720845 // arguments for call to printnr
2077820846 stack[base + 38LLU] = stack[base + 17]/*label*/;
2077920847 // set stack-base & callee-address
@@ -20781,13 +20849,13 @@
2078120849 label = 18446744073709551590LLU; // printnr
2078220850 break;
2078320851 }
20784- case 1795LLU: // copy-back deleter (printnr to ProcCall)
20852+ case 1803LLU: // copy-back deleter (printnr to ProcCall)
2078520853 {
2078620854 // copy mutable arguments back from call to printnr
20787- label = 1771LLU; // continue to roll stack
20855+ label = 1779LLU; // continue to roll stack
2078820856 break;
2078920857 }
20790- case 1796LLU: // return from printnr to ProcCall
20858+ case 1804LLU: // return from printnr to ProcCall
2079120859 {
2079220860 // copy mutable arguments back from call to printnr
2079320861 printf("%s", "LLU;");
@@ -20794,9 +20862,9 @@
2079420862 stack[base + 31]/*n*/ = stack[base + 29]/*ceargcount*/;
2079520863 printf("%s", "\n // arguments for call to ");
2079620864 // call printid from ProcCall
20797- stack[base + 35LLU] = 1797LLU/*throw to this address*/;
20865+ stack[base + 35LLU] = 1805LLU/*throw to this address*/;
2079820866 stack[base + 36LLU] = base;
20799- stack[base + 37LLU] = 1798LLU;
20867+ stack[base + 37LLU] = 1806LLU;
2080020868 // arguments for call to printid
2080120869 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2080220870 // set stack-base & callee-address
@@ -20804,41 +20872,41 @@
2080420872 label = 18446744073709551587LLU; // printid
2080520873 break;
2080620874 }
20807- case 1797LLU: // copy-back deleter (printid to ProcCall)
20875+ case 1805LLU: // copy-back deleter (printid to ProcCall)
2080820876 {
2080920877 // copy mutable arguments back from call to printid
20810- label = 1771LLU; // continue to roll stack
20878+ label = 1779LLU; // continue to roll stack
2081120879 break;
2081220880 }
20813- case 1798LLU: // return from printid to ProcCall
20881+ case 1806LLU: // return from printid to ProcCall
2081420882 {
2081520883 // copy mutable arguments back from call to printid
20816- label = 1800LLU; // skip deleter
20884+ label = 1808LLU; // skip deleter
2081720885 break;
2081820886 }
20819- case 1799LLU: // deleter
20887+ case 1807LLU: // deleter
2082020888 {
2082120889 // throw from ProcCall
2082220890 if(!stack[base + 35])
2082320891 {
20824- label = 1771LLU; // skip, variable already deleted/unscoped
20892+ label = 1779LLU; // skip, variable already deleted/unscoped
2082520893 break;
2082620894 }
20827- label = 1771LLU; // continue unrolling stack, delete next variable
20895+ label = 1779LLU; // continue unrolling stack, delete next variable
2082820896 break;
2082920897 }
20830- case 1800LLU: // skipped deleter
20898+ case 1808LLU: // skipped deleter
2083120899 {
2083220900 stack[base + 35] = 0;
2083320901 flippedassign(stack[base + 22]/*ceargtypes*/, &stack[base + 36]);
20834- label = 1801LLU; // start to repeat
20902+ label = 1809LLU; // start to repeat
2083520903 break;
2083620904 }
20837- case 1801LLU: // repeat from here
20905+ case 1809LLU: // repeat from here
2083820906 {
2083920907 if(!stack[base + 36])
2084020908 {
20841- label = 1802LLU; // break loop
20909+ label = 1810LLU; // break loop
2084220910 break;
2084320911 }
2084420912
@@ -20847,9 +20915,9 @@
2084720915 stack[base + 38]/*previous*/ = stack[base + 36];
2084820916 stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
2084920917 // call sub from ProcCall
20850- stack[base + 39LLU] = 1804LLU/*throw to this address*/;
20918+ stack[base + 39LLU] = 1812LLU/*throw to this address*/;
2085120919 stack[base + 40LLU] = base;
20852- stack[base + 41LLU] = 1805LLU;
20920+ stack[base + 41LLU] = 1813LLU;
2085320921 // arguments for call to sub
2085420922 stack[base + 43LLU] = stack[base + 29]/*ceargcount*/;
2085520923 stack[base + 44LLU] = stack[base + 31]/*n*/;
@@ -20858,21 +20926,21 @@
2085820926 label = 18446744073709551604LLU; // sub
2085920927 break;
2086020928 }
20861- case 1804LLU: // copy-back deleter (sub to ProcCall)
20929+ case 1812LLU: // copy-back deleter (sub to ProcCall)
2086220930 {
2086320931 // copy mutable arguments back from call to sub
20864- label = 1803LLU; // continue to roll stack
20932+ label = 1811LLU; // continue to roll stack
2086520933 break;
2086620934 }
20867- case 1805LLU: // return from sub to ProcCall
20935+ case 1813LLU: // return from sub to ProcCall
2086820936 {
2086920937 // copy mutable arguments back from call to sub
2087020938 // copy back results provided by call to sub
2087120939 stack[base + 32] = stack[base + 42LLU];
2087220940 // call sub from ProcCall
20873- stack[base + 39LLU] = 1806LLU/*throw to this address*/;
20941+ stack[base + 39LLU] = 1814LLU/*throw to this address*/;
2087420942 stack[base + 40LLU] = base;
20875- stack[base + 41LLU] = 1807LLU;
20943+ stack[base + 41LLU] = 1815LLU;
2087620944 // arguments for call to sub
2087720945 stack[base + 43LLU] = stack[base + 31]/*n*/;
2087820946 stack[base + 44LLU] = 1LLU;
@@ -20881,13 +20949,13 @@
2088120949 label = 18446744073709551604LLU; // sub
2088220950 break;
2088320951 }
20884- case 1806LLU: // copy-back deleter (sub to ProcCall)
20952+ case 1814LLU: // copy-back deleter (sub to ProcCall)
2088520953 {
2088620954 // copy mutable arguments back from call to sub
20887- label = 1803LLU; // continue to roll stack
20955+ label = 1811LLU; // continue to roll stack
2088820956 break;
2088920957 }
20890- case 1807LLU: // return from sub to ProcCall
20958+ case 1815LLU: // return from sub to ProcCall
2089120959 {
2089220960 // copy mutable arguments back from call to sub
2089320961 // copy back results provided by call to sub
@@ -20894,15 +20962,15 @@
2089420962 stack[base + 31] = stack[base + 42LLU];
2089520963 if(!stack[base + 32]/*index*/)
2089620964 {
20897- label = 1808LLU; // jump to alternative
20965+ label = 1816LLU; // jump to alternative
2089820966 break;
2089920967 }
2090020968
2090120969 // consequent
2090220970 // call matchsym from ProcCall
20903- stack[base + 39LLU] = 1810LLU/*throw to this address*/;
20971+ stack[base + 39LLU] = 1818LLU/*throw to this address*/;
2090420972 stack[base + 40LLU] = base;
20905- stack[base + 41LLU] = 1811LLU;
20973+ stack[base + 41LLU] = 1819LLU;
2090620974 // arguments for call to matchsym
2090720975 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2090820976 stack[base + 43LLU] = 44LLU;
@@ -20912,32 +20980,32 @@
2091220980 label = 246LLU; // matchsym
2091320981 break;
2091420982 }
20915- case 1810LLU: // copy-back deleter (matchsym to ProcCall)
20983+ case 1818LLU: // copy-back deleter (matchsym to ProcCall)
2091620984 {
2091720985 // copy mutable arguments back from call to matchsym
2091820986 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
20919- label = 1803LLU; // continue to roll stack
20987+ label = 1811LLU; // continue to roll stack
2092020988 break;
2092120989 }
20922- case 1811LLU: // return from matchsym to ProcCall
20990+ case 1819LLU: // return from matchsym to ProcCall
2092320991 {
2092420992 // copy mutable arguments back from call to matchsym
2092520993 stack[base + 14]/*lookahead*/ = stack[base + 44LLU];
20926- label = 1809LLU; // consequent complete
20994+ label = 1817LLU; // consequent complete
2092720995 break;
2092820996 }
20929- case 1808LLU: // alternative
20997+ case 1816LLU: // alternative
2093020998 {
20931- label = 1809LLU; // alternative complete
20999+ label = 1817LLU; // alternative complete
2093221000 break;
2093321001 }
20934- case 1809LLU: // completed if-then-else
21002+ case 1817LLU: // completed if-then-else
2093521003 {
2093621004 stack[base + 30]/*sum*/ = 0;
2093721005 // call add from ProcCall
20938- stack[base + 39LLU] = 1812LLU/*throw to this address*/;
21006+ stack[base + 39LLU] = 1820LLU/*throw to this address*/;
2093921007 stack[base + 40LLU] = base;
20940- stack[base + 41LLU] = 1813LLU;
21008+ stack[base + 41LLU] = 1821LLU;
2094121009 // arguments for call to add
2094221010 stack[base + 43LLU] = 4LLU;
2094321011 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -20946,21 +21014,21 @@
2094621014 label = 18446744073709551605LLU; // add
2094721015 break;
2094821016 }
20949- case 1812LLU: // copy-back deleter (add to ProcCall)
21017+ case 1820LLU: // copy-back deleter (add to ProcCall)
2095021018 {
2095121019 // copy mutable arguments back from call to add
20952- label = 1803LLU; // continue to roll stack
21020+ label = 1811LLU; // continue to roll stack
2095321021 break;
2095421022 }
20955- case 1813LLU: // return from add to ProcCall
21023+ case 1821LLU: // return from add to ProcCall
2095621024 {
2095721025 // copy mutable arguments back from call to add
2095821026 // copy back results provided by call to add
2095921027 stack[base + 30] = stack[base + 42LLU];
2096021028 // call add from ProcCall
20961- stack[base + 39LLU] = 1814LLU/*throw to this address*/;
21029+ stack[base + 39LLU] = 1822LLU/*throw to this address*/;
2096221030 stack[base + 40LLU] = base;
20963- stack[base + 41LLU] = 1815LLU;
21031+ stack[base + 41LLU] = 1823LLU;
2096421032 // arguments for call to add
2096521033 stack[base + 43LLU] = stack[base + 28]/*cerescount*/;
2096621034 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -20969,21 +21037,21 @@
2096921037 label = 18446744073709551605LLU; // add
2097021038 break;
2097121039 }
20972- case 1814LLU: // copy-back deleter (add to ProcCall)
21040+ case 1822LLU: // copy-back deleter (add to ProcCall)
2097321041 {
2097421042 // copy mutable arguments back from call to add
20975- label = 1803LLU; // continue to roll stack
21043+ label = 1811LLU; // continue to roll stack
2097621044 break;
2097721045 }
20978- case 1815LLU: // return from add to ProcCall
21046+ case 1823LLU: // return from add to ProcCall
2097921047 {
2098021048 // copy mutable arguments back from call to add
2098121049 // copy back results provided by call to add
2098221050 stack[base + 30] = stack[base + 42LLU];
2098321051 // call add from ProcCall
20984- stack[base + 39LLU] = 1816LLU/*throw to this address*/;
21052+ stack[base + 39LLU] = 1824LLU/*throw to this address*/;
2098521053 stack[base + 40LLU] = base;
20986- stack[base + 41LLU] = 1817LLU;
21054+ stack[base + 41LLU] = 1825LLU;
2098721055 // arguments for call to add
2098821056 stack[base + 43LLU] = stack[base + 32]/*index*/;
2098921057 stack[base + 44LLU] = stack[base + 30]/*sum*/;
@@ -20992,13 +21060,13 @@
2099221060 label = 18446744073709551605LLU; // add
2099321061 break;
2099421062 }
20995- case 1816LLU: // copy-back deleter (add to ProcCall)
21063+ case 1824LLU: // copy-back deleter (add to ProcCall)
2099621064 {
2099721065 // copy mutable arguments back from call to add
20998- label = 1803LLU; // continue to roll stack
21066+ label = 1811LLU; // continue to roll stack
2099921067 break;
2100021068 }
21001- case 1817LLU: // return from add to ProcCall
21069+ case 1825LLU: // return from add to ProcCall
2100221070 {
2100321071 // copy mutable arguments back from call to add
2100421072 // copy back results provided by call to add
@@ -21005,7 +21073,7 @@
2100521073 stack[base + 30] = stack[base + 42LLU];
2100621074 if(/*param*/0 != ((uint64_t *)(stack[base + 37]/*param*/))[0])
2100721075 {
21008- label = 1819LLU; // jump to alternative
21076+ label = 1827LLU; // jump to alternative
2100921077 break;
2101021078 }
2101121079
@@ -21015,7 +21083,7 @@
2101521083 // case
2101621084 if(/*typeid*/0 != ((uint64_t *)(stack[base + 39]/*typeid*/))[0])
2101721085 {
21018- label = 1822LLU; // jump to alternative
21086+ label = 1830LLU; // jump to alternative
2101921087 break;
2102021088 }
2102121089
@@ -21024,9 +21092,9 @@
2102421092
2102521093 // case
2102621094 // call ParseToken from ProcCall
21027- stack[base + 43LLU] = 1824LLU/*throw to this address*/;
21095+ stack[base + 43LLU] = 1832LLU/*throw to this address*/;
2102821096 stack[base + 44LLU] = base;
21029- stack[base + 45LLU] = 1825LLU;
21097+ stack[base + 45LLU] = 1833LLU;
2103021098 // arguments for call to ParseToken
2103121099 stack[base + 48LLU] = stack[base + 14]/*lookahead*/;
2103221100 // set stack-base & callee-address
@@ -21034,14 +21102,14 @@
2103421102 label = 3LLU; // ParseToken
2103521103 break;
2103621104 }
21037- case 1824LLU: // copy-back deleter (ParseToken to ProcCall)
21105+ case 1832LLU: // copy-back deleter (ParseToken to ProcCall)
2103821106 {
2103921107 // copy mutable arguments back from call to ParseToken
2104021108 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21041- label = 1823LLU; // continue to roll stack
21109+ label = 1831LLU; // continue to roll stack
2104221110 break;
2104321111 }
21044- case 1825LLU: // return from ParseToken to ProcCall
21112+ case 1833LLU: // return from ParseToken to ProcCall
2104521113 {
2104621114 // copy mutable arguments back from call to ParseToken
2104721115 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
@@ -21049,9 +21117,9 @@
2104921117 stack[base + 15] = stack[base + 46LLU];
2105021118 stack[base + 16] = stack[base + 47LLU];
2105121119 // call isncs from ProcCall
21052- stack[base + 43LLU] = 1826LLU/*throw to this address*/;
21120+ stack[base + 43LLU] = 1834LLU/*throw to this address*/;
2105321121 stack[base + 44LLU] = base;
21054- stack[base + 45LLU] = 1827LLU;
21122+ stack[base + 45LLU] = 1835LLU;
2105521123 // arguments for call to isncs
2105621124 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2105721125 // set stack-base & callee-address
@@ -21059,13 +21127,13 @@
2105921127 label = 286LLU; // isncs
2106021128 break;
2106121129 }
21062- case 1826LLU: // copy-back deleter (isncs to ProcCall)
21130+ case 1834LLU: // copy-back deleter (isncs to ProcCall)
2106321131 {
2106421132 // copy mutable arguments back from call to isncs
21065- label = 1823LLU; // continue to roll stack
21133+ label = 1831LLU; // continue to roll stack
2106621134 break;
2106721135 }
21068- case 1827LLU: // return from isncs to ProcCall
21136+ case 1835LLU: // return from isncs to ProcCall
2106921137 {
2107021138 // copy mutable arguments back from call to isncs
2107121139 // copy back results provided by call to isncs
@@ -21072,20 +21140,20 @@
2107221140 stack[base + 18] = stack[base + 46LLU];
2107321141 if(!stack[base + 18]/*isequal*/)
2107421142 {
21075- label = 1828LLU; // jump to alternative
21143+ label = 1836LLU; // jump to alternative
2107621144 break;
2107721145 }
2107821146
2107921147 // consequent
21080- label = 1831LLU; // skip deleter
21148+ label = 1839LLU; // skip deleter
2108121149 break;
2108221150 }
21083- case 1830LLU: // deleter
21151+ case 1838LLU: // deleter
2108421152 {
2108521153 // throw from ProcCall
2108621154 if(!stack[base + 43])
2108721155 {
21088- label = 1823LLU; // skip, variable already deleted/unscoped
21156+ label = 1831LLU; // skip, variable already deleted/unscoped
2108921157 break;
2109021158 }
2109121159
@@ -21094,7 +21162,7 @@
2109421162 newstack[0] = (uint64_t)stack; // backup stack location
2109521163 newstack[1] = 1234567890;
2109621164 newstack[2] = base;
21097- newstack[3] = 1832LLU;
21165+ newstack[3] = 1840LLU;
2109821166 stack = newstack;
2109921167 // set stack-base & callee-address
2110021168 base = 4/*deloffset*/;
@@ -21101,21 +21169,21 @@
2110121169 label = 310LLU; // ~type
2110221170 break;
2110321171 }
21104- case 1832LLU: // return from ~type to ProcCall
21172+ case 1840LLU: // return from ~type to ProcCall
2110521173 {
2110621174 stack = (uint64_t *)stack[0];
2110721175 // releasing toplevel container
2110821176 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2110921177
21110- label = 1823LLU; // continue unrolling stack, delete next variable
21178+ label = 1831LLU; // continue unrolling stack, delete next variable
2111121179 break;
2111221180 }
21113- case 1831LLU: // skipped deleter
21181+ case 1839LLU: // skipped deleter
2111421182 {
2111521183 // call mktypedata from ProcCall
21116- stack[base + 44LLU] = 1833LLU/*throw to this address*/;
21184+ stack[base + 44LLU] = 1841LLU/*throw to this address*/;
2111721185 stack[base + 45LLU] = base;
21118- stack[base + 46LLU] = 1834LLU;
21186+ stack[base + 46LLU] = 1842LLU;
2111921187 // arguments for call to mktypedata
2112021188 stack[base + 48LLU] = 881834713755418624LLU;
2112121189 // set stack-base & callee-address
@@ -21123,13 +21191,13 @@
2112321191 label = 314LLU; // mktypedata
2112421192 break;
2112521193 }
21126- case 1833LLU: // copy-back deleter (mktypedata to ProcCall)
21194+ case 1841LLU: // copy-back deleter (mktypedata to ProcCall)
2112721195 {
2112821196 // copy mutable arguments back from call to mktypedata
21129- label = 1823LLU; // continue to roll stack
21197+ label = 1831LLU; // continue to roll stack
2113021198 break;
2113121199 }
21132- case 1834LLU: // return from mktypedata to ProcCall
21200+ case 1842LLU: // return from mktypedata to ProcCall
2113321201 {
2113421202 // copy mutable arguments back from call to mktypedata
2113521203 // copy back results provided by call to mktypedata
@@ -21137,7 +21205,7 @@
2113721205 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2113821206 if(!newstack)
2113921207 {
21140- label = 1830LLU; // throw: begin to unroll stack
21208+ label = 1838LLU; // throw: begin to unroll stack
2114121209 break;
2114221210 }
2114321211
@@ -21144,9 +21212,9 @@
2114421212 newstack[15LLU] = 9876543210LLU; // overflow-marker
2114521213 // call equtype from ProcCall
2114621214 newstack[0] = (uint64_t)stack; // backup stack location
21147- newstack[1] = 1835LLU;
21215+ newstack[1] = 1843LLU;
2114821216 newstack[2] = base;
21149- newstack[3] = 1836LLU;
21217+ newstack[3] = 1844LLU;
2115021218 // arguments for call to equtype
2115121219 newstack[5LLU] = stack[base + 43]/*type*/;
2115221220 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -21156,7 +21224,7 @@
2115621224 label = 359LLU; // equtype
2115721225 break;
2115821226 }
21159- case 1835LLU: // copy-back deleter (equtype to ProcCall)
21227+ case 1843LLU: // copy-back deleter (equtype to ProcCall)
2116021228 {
2116121229 uint64_t *oldstack = (uint64_t *)stack[0];
2116221230 // copy mutable arguments back from call to equtype
@@ -21167,10 +21235,10 @@
2116721235 }
2116821236 Free(15LLU + 1, sizeof(uint64_t), stack);
2116921237 stack = oldstack;
21170- label = 1830LLU; // continue to unroll stack
21238+ label = 1838LLU; // continue to unroll stack
2117121239 break;
2117221240 }
21173- case 1836LLU: // return from equtype to ProcCall
21241+ case 1844LLU: // return from equtype to ProcCall
2117421242 {
2117521243 uint64_t *oldstack = (uint64_t *)stack[0];
2117621244 // copy mutable arguments back from call to equtype
@@ -21185,21 +21253,21 @@
2118521253 stack = oldstack;
2118621254 if(!stack[base + 18]/*isequal*/)
2118721255 {
21188- label = 1837LLU; // jump to alternative
21256+ label = 1845LLU; // jump to alternative
2118921257 break;
2119021258 }
2119121259
2119221260 // consequent
21193- label = 1838LLU; // consequent complete
21261+ label = 1846LLU; // consequent complete
2119421262 break;
2119521263 }
21196- case 1837LLU: // alternative
21264+ case 1845LLU: // alternative
2119721265 {
2119821266 fprintf(stderr, "%s", "in function ");
2119921267 // call reportid from ProcCall
21200- stack[base + 44LLU] = 1839LLU/*throw to this address*/;
21268+ stack[base + 44LLU] = 1847LLU/*throw to this address*/;
2120121269 stack[base + 45LLU] = base;
21202- stack[base + 46LLU] = 1840LLU;
21270+ stack[base + 46LLU] = 1848LLU;
2120321271 // arguments for call to reportid
2120421272 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2120521273 // set stack-base & callee-address
@@ -21207,20 +21275,20 @@
2120721275 label = 18446744073709551586LLU; // reportid
2120821276 break;
2120921277 }
21210- case 1839LLU: // copy-back deleter (reportid to ProcCall)
21278+ case 1847LLU: // copy-back deleter (reportid to ProcCall)
2121121279 {
2121221280 // copy mutable arguments back from call to reportid
21213- label = 1830LLU; // continue to roll stack
21281+ label = 1838LLU; // continue to roll stack
2121421282 break;
2121521283 }
21216- case 1840LLU: // return from reportid to ProcCall
21284+ case 1848LLU: // return from reportid to ProcCall
2121721285 {
2121821286 // copy mutable arguments back from call to reportid
2121921287 fprintf(stderr, "%s", " call to ");
2122021288 // call reportid from ProcCall
21221- stack[base + 44LLU] = 1841LLU/*throw to this address*/;
21289+ stack[base + 44LLU] = 1849LLU/*throw to this address*/;
2122221290 stack[base + 45LLU] = base;
21223- stack[base + 46LLU] = 1842LLU;
21291+ stack[base + 46LLU] = 1850LLU;
2122421292 // arguments for call to reportid
2122521293 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2122621294 // set stack-base & callee-address
@@ -21228,20 +21296,20 @@
2122821296 label = 18446744073709551586LLU; // reportid
2122921297 break;
2123021298 }
21231- case 1841LLU: // copy-back deleter (reportid to ProcCall)
21299+ case 1849LLU: // copy-back deleter (reportid to ProcCall)
2123221300 {
2123321301 // copy mutable arguments back from call to reportid
21234- label = 1830LLU; // continue to roll stack
21302+ label = 1838LLU; // continue to roll stack
2123521303 break;
2123621304 }
21237- case 1842LLU: // return from reportid to ProcCall
21305+ case 1850LLU: // return from reportid to ProcCall
2123821306 {
2123921307 // copy mutable arguments back from call to reportid
2124021308 fprintf(stderr, "%s", " at position ");
2124121309 // call reportnr from ProcCall
21242- stack[base + 44LLU] = 1843LLU/*throw to this address*/;
21310+ stack[base + 44LLU] = 1851LLU/*throw to this address*/;
2124321311 stack[base + 45LLU] = base;
21244- stack[base + 46LLU] = 1844LLU;
21312+ stack[base + 46LLU] = 1852LLU;
2124521313 // arguments for call to reportnr
2124621314 stack[base + 47LLU] = stack[base + 32]/*index*/;
2124721315 // set stack-base & callee-address
@@ -21249,13 +21317,13 @@
2124921317 label = 18446744073709551589LLU; // reportnr
2125021318 break;
2125121319 }
21252- case 1843LLU: // copy-back deleter (reportnr to ProcCall)
21320+ case 1851LLU: // copy-back deleter (reportnr to ProcCall)
2125321321 {
2125421322 // copy mutable arguments back from call to reportnr
21255- label = 1830LLU; // continue to roll stack
21323+ label = 1838LLU; // continue to roll stack
2125621324 break;
2125721325 }
21258- case 1844LLU: // return from reportnr to ProcCall
21326+ case 1852LLU: // return from reportnr to ProcCall
2125921327 {
2126021328 // copy mutable arguments back from call to reportnr
2126121329 fprintf(stderr, "%s", " expected parameter of type ");
@@ -21262,7 +21330,7 @@
2126221330 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2126321331 if(!newstack)
2126421332 {
21265- label = 1830LLU; // throw: begin to unroll stack
21333+ label = 1838LLU; // throw: begin to unroll stack
2126621334 break;
2126721335 }
2126821336
@@ -21269,9 +21337,9 @@
2126921337 newstack[10LLU] = 9876543210LLU; // overflow-marker
2127021338 // call reporttype from ProcCall
2127121339 newstack[0] = (uint64_t)stack; // backup stack location
21272- newstack[1] = 1845LLU;
21340+ newstack[1] = 1853LLU;
2127321341 newstack[2] = base;
21274- newstack[3] = 1846LLU;
21342+ newstack[3] = 1854LLU;
2127521343 // arguments for call to reporttype
2127621344 newstack[4LLU] = stack[base + 41]/*expected*/;
2127721345 stack = newstack;
@@ -21280,7 +21348,7 @@
2128021348 label = 330LLU; // reporttype
2128121349 break;
2128221350 }
21283- case 1845LLU: // copy-back deleter (reporttype to ProcCall)
21351+ case 1853LLU: // copy-back deleter (reporttype to ProcCall)
2128421352 {
2128521353 uint64_t *oldstack = (uint64_t *)stack[0];
2128621354 // copy mutable arguments back from call to reporttype
@@ -21291,10 +21359,10 @@
2129121359 }
2129221360 Free(10LLU + 1, sizeof(uint64_t), stack);
2129321361 stack = oldstack;
21294- label = 1830LLU; // continue to unroll stack
21362+ label = 1838LLU; // continue to unroll stack
2129521363 break;
2129621364 }
21297- case 1846LLU: // return from reporttype to ProcCall
21365+ case 1854LLU: // return from reporttype to ProcCall
2129821366 {
2129921367 uint64_t *oldstack = (uint64_t *)stack[0];
2130021368 // copy mutable arguments back from call to reporttype
@@ -21308,18 +21376,18 @@
2130821376 fprintf(stderr, "%s", " but found constant-argument of type u64");
2130921377 fprintf(stderr, "%s", "\n");
2131021378 {
21311- label = 1830LLU; // throw: begin to unroll stack
21379+ label = 1838LLU; // throw: begin to unroll stack
2131221380 break;
2131321381 }
2131421382
21315- label = 1838LLU; // alternative complete
21383+ label = 1846LLU; // alternative complete
2131621384 break;
2131721385 }
21318- case 1838LLU: // completed if-then-else
21386+ case 1846LLU: // completed if-then-else
2131921387 {
2132021388 if(!stack[base + 40]/*mutable*/)
2132121389 {
21322- label = 1847LLU; // jump to alternative
21390+ label = 1855LLU; // jump to alternative
2132321391 break;
2132421392 }
2132521393
@@ -21326,9 +21394,9 @@
2132621394 // consequent
2132721395 fprintf(stderr, "%s", "in function ");
2132821396 // call reportid from ProcCall
21329- stack[base + 44LLU] = 1849LLU/*throw to this address*/;
21397+ stack[base + 44LLU] = 1857LLU/*throw to this address*/;
2133021398 stack[base + 45LLU] = base;
21331- stack[base + 46LLU] = 1850LLU;
21399+ stack[base + 46LLU] = 1858LLU;
2133221400 // arguments for call to reportid
2133321401 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2133421402 // set stack-base & callee-address
@@ -21336,20 +21404,20 @@
2133621404 label = 18446744073709551586LLU; // reportid
2133721405 break;
2133821406 }
21339- case 1849LLU: // copy-back deleter (reportid to ProcCall)
21407+ case 1857LLU: // copy-back deleter (reportid to ProcCall)
2134021408 {
2134121409 // copy mutable arguments back from call to reportid
21342- label = 1830LLU; // continue to roll stack
21410+ label = 1838LLU; // continue to roll stack
2134321411 break;
2134421412 }
21345- case 1850LLU: // return from reportid to ProcCall
21413+ case 1858LLU: // return from reportid to ProcCall
2134621414 {
2134721415 // copy mutable arguments back from call to reportid
2134821416 fprintf(stderr, "%s", ", calling ");
2134921417 // call reportid from ProcCall
21350- stack[base + 44LLU] = 1851LLU/*throw to this address*/;
21418+ stack[base + 44LLU] = 1859LLU/*throw to this address*/;
2135121419 stack[base + 45LLU] = base;
21352- stack[base + 46LLU] = 1852LLU;
21420+ stack[base + 46LLU] = 1860LLU;
2135321421 // arguments for call to reportid
2135421422 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2135521423 // set stack-base & callee-address
@@ -21357,21 +21425,21 @@
2135721425 label = 18446744073709551586LLU; // reportid
2135821426 break;
2135921427 }
21360- case 1851LLU: // copy-back deleter (reportid to ProcCall)
21428+ case 1859LLU: // copy-back deleter (reportid to ProcCall)
2136121429 {
2136221430 // copy mutable arguments back from call to reportid
21363- label = 1830LLU; // continue to roll stack
21431+ label = 1838LLU; // continue to roll stack
2136421432 break;
2136521433 }
21366- case 1852LLU: // return from reportid to ProcCall
21434+ case 1860LLU: // return from reportid to ProcCall
2136721435 {
2136821436 // copy mutable arguments back from call to reportid
2136921437 fprintf(stderr, "%s", ": ");
2137021438 fprintf(stderr, "%s", "can't use constant argument ");
2137121439 // call printnr from ProcCall
21372- stack[base + 44LLU] = 1853LLU/*throw to this address*/;
21440+ stack[base + 44LLU] = 1861LLU/*throw to this address*/;
2137321441 stack[base + 45LLU] = base;
21374- stack[base + 46LLU] = 1854LLU;
21442+ stack[base + 46LLU] = 1862LLU;
2137521443 // arguments for call to printnr
2137621444 stack[base + 47LLU] = stack[base + 16]/*content*/;
2137721445 // set stack-base & callee-address
@@ -21379,20 +21447,20 @@
2137921447 label = 18446744073709551590LLU; // printnr
2138021448 break;
2138121449 }
21382- case 1853LLU: // copy-back deleter (printnr to ProcCall)
21450+ case 1861LLU: // copy-back deleter (printnr to ProcCall)
2138321451 {
2138421452 // copy mutable arguments back from call to printnr
21385- label = 1830LLU; // continue to roll stack
21453+ label = 1838LLU; // continue to roll stack
2138621454 break;
2138721455 }
21388- case 1854LLU: // return from printnr to ProcCall
21456+ case 1862LLU: // return from printnr to ProcCall
2138921457 {
2139021458 // copy mutable arguments back from call to printnr
2139121459 printf("%s", " for mutable parameter ");
2139221460 // call reportti from ProcCall
21393- stack[base + 44LLU] = 1855LLU/*throw to this address*/;
21461+ stack[base + 44LLU] = 1863LLU/*throw to this address*/;
2139421462 stack[base + 45LLU] = base;
21395- stack[base + 46LLU] = 1856LLU;
21463+ stack[base + 46LLU] = 1864LLU;
2139621464 // arguments for call to reportti
2139721465 stack[base + 47LLU] = stack[base + 39]/*typeid*/;
2139821466 // set stack-base & callee-address
@@ -21400,36 +21468,36 @@
2140021468 label = 390LLU; // reportti
2140121469 break;
2140221470 }
21403- case 1855LLU: // copy-back deleter (reportti to ProcCall)
21471+ case 1863LLU: // copy-back deleter (reportti to ProcCall)
2140421472 {
2140521473 // copy mutable arguments back from call to reportti
21406- label = 1830LLU; // continue to roll stack
21474+ label = 1838LLU; // continue to roll stack
2140721475 break;
2140821476 }
21409- case 1856LLU: // return from reportti to ProcCall
21477+ case 1864LLU: // return from reportti to ProcCall
2141021478 {
2141121479 // copy mutable arguments back from call to reportti
2141221480 fprintf(stderr, "%s", "\n");
2141321481 {
21414- label = 1830LLU; // throw: begin to unroll stack
21482+ label = 1838LLU; // throw: begin to unroll stack
2141521483 break;
2141621484 }
2141721485
21418- label = 1848LLU; // consequent complete
21486+ label = 1856LLU; // consequent complete
2141921487 break;
2142021488 }
21421- case 1847LLU: // alternative
21489+ case 1855LLU: // alternative
2142221490 {
21423- label = 1848LLU; // alternative complete
21491+ label = 1856LLU; // alternative complete
2142421492 break;
2142521493 }
21426- case 1848LLU: // completed if-then-else
21494+ case 1856LLU: // completed if-then-else
2142721495 {
2142821496 printf("%s", "\n newstack[");
2142921497 // call printnr from ProcCall
21430- stack[base + 44LLU] = 1857LLU/*throw to this address*/;
21498+ stack[base + 44LLU] = 1865LLU/*throw to this address*/;
2143121499 stack[base + 45LLU] = base;
21432- stack[base + 46LLU] = 1858LLU;
21500+ stack[base + 46LLU] = 1866LLU;
2143321501 // arguments for call to printnr
2143421502 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2143521503 // set stack-base & callee-address
@@ -21437,20 +21505,20 @@
2143721505 label = 18446744073709551590LLU; // printnr
2143821506 break;
2143921507 }
21440- case 1857LLU: // copy-back deleter (printnr to ProcCall)
21508+ case 1865LLU: // copy-back deleter (printnr to ProcCall)
2144121509 {
2144221510 // copy mutable arguments back from call to printnr
21443- label = 1830LLU; // continue to roll stack
21511+ label = 1838LLU; // continue to roll stack
2144421512 break;
2144521513 }
21446- case 1858LLU: // return from printnr to ProcCall
21514+ case 1866LLU: // return from printnr to ProcCall
2144721515 {
2144821516 // copy mutable arguments back from call to printnr
2144921517 printf("%s", "LLU] = ");
2145021518 // call printnr from ProcCall
21451- stack[base + 44LLU] = 1859LLU/*throw to this address*/;
21519+ stack[base + 44LLU] = 1867LLU/*throw to this address*/;
2145221520 stack[base + 45LLU] = base;
21453- stack[base + 46LLU] = 1860LLU;
21521+ stack[base + 46LLU] = 1868LLU;
2145421522 // arguments for call to printnr
2145521523 stack[base + 47LLU] = stack[base + 16]/*content*/;
2145621524 // set stack-base & callee-address
@@ -21458,20 +21526,20 @@
2145821526 label = 18446744073709551590LLU; // printnr
2145921527 break;
2146021528 }
21461- case 1859LLU: // copy-back deleter (printnr to ProcCall)
21529+ case 1867LLU: // copy-back deleter (printnr to ProcCall)
2146221530 {
2146321531 // copy mutable arguments back from call to printnr
21464- label = 1830LLU; // continue to roll stack
21532+ label = 1838LLU; // continue to roll stack
2146521533 break;
2146621534 }
21467- case 1860LLU: // return from printnr to ProcCall
21535+ case 1868LLU: // return from printnr to ProcCall
2146821536 {
2146921537 // copy mutable arguments back from call to printnr
2147021538 printf("%s", "LLU; // ");
2147121539 // call printid from ProcCall
21472- stack[base + 44LLU] = 1861LLU/*throw to this address*/;
21540+ stack[base + 44LLU] = 1869LLU/*throw to this address*/;
2147321541 stack[base + 45LLU] = base;
21474- stack[base + 46LLU] = 1862LLU;
21542+ stack[base + 46LLU] = 1870LLU;
2147521543 // arguments for call to printid
2147621544 stack[base + 47LLU] = stack[base + 16]/*content*/;
2147721545 // set stack-base & callee-address
@@ -21479,13 +21547,13 @@
2147921547 label = 18446744073709551587LLU; // printid
2148021548 break;
2148121549 }
21482- case 1861LLU: // copy-back deleter (printid to ProcCall)
21550+ case 1869LLU: // copy-back deleter (printid to ProcCall)
2148321551 {
2148421552 // copy mutable arguments back from call to printid
21485- label = 1830LLU; // continue to roll stack
21553+ label = 1838LLU; // continue to roll stack
2148621554 break;
2148721555 }
21488- case 1862LLU: // return from printid to ProcCall
21556+ case 1870LLU: // return from printid to ProcCall
2148921557 {
2149021558 // copy mutable arguments back from call to printid
2149121559
@@ -21494,7 +21562,7 @@
2149421562 newstack[0] = (uint64_t)stack; // backup stack location
2149521563 newstack[1] = 1234567890;
2149621564 newstack[2] = base;
21497- newstack[3] = 1863LLU;
21565+ newstack[3] = 1871LLU;
2149821566 stack = newstack;
2149921567 // set stack-base & callee-address
2150021568 base = 4/*deloffset*/;
@@ -21501,21 +21569,21 @@
2150121569 label = 310LLU; // ~type
2150221570 break;
2150321571 }
21504- case 1863LLU: // return from ~type to ProcCall
21572+ case 1871LLU: // return from ~type to ProcCall
2150521573 {
2150621574 stack = (uint64_t *)stack[0];
2150721575 // releasing toplevel container
2150821576 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2150921577
21510- label = 1829LLU; // consequent complete
21578+ label = 1837LLU; // consequent complete
2151121579 break;
2151221580 }
21513- case 1828LLU: // alternative
21581+ case 1836LLU: // alternative
2151421582 {
2151521583 // call equ from ProcCall
21516- stack[base + 43LLU] = 1864LLU/*throw to this address*/;
21584+ stack[base + 43LLU] = 1872LLU/*throw to this address*/;
2151721585 stack[base + 44LLU] = base;
21518- stack[base + 45LLU] = 1865LLU;
21586+ stack[base + 45LLU] = 1873LLU;
2151921587 // arguments for call to equ
2152021588 stack[base + 47LLU] = stack[base + 15]/*variant*/;
2152121589 stack[base + 48LLU] = 4LLU;
@@ -21524,13 +21592,13 @@
2152421592 label = 18446744073709551600LLU; // equ
2152521593 break;
2152621594 }
21527- case 1864LLU: // copy-back deleter (equ to ProcCall)
21595+ case 1872LLU: // copy-back deleter (equ to ProcCall)
2152821596 {
2152921597 // copy mutable arguments back from call to equ
21530- label = 1823LLU; // continue to roll stack
21598+ label = 1831LLU; // continue to roll stack
2153121599 break;
2153221600 }
21533- case 1865LLU: // return from equ to ProcCall
21601+ case 1873LLU: // return from equ to ProcCall
2153421602 {
2153521603 // copy mutable arguments back from call to equ
2153621604 // copy back results provided by call to equ
@@ -21537,15 +21605,15 @@
2153721605 stack[base + 18] = stack[base + 46LLU];
2153821606 if(!stack[base + 18]/*isequal*/)
2153921607 {
21540- label = 1866LLU; // jump to alternative
21608+ label = 1874LLU; // jump to alternative
2154121609 break;
2154221610 }
2154321611
2154421612 // consequent
2154521613 // call equ from ProcCall
21546- stack[base + 43LLU] = 1868LLU/*throw to this address*/;
21614+ stack[base + 43LLU] = 1876LLU/*throw to this address*/;
2154721615 stack[base + 44LLU] = base;
21548- stack[base + 45LLU] = 1869LLU;
21616+ stack[base + 45LLU] = 1877LLU;
2154921617 // arguments for call to equ
2155021618 stack[base + 47LLU] = stack[base + 16]/*content*/;
2155121619 stack[base + 48LLU] = 621705506259468288LLU;
@@ -21554,13 +21622,13 @@
2155421622 label = 18446744073709551600LLU; // equ
2155521623 break;
2155621624 }
21557- case 1868LLU: // copy-back deleter (equ to ProcCall)
21625+ case 1876LLU: // copy-back deleter (equ to ProcCall)
2155821626 {
2155921627 // copy mutable arguments back from call to equ
21560- label = 1823LLU; // continue to roll stack
21628+ label = 1831LLU; // continue to roll stack
2156121629 break;
2156221630 }
21563- case 1869LLU: // return from equ to ProcCall
21631+ case 1877LLU: // return from equ to ProcCall
2156421632 {
2156521633 // copy mutable arguments back from call to equ
2156621634 // copy back results provided by call to equ
@@ -21567,15 +21635,15 @@
2156721635 stack[base + 18] = stack[base + 46LLU];
2156821636 if(!stack[base + 18]/*isequal*/)
2156921637 {
21570- label = 1870LLU; // jump to alternative
21638+ label = 1878LLU; // jump to alternative
2157121639 break;
2157221640 }
2157321641
2157421642 // consequent
2157521643 // call matchsym from ProcCall
21576- stack[base + 43LLU] = 1872LLU/*throw to this address*/;
21644+ stack[base + 43LLU] = 1880LLU/*throw to this address*/;
2157721645 stack[base + 44LLU] = base;
21578- stack[base + 45LLU] = 1873LLU;
21646+ stack[base + 45LLU] = 1881LLU;
2157921647 // arguments for call to matchsym
2158021648 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2158121649 stack[base + 47LLU] = 40LLU;
@@ -21585,21 +21653,21 @@
2158521653 label = 246LLU; // matchsym
2158621654 break;
2158721655 }
21588- case 1872LLU: // copy-back deleter (matchsym to ProcCall)
21656+ case 1880LLU: // copy-back deleter (matchsym to ProcCall)
2158921657 {
2159021658 // copy mutable arguments back from call to matchsym
2159121659 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21592- label = 1823LLU; // continue to roll stack
21660+ label = 1831LLU; // continue to roll stack
2159321661 break;
2159421662 }
21595- case 1873LLU: // return from matchsym to ProcCall
21663+ case 1881LLU: // return from matchsym to ProcCall
2159621664 {
2159721665 // copy mutable arguments back from call to matchsym
2159821666 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2159921667 // call matchsym from ProcCall
21600- stack[base + 43LLU] = 1874LLU/*throw to this address*/;
21668+ stack[base + 43LLU] = 1882LLU/*throw to this address*/;
2160121669 stack[base + 44LLU] = base;
21602- stack[base + 45LLU] = 1875LLU;
21670+ stack[base + 45LLU] = 1883LLU;
2160321671 // arguments for call to matchsym
2160421672 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2160521673 stack[base + 47LLU] = 41LLU;
@@ -21609,20 +21677,20 @@
2160921677 label = 246LLU; // matchsym
2161021678 break;
2161121679 }
21612- case 1874LLU: // copy-back deleter (matchsym to ProcCall)
21680+ case 1882LLU: // copy-back deleter (matchsym to ProcCall)
2161321681 {
2161421682 // copy mutable arguments back from call to matchsym
2161521683 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
21616- label = 1823LLU; // continue to roll stack
21684+ label = 1831LLU; // continue to roll stack
2161721685 break;
2161821686 }
21619- case 1875LLU: // return from matchsym to ProcCall
21687+ case 1883LLU: // return from matchsym to ProcCall
2162021688 {
2162121689 // copy mutable arguments back from call to matchsym
2162221690 stack[base + 14]/*lookahead*/ = stack[base + 48LLU];
2162321691 if(/*typedata*/0 != ((uint64_t *)(stack[base + 41]/*expected*/))[0])
2162421692 {
21625- label = 1877LLU; // jump to alternative
21693+ label = 1885LLU; // jump to alternative
2162621694 break;
2162721695 }
2162821696
@@ -21630,9 +21698,9 @@
2163021698
2163121699 // case
2163221700 // call equ from ProcCall
21633- stack[base + 44LLU] = 1879LLU/*throw to this address*/;
21701+ stack[base + 44LLU] = 1887LLU/*throw to this address*/;
2163421702 stack[base + 45LLU] = base;
21635- stack[base + 46LLU] = 1880LLU;
21703+ stack[base + 46LLU] = 1888LLU;
2163621704 // arguments for call to equ
2163721705 stack[base + 48LLU] = stack[base + 43]/*name*/;
2163821706 stack[base + 49LLU] = 881834713755418624LLU;
@@ -21641,13 +21709,13 @@
2164121709 label = 18446744073709551600LLU; // equ
2164221710 break;
2164321711 }
21644- case 1879LLU: // copy-back deleter (equ to ProcCall)
21712+ case 1887LLU: // copy-back deleter (equ to ProcCall)
2164521713 {
2164621714 // copy mutable arguments back from call to equ
21647- label = 1878LLU; // continue to roll stack
21715+ label = 1886LLU; // continue to roll stack
2164821716 break;
2164921717 }
21650- case 1880LLU: // return from equ to ProcCall
21718+ case 1888LLU: // return from equ to ProcCall
2165121719 {
2165221720 // copy mutable arguments back from call to equ
2165321721 // copy back results provided by call to equ
@@ -21654,7 +21722,7 @@
2165421722 stack[base + 18] = stack[base + 47LLU];
2165521723 if(!stack[base + 18]/*isequal*/)
2165621724 {
21657- label = 1881LLU; // jump to alternative
21725+ label = 1889LLU; // jump to alternative
2165821726 break;
2165921727 }
2166021728
@@ -21661,7 +21729,7 @@
2166121729 // consequent
2166221730 if(!stack[base + 40]/*mutable*/)
2166321731 {
21664- label = 1883LLU; // jump to alternative
21732+ label = 1891LLU; // jump to alternative
2166521733 break;
2166621734 }
2166721735
@@ -21668,9 +21736,9 @@
2166821736 // consequent
2166921737 fprintf(stderr, "%s", "in function ");
2167021738 // call reportid from ProcCall
21671- stack[base + 44LLU] = 1885LLU/*throw to this address*/;
21739+ stack[base + 44LLU] = 1893LLU/*throw to this address*/;
2167221740 stack[base + 45LLU] = base;
21673- stack[base + 46LLU] = 1886LLU;
21741+ stack[base + 46LLU] = 1894LLU;
2167421742 // arguments for call to reportid
2167521743 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2167621744 // set stack-base & callee-address
@@ -21678,20 +21746,20 @@
2167821746 label = 18446744073709551586LLU; // reportid
2167921747 break;
2168021748 }
21681- case 1885LLU: // copy-back deleter (reportid to ProcCall)
21749+ case 1893LLU: // copy-back deleter (reportid to ProcCall)
2168221750 {
2168321751 // copy mutable arguments back from call to reportid
21684- label = 1878LLU; // continue to roll stack
21752+ label = 1886LLU; // continue to roll stack
2168521753 break;
2168621754 }
21687- case 1886LLU: // return from reportid to ProcCall
21755+ case 1894LLU: // return from reportid to ProcCall
2168821756 {
2168921757 // copy mutable arguments back from call to reportid
2169021758 fprintf(stderr, "%s", ", call to ");
2169121759 // call reportid from ProcCall
21692- stack[base + 44LLU] = 1887LLU/*throw to this address*/;
21760+ stack[base + 44LLU] = 1895LLU/*throw to this address*/;
2169321761 stack[base + 45LLU] = base;
21694- stack[base + 46LLU] = 1888LLU;
21762+ stack[base + 46LLU] = 1896LLU;
2169521763 // arguments for call to reportid
2169621764 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2169721765 // set stack-base & callee-address
@@ -21699,13 +21767,13 @@
2169921767 label = 18446744073709551586LLU; // reportid
2170021768 break;
2170121769 }
21702- case 1887LLU: // copy-back deleter (reportid to ProcCall)
21770+ case 1895LLU: // copy-back deleter (reportid to ProcCall)
2170321771 {
2170421772 // copy mutable arguments back from call to reportid
21705- label = 1878LLU; // continue to roll stack
21773+ label = 1886LLU; // continue to roll stack
2170621774 break;
2170721775 }
21708- case 1888LLU: // return from reportid to ProcCall
21776+ case 1896LLU: // return from reportid to ProcCall
2170921777 {
2171021778 // copy mutable arguments back from call to reportid
2171121779 fprintf(stderr, "%s", ": can't put constant argument u64 getbyte() into mutable parameter ");
@@ -21712,7 +21780,7 @@
2171221780 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2171321781 if(!newstack)
2171421782 {
21715- label = 1878LLU; // throw: begin to unroll stack
21783+ label = 1886LLU; // throw: begin to unroll stack
2171621784 break;
2171721785 }
2171821786
@@ -21719,9 +21787,9 @@
2171921787 newstack[10LLU] = 9876543210LLU; // overflow-marker
2172021788 // call reporttype from ProcCall
2172121789 newstack[0] = (uint64_t)stack; // backup stack location
21722- newstack[1] = 1889LLU;
21790+ newstack[1] = 1897LLU;
2172321791 newstack[2] = base;
21724- newstack[3] = 1890LLU;
21792+ newstack[3] = 1898LLU;
2172521793 // arguments for call to reporttype
2172621794 newstack[4LLU] = stack[base + 41]/*expected*/;
2172721795 stack = newstack;
@@ -21730,7 +21798,7 @@
2173021798 label = 330LLU; // reporttype
2173121799 break;
2173221800 }
21733- case 1889LLU: // copy-back deleter (reporttype to ProcCall)
21801+ case 1897LLU: // copy-back deleter (reporttype to ProcCall)
2173421802 {
2173521803 uint64_t *oldstack = (uint64_t *)stack[0];
2173621804 // copy mutable arguments back from call to reporttype
@@ -21741,10 +21809,10 @@
2174121809 }
2174221810 Free(10LLU + 1, sizeof(uint64_t), stack);
2174321811 stack = oldstack;
21744- label = 1878LLU; // continue to unroll stack
21812+ label = 1886LLU; // continue to unroll stack
2174521813 break;
2174621814 }
21747- case 1890LLU: // return from reporttype to ProcCall
21815+ case 1898LLU: // return from reporttype to ProcCall
2174821816 {
2174921817 uint64_t *oldstack = (uint64_t *)stack[0];
2175021818 // copy mutable arguments back from call to reporttype
@@ -21756,9 +21824,9 @@
2175621824 Free(10LLU + 1, sizeof(uint64_t), stack);
2175721825 stack = oldstack;
2175821826 // call reportid from ProcCall
21759- stack[base + 44LLU] = 1891LLU/*throw to this address*/;
21827+ stack[base + 44LLU] = 1899LLU/*throw to this address*/;
2176021828 stack[base + 45LLU] = base;
21761- stack[base + 46LLU] = 1892LLU;
21829+ stack[base + 46LLU] = 1900LLU;
2176221830 // arguments for call to reportid
2176321831 stack[base + 47LLU] = stack[base + 42]/*paramname*/;
2176421832 // set stack-base & callee-address
@@ -21766,32 +21834,32 @@
2176621834 label = 18446744073709551586LLU; // reportid
2176721835 break;
2176821836 }
21769- case 1891LLU: // copy-back deleter (reportid to ProcCall)
21837+ case 1899LLU: // copy-back deleter (reportid to ProcCall)
2177021838 {
2177121839 // copy mutable arguments back from call to reportid
21772- label = 1878LLU; // continue to roll stack
21840+ label = 1886LLU; // continue to roll stack
2177321841 break;
2177421842 }
21775- case 1892LLU: // return from reportid to ProcCall
21843+ case 1900LLU: // return from reportid to ProcCall
2177621844 {
2177721845 // copy mutable arguments back from call to reportid
2177821846 fprintf(stderr, "%s", "\n");
2177921847 {
21780- label = 1878LLU; // throw: begin to unroll stack
21848+ label = 1886LLU; // throw: begin to unroll stack
2178121849 break;
2178221850 }
2178321851
21784- label = 1884LLU; // consequent complete
21852+ label = 1892LLU; // consequent complete
2178521853 break;
2178621854 }
21787- case 1883LLU: // alternative
21855+ case 1891LLU: // alternative
2178821856 {
2178921857 stack[base + 35]/*csubstruct*/ = 1;
2179021858 printf("%s", "\n newstack[");
2179121859 // call printnr from ProcCall
21792- stack[base + 44LLU] = 1893LLU/*throw to this address*/;
21860+ stack[base + 44LLU] = 1901LLU/*throw to this address*/;
2179321861 stack[base + 45LLU] = base;
21794- stack[base + 46LLU] = 1894LLU;
21862+ stack[base + 46LLU] = 1902LLU;
2179521863 // arguments for call to printnr
2179621864 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2179721865 // set stack-base & callee-address
@@ -21799,31 +21867,31 @@
2179921867 label = 18446744073709551590LLU; // printnr
2180021868 break;
2180121869 }
21802- case 1893LLU: // copy-back deleter (printnr to ProcCall)
21870+ case 1901LLU: // copy-back deleter (printnr to ProcCall)
2180321871 {
2180421872 // copy mutable arguments back from call to printnr
21805- label = 1878LLU; // continue to roll stack
21873+ label = 1886LLU; // continue to roll stack
2180621874 break;
2180721875 }
21808- case 1894LLU: // return from printnr to ProcCall
21876+ case 1902LLU: // return from printnr to ProcCall
2180921877 {
2181021878 // copy mutable arguments back from call to printnr
2181121879 printf("%s", "LLU] = getchar();");
21812- label = 1884LLU; // alternative complete
21880+ label = 1892LLU; // alternative complete
2181321881 break;
2181421882 }
21815- case 1884LLU: // completed if-then-else
21883+ case 1892LLU: // completed if-then-else
2181621884 {
21817- label = 1882LLU; // consequent complete
21885+ label = 1890LLU; // consequent complete
2181821886 break;
2181921887 }
21820- case 1881LLU: // alternative
21888+ case 1889LLU: // alternative
2182121889 {
2182221890 fprintf(stderr, "%s", "in function ");
2182321891 // call reportid from ProcCall
21824- stack[base + 44LLU] = 1895LLU/*throw to this address*/;
21892+ stack[base + 44LLU] = 1903LLU/*throw to this address*/;
2182521893 stack[base + 45LLU] = base;
21826- stack[base + 46LLU] = 1896LLU;
21894+ stack[base + 46LLU] = 1904LLU;
2182721895 // arguments for call to reportid
2182821896 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2182921897 // set stack-base & callee-address
@@ -21831,20 +21899,20 @@
2183121899 label = 18446744073709551586LLU; // reportid
2183221900 break;
2183321901 }
21834- case 1895LLU: // copy-back deleter (reportid to ProcCall)
21902+ case 1903LLU: // copy-back deleter (reportid to ProcCall)
2183521903 {
2183621904 // copy mutable arguments back from call to reportid
21837- label = 1878LLU; // continue to roll stack
21905+ label = 1886LLU; // continue to roll stack
2183821906 break;
2183921907 }
21840- case 1896LLU: // return from reportid to ProcCall
21908+ case 1904LLU: // return from reportid to ProcCall
2184121909 {
2184221910 // copy mutable arguments back from call to reportid
2184321911 fprintf(stderr, "%s", " recursive call to ");
2184421912 // call reportid from ProcCall
21845- stack[base + 44LLU] = 1897LLU/*throw to this address*/;
21913+ stack[base + 44LLU] = 1905LLU/*throw to this address*/;
2184621914 stack[base + 45LLU] = base;
21847- stack[base + 46LLU] = 1898LLU;
21915+ stack[base + 46LLU] = 1906LLU;
2184821916 // arguments for call to reportid
2184921917 stack[base + 47LLU] = stack[base + 24]/*ceid*/;
2185021918 // set stack-base & callee-address
@@ -21852,20 +21920,20 @@
2185221920 label = 18446744073709551586LLU; // reportid
2185321921 break;
2185421922 }
21855- case 1897LLU: // copy-back deleter (reportid to ProcCall)
21923+ case 1905LLU: // copy-back deleter (reportid to ProcCall)
2185621924 {
2185721925 // copy mutable arguments back from call to reportid
21858- label = 1878LLU; // continue to roll stack
21926+ label = 1886LLU; // continue to roll stack
2185921927 break;
2186021928 }
21861- case 1898LLU: // return from reportid to ProcCall
21929+ case 1906LLU: // return from reportid to ProcCall
2186221930 {
2186321931 // copy mutable arguments back from call to reportid
2186421932 fprintf(stderr, "%s", " at position ");
2186521933 // call reportnr from ProcCall
21866- stack[base + 44LLU] = 1899LLU/*throw to this address*/;
21934+ stack[base + 44LLU] = 1907LLU/*throw to this address*/;
2186721935 stack[base + 45LLU] = base;
21868- stack[base + 46LLU] = 1900LLU;
21936+ stack[base + 46LLU] = 1908LLU;
2186921937 // arguments for call to reportnr
2187021938 stack[base + 47LLU] = stack[base + 32]/*index*/;
2187121939 // set stack-base & callee-address
@@ -21873,13 +21941,13 @@
2187321941 label = 18446744073709551589LLU; // reportnr
2187421942 break;
2187521943 }
21876- case 1899LLU: // copy-back deleter (reportnr to ProcCall)
21944+ case 1907LLU: // copy-back deleter (reportnr to ProcCall)
2187721945 {
2187821946 // copy mutable arguments back from call to reportnr
21879- label = 1878LLU; // continue to roll stack
21947+ label = 1886LLU; // continue to roll stack
2188021948 break;
2188121949 }
21882- case 1900LLU: // return from reportnr to ProcCall
21950+ case 1908LLU: // return from reportnr to ProcCall
2188321951 {
2188421952 // copy mutable arguments back from call to reportnr
2188521953 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -21887,7 +21955,7 @@
2188721955 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2188821956 if(!newstack)
2188921957 {
21890- label = 1878LLU; // throw: begin to unroll stack
21958+ label = 1886LLU; // throw: begin to unroll stack
2189121959 break;
2189221960 }
2189321961
@@ -21894,9 +21962,9 @@
2189421962 newstack[10LLU] = 9876543210LLU; // overflow-marker
2189521963 // call reporttype from ProcCall
2189621964 newstack[0] = (uint64_t)stack; // backup stack location
21897- newstack[1] = 1901LLU;
21965+ newstack[1] = 1909LLU;
2189821966 newstack[2] = base;
21899- newstack[3] = 1902LLU;
21967+ newstack[3] = 1910LLU;
2190021968 // arguments for call to reporttype
2190121969 newstack[4LLU] = stack[base + 41]/*expected*/;
2190221970 stack = newstack;
@@ -21905,7 +21973,7 @@
2190521973 label = 330LLU; // reporttype
2190621974 break;
2190721975 }
21908- case 1901LLU: // copy-back deleter (reporttype to ProcCall)
21976+ case 1909LLU: // copy-back deleter (reporttype to ProcCall)
2190921977 {
2191021978 uint64_t *oldstack = (uint64_t *)stack[0];
2191121979 // copy mutable arguments back from call to reporttype
@@ -21916,10 +21984,10 @@
2191621984 }
2191721985 Free(10LLU + 1, sizeof(uint64_t), stack);
2191821986 stack = oldstack;
21919- label = 1878LLU; // continue to unroll stack
21987+ label = 1886LLU; // continue to unroll stack
2192021988 break;
2192121989 }
21922- case 1902LLU: // return from reporttype to ProcCall
21990+ case 1910LLU: // return from reporttype to ProcCall
2192321991 {
2192421992 uint64_t *oldstack = (uint64_t *)stack[0];
2192521993 // copy mutable arguments back from call to reporttype
@@ -21932,33 +22000,33 @@
2193222000 stack = oldstack;
2193322001 fprintf(stderr, "%s", "\n");
2193422002 {
21935- label = 1878LLU; // throw: begin to unroll stack
22003+ label = 1886LLU; // throw: begin to unroll stack
2193622004 break;
2193722005 }
2193822006
21939- label = 1882LLU; // alternative complete
22007+ label = 1890LLU; // alternative complete
2194022008 break;
2194122009 }
21942- case 1882LLU: // completed if-then-else
22010+ case 1890LLU: // completed if-then-else
2194322011 {
2194422012 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
21945- label = 1876LLU; // case complete
22013+ label = 1884LLU; // case complete
2194622014 break;
2194722015 }
21948- case 1878LLU: // copy-back deleter (switch)
22016+ case 1886LLU: // copy-back deleter (switch)
2194922017 {
2195022018 ((uint64_t **)(stack[base + 41]))[1][0] = stack[base + 43];
21951- label = 1823LLU; // continue to unroll stack
22019+ label = 1831LLU; // continue to unroll stack
2195222020 break;
2195322021 }
21954- case 1877LLU: // try next case
22022+ case 1885LLU: // try next case
2195522023 {
2195622024 // default
2195722025 fprintf(stderr, "%s", "in function ");
2195822026 // call reportid from ProcCall
21959- stack[base + 43LLU] = 1903LLU/*throw to this address*/;
22027+ stack[base + 43LLU] = 1911LLU/*throw to this address*/;
2196022028 stack[base + 44LLU] = base;
21961- stack[base + 45LLU] = 1904LLU;
22029+ stack[base + 45LLU] = 1912LLU;
2196222030 // arguments for call to reportid
2196322031 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2196422032 // set stack-base & callee-address
@@ -21966,20 +22034,20 @@
2196622034 label = 18446744073709551586LLU; // reportid
2196722035 break;
2196822036 }
21969- case 1903LLU: // copy-back deleter (reportid to ProcCall)
22037+ case 1911LLU: // copy-back deleter (reportid to ProcCall)
2197022038 {
2197122039 // copy mutable arguments back from call to reportid
21972- label = 1823LLU; // continue to roll stack
22040+ label = 1831LLU; // continue to roll stack
2197322041 break;
2197422042 }
21975- case 1904LLU: // return from reportid to ProcCall
22043+ case 1912LLU: // return from reportid to ProcCall
2197622044 {
2197722045 // copy mutable arguments back from call to reportid
2197822046 fprintf(stderr, "%s", " recursive call to ");
2197922047 // call reportid from ProcCall
21980- stack[base + 43LLU] = 1905LLU/*throw to this address*/;
22048+ stack[base + 43LLU] = 1913LLU/*throw to this address*/;
2198122049 stack[base + 44LLU] = base;
21982- stack[base + 45LLU] = 1906LLU;
22050+ stack[base + 45LLU] = 1914LLU;
2198322051 // arguments for call to reportid
2198422052 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2198522053 // set stack-base & callee-address
@@ -21987,20 +22055,20 @@
2198722055 label = 18446744073709551586LLU; // reportid
2198822056 break;
2198922057 }
21990- case 1905LLU: // copy-back deleter (reportid to ProcCall)
22058+ case 1913LLU: // copy-back deleter (reportid to ProcCall)
2199122059 {
2199222060 // copy mutable arguments back from call to reportid
21993- label = 1823LLU; // continue to roll stack
22061+ label = 1831LLU; // continue to roll stack
2199422062 break;
2199522063 }
21996- case 1906LLU: // return from reportid to ProcCall
22064+ case 1914LLU: // return from reportid to ProcCall
2199722065 {
2199822066 // copy mutable arguments back from call to reportid
2199922067 fprintf(stderr, "%s", " at position ");
2200022068 // call reportnr from ProcCall
22001- stack[base + 43LLU] = 1907LLU/*throw to this address*/;
22069+ stack[base + 43LLU] = 1915LLU/*throw to this address*/;
2200222070 stack[base + 44LLU] = base;
22003- stack[base + 45LLU] = 1908LLU;
22071+ stack[base + 45LLU] = 1916LLU;
2200422072 // arguments for call to reportnr
2200522073 stack[base + 46LLU] = stack[base + 32]/*index*/;
2200622074 // set stack-base & callee-address
@@ -22008,13 +22076,13 @@
2200822076 label = 18446744073709551589LLU; // reportnr
2200922077 break;
2201022078 }
22011- case 1907LLU: // copy-back deleter (reportnr to ProcCall)
22079+ case 1915LLU: // copy-back deleter (reportnr to ProcCall)
2201222080 {
2201322081 // copy mutable arguments back from call to reportnr
22014- label = 1823LLU; // continue to roll stack
22082+ label = 1831LLU; // continue to roll stack
2201522083 break;
2201622084 }
22017- case 1908LLU: // return from reportnr to ProcCall
22085+ case 1916LLU: // return from reportnr to ProcCall
2201822086 {
2201922087 // copy mutable arguments back from call to reportnr
2202022088 fprintf(stderr, "%s", " argument getbyte() requires parameter of type u64 but found ");
@@ -22022,7 +22090,7 @@
2202222090 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2202322091 if(!newstack)
2202422092 {
22025- label = 1823LLU; // throw: begin to unroll stack
22093+ label = 1831LLU; // throw: begin to unroll stack
2202622094 break;
2202722095 }
2202822096
@@ -22029,9 +22097,9 @@
2202922097 newstack[10LLU] = 9876543210LLU; // overflow-marker
2203022098 // call reporttype from ProcCall
2203122099 newstack[0] = (uint64_t)stack; // backup stack location
22032- newstack[1] = 1909LLU;
22100+ newstack[1] = 1917LLU;
2203322101 newstack[2] = base;
22034- newstack[3] = 1910LLU;
22102+ newstack[3] = 1918LLU;
2203522103 // arguments for call to reporttype
2203622104 newstack[4LLU] = stack[base + 41]/*expected*/;
2203722105 stack = newstack;
@@ -22040,7 +22108,7 @@
2204022108 label = 330LLU; // reporttype
2204122109 break;
2204222110 }
22043- case 1909LLU: // copy-back deleter (reporttype to ProcCall)
22111+ case 1917LLU: // copy-back deleter (reporttype to ProcCall)
2204422112 {
2204522113 uint64_t *oldstack = (uint64_t *)stack[0];
2204622114 // copy mutable arguments back from call to reporttype
@@ -22051,10 +22119,10 @@
2205122119 }
2205222120 Free(10LLU + 1, sizeof(uint64_t), stack);
2205322121 stack = oldstack;
22054- label = 1823LLU; // continue to unroll stack
22122+ label = 1831LLU; // continue to unroll stack
2205522123 break;
2205622124 }
22057- case 1910LLU: // return from reporttype to ProcCall
22125+ case 1918LLU: // return from reporttype to ProcCall
2205822126 {
2205922127 uint64_t *oldstack = (uint64_t *)stack[0];
2206022128 // copy mutable arguments back from call to reporttype
@@ -22067,32 +22135,32 @@
2206722135 stack = oldstack;
2206822136 fprintf(stderr, "%s", "\n");
2206922137 {
22070- label = 1823LLU; // throw: begin to unroll stack
22138+ label = 1831LLU; // throw: begin to unroll stack
2207122139 break;
2207222140 }
2207322141
22074- label = 1876LLU; // default complete
22142+ label = 1884LLU; // default complete
2207522143 break;
2207622144 }
22077- case 1876LLU: // completed switch
22145+ case 1884LLU: // completed switch
2207822146 {
2207922147 if(!stack[base + 7]/*fnIO*/)
2208022148 {
22081- label = 1911LLU; // jump to alternative
22149+ label = 1919LLU; // jump to alternative
2208222150 break;
2208322151 }
2208422152
2208522153 // consequent
22086- label = 1912LLU; // consequent complete
22154+ label = 1920LLU; // consequent complete
2208722155 break;
2208822156 }
22089- case 1911LLU: // alternative
22157+ case 1919LLU: // alternative
2209022158 {
2209122159 fprintf(stderr, "%s", "in function ");
2209222160 // call reportid from ProcCall
22093- stack[base + 43LLU] = 1913LLU/*throw to this address*/;
22161+ stack[base + 43LLU] = 1921LLU/*throw to this address*/;
2209422162 stack[base + 44LLU] = base;
22095- stack[base + 45LLU] = 1914LLU;
22163+ stack[base + 45LLU] = 1922LLU;
2209622164 // arguments for call to reportid
2209722165 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2209822166 // set stack-base & callee-address
@@ -22100,41 +22168,41 @@
2210022168 label = 18446744073709551586LLU; // reportid
2210122169 break;
2210222170 }
22103- case 1913LLU: // copy-back deleter (reportid to ProcCall)
22171+ case 1921LLU: // copy-back deleter (reportid to ProcCall)
2210422172 {
2210522173 // copy mutable arguments back from call to reportid
22106- label = 1823LLU; // continue to roll stack
22174+ label = 1831LLU; // continue to roll stack
2210722175 break;
2210822176 }
22109- case 1914LLU: // return from reportid to ProcCall
22177+ case 1922LLU: // return from reportid to ProcCall
2211022178 {
2211122179 // copy mutable arguments back from call to reportid
2211222180 fprintf(stderr, "%s", ": ");
2211322181 fprintf(stderr, "%s", "getbyte() used in non-IO environment\n");
2211422182 {
22115- label = 1823LLU; // throw: begin to unroll stack
22183+ label = 1831LLU; // throw: begin to unroll stack
2211622184 break;
2211722185 }
2211822186
22119- label = 1912LLU; // alternative complete
22187+ label = 1920LLU; // alternative complete
2212022188 break;
2212122189 }
22122- case 1912LLU: // completed if-then-else
22190+ case 1920LLU: // completed if-then-else
2212322191 {
22124- label = 1871LLU; // consequent complete
22192+ label = 1879LLU; // consequent complete
2212522193 break;
2212622194 }
22127- case 1870LLU: // alternative
22195+ case 1878LLU: // alternative
2212822196 {
22129- label = 1916LLU; // skip deleter
22197+ label = 1924LLU; // skip deleter
2213022198 break;
2213122199 }
22132- case 1915LLU: // deleter
22200+ case 1923LLU: // deleter
2213322201 {
2213422202 // throw from ProcCall
2213522203 if(!stack[base + 43])
2213622204 {
22137- label = 1823LLU; // skip, variable already deleted/unscoped
22205+ label = 1831LLU; // skip, variable already deleted/unscoped
2213822206 break;
2213922207 }
2214022208
@@ -22143,7 +22211,7 @@
2214322211 newstack[0] = (uint64_t)stack; // backup stack location
2214422212 newstack[1] = 1234567890;
2214522213 newstack[2] = base;
22146- newstack[3] = 1917LLU;
22214+ newstack[3] = 1925LLU;
2214722215 stack = newstack;
2214822216 // set stack-base & callee-address
2214922217 base = 4/*deloffset*/;
@@ -22150,21 +22218,21 @@
2215022218 label = 486LLU; // ~letdef
2215122219 break;
2215222220 }
22153- case 1917LLU: // return from ~letdef to ProcCall
22221+ case 1925LLU: // return from ~letdef to ProcCall
2215422222 {
2215522223 stack = (uint64_t *)stack[0];
2215622224 // releasing toplevel container
2215722225 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2215822226
22159- label = 1823LLU; // continue unrolling stack, delete next variable
22227+ label = 1831LLU; // continue unrolling stack, delete next variable
2216022228 break;
2216122229 }
22162- case 1916LLU: // skipped deleter
22230+ case 1924LLU: // skipped deleter
2216322231 {
2216422232 // call FindLet from ProcCall
22165- stack[base + 44LLU] = 1918LLU/*throw to this address*/;
22233+ stack[base + 44LLU] = 1926LLU/*throw to this address*/;
2216622234 stack[base + 45LLU] = base;
22167- stack[base + 46LLU] = 1919LLU;
22235+ stack[base + 46LLU] = 1927LLU;
2216822236 // arguments for call to FindLet
2216922237 stack[base + 48LLU] = stack[base + 8]/*fnid*/;
2217022238 stack[base + 49LLU] = stack[base + 16]/*content*/;
@@ -22175,13 +22243,13 @@
2217522243 label = 619LLU; // FindLet
2217622244 break;
2217722245 }
22178- case 1918LLU: // copy-back deleter (FindLet to ProcCall)
22246+ case 1926LLU: // copy-back deleter (FindLet to ProcCall)
2217922247 {
2218022248 // copy mutable arguments back from call to FindLet
22181- label = 1823LLU; // continue to roll stack
22249+ label = 1831LLU; // continue to roll stack
2218222250 break;
2218322251 }
22184- case 1919LLU: // return from FindLet to ProcCall
22252+ case 1927LLU: // return from FindLet to ProcCall
2218522253 {
2218622254 // copy mutable arguments back from call to FindLet
2218722255 // copy back results provided by call to FindLet
@@ -22188,7 +22256,7 @@
2218822256 stack[base + 43] = stack[base + 47LLU];
2218922257 if(/*letdef*/0 != ((uint64_t *)(stack[base + 43]/*letdef*/))[0])
2219022258 {
22191- label = 1921LLU; // jump to alternative
22259+ label = 1929LLU; // jump to alternative
2219222260 break;
2219322261 }
2219422262
@@ -22200,9 +22268,9 @@
2220022268
2220122269 // case
2220222270 // call or from ProcCall
22203- stack[base + 49LLU] = 1923LLU/*throw to this address*/;
22271+ stack[base + 49LLU] = 1931LLU/*throw to this address*/;
2220422272 stack[base + 50LLU] = base;
22205- stack[base + 51LLU] = 1924LLU;
22273+ stack[base + 51LLU] = 1932LLU;
2220622274 // arguments for call to or
2220722275 stack[base + 53LLU] = stack[base + 35]/*csubstruct*/;
2220822276 stack[base + 54LLU] = stack[base + 48]/*substruct*/;
@@ -22211,13 +22279,13 @@
2221122279 label = 18446744073709551611LLU; // or
2221222280 break;
2221322281 }
22214- case 1923LLU: // copy-back deleter (or to ProcCall)
22282+ case 1931LLU: // copy-back deleter (or to ProcCall)
2221522283 {
2221622284 // copy mutable arguments back from call to or
22217- label = 1922LLU; // continue to roll stack
22285+ label = 1930LLU; // continue to roll stack
2221822286 break;
2221922287 }
22220- case 1924LLU: // return from or to ProcCall
22288+ case 1932LLU: // return from or to ProcCall
2222122289 {
2222222290 // copy mutable arguments back from call to or
2222322291 // copy back results provided by call to or
@@ -22225,7 +22293,7 @@
2222522293 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2222622294 if(!newstack)
2222722295 {
22228- label = 1922LLU; // throw: begin to unroll stack
22296+ label = 1930LLU; // throw: begin to unroll stack
2222922297 break;
2223022298 }
2223122299
@@ -22232,9 +22300,9 @@
2223222300 newstack[15LLU] = 9876543210LLU; // overflow-marker
2223322301 // call equtype from ProcCall
2223422302 newstack[0] = (uint64_t)stack; // backup stack location
22235- newstack[1] = 1925LLU;
22303+ newstack[1] = 1933LLU;
2223622304 newstack[2] = base;
22237- newstack[3] = 1926LLU;
22305+ newstack[3] = 1934LLU;
2223822306 // arguments for call to equtype
2223922307 newstack[5LLU] = stack[base + 44]/*type*/;
2224022308 newstack[6LLU] = stack[base + 41]/*expected*/;
@@ -22244,7 +22312,7 @@
2224422312 label = 359LLU; // equtype
2224522313 break;
2224622314 }
22247- case 1925LLU: // copy-back deleter (equtype to ProcCall)
22315+ case 1933LLU: // copy-back deleter (equtype to ProcCall)
2224822316 {
2224922317 uint64_t *oldstack = (uint64_t *)stack[0];
2225022318 // copy mutable arguments back from call to equtype
@@ -22255,10 +22323,10 @@
2225522323 }
2225622324 Free(15LLU + 1, sizeof(uint64_t), stack);
2225722325 stack = oldstack;
22258- label = 1922LLU; // continue to unroll stack
22326+ label = 1930LLU; // continue to unroll stack
2225922327 break;
2226022328 }
22261- case 1926LLU: // return from equtype to ProcCall
22329+ case 1934LLU: // return from equtype to ProcCall
2226222330 {
2226322331 uint64_t *oldstack = (uint64_t *)stack[0];
2226422332 // copy mutable arguments back from call to equtype
@@ -22273,21 +22341,21 @@
2227322341 stack = oldstack;
2227422342 if(!stack[base + 18]/*isequal*/)
2227522343 {
22276- label = 1927LLU; // jump to alternative
22344+ label = 1935LLU; // jump to alternative
2227722345 break;
2227822346 }
2227922347
2228022348 // consequent
22281- label = 1928LLU; // consequent complete
22349+ label = 1936LLU; // consequent complete
2228222350 break;
2228322351 }
22284- case 1927LLU: // alternative
22352+ case 1935LLU: // alternative
2228522353 {
2228622354 fprintf(stderr, "%s", "in function ");
2228722355 // call reportid from ProcCall
22288- stack[base + 49LLU] = 1929LLU/*throw to this address*/;
22356+ stack[base + 49LLU] = 1937LLU/*throw to this address*/;
2228922357 stack[base + 50LLU] = base;
22290- stack[base + 51LLU] = 1930LLU;
22358+ stack[base + 51LLU] = 1938LLU;
2229122359 // arguments for call to reportid
2229222360 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2229322361 // set stack-base & callee-address
@@ -22295,20 +22363,20 @@
2229522363 label = 18446744073709551586LLU; // reportid
2229622364 break;
2229722365 }
22298- case 1929LLU: // copy-back deleter (reportid to ProcCall)
22366+ case 1937LLU: // copy-back deleter (reportid to ProcCall)
2229922367 {
2230022368 // copy mutable arguments back from call to reportid
22301- label = 1922LLU; // continue to roll stack
22369+ label = 1930LLU; // continue to roll stack
2230222370 break;
2230322371 }
22304- case 1930LLU: // return from reportid to ProcCall
22372+ case 1938LLU: // return from reportid to ProcCall
2230522373 {
2230622374 // copy mutable arguments back from call to reportid
2230722375 fprintf(stderr, "%s", " call to ");
2230822376 // call reportid from ProcCall
22309- stack[base + 49LLU] = 1931LLU/*throw to this address*/;
22377+ stack[base + 49LLU] = 1939LLU/*throw to this address*/;
2231022378 stack[base + 50LLU] = base;
22311- stack[base + 51LLU] = 1932LLU;
22379+ stack[base + 51LLU] = 1940LLU;
2231222380 // arguments for call to reportid
2231322381 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2231422382 // set stack-base & callee-address
@@ -22316,20 +22384,20 @@
2231622384 label = 18446744073709551586LLU; // reportid
2231722385 break;
2231822386 }
22319- case 1931LLU: // copy-back deleter (reportid to ProcCall)
22387+ case 1939LLU: // copy-back deleter (reportid to ProcCall)
2232022388 {
2232122389 // copy mutable arguments back from call to reportid
22322- label = 1922LLU; // continue to roll stack
22390+ label = 1930LLU; // continue to roll stack
2232322391 break;
2232422392 }
22325- case 1932LLU: // return from reportid to ProcCall
22393+ case 1940LLU: // return from reportid to ProcCall
2232622394 {
2232722395 // copy mutable arguments back from call to reportid
2232822396 fprintf(stderr, "%s", " at position ");
2232922397 // call reportnr from ProcCall
22330- stack[base + 49LLU] = 1933LLU/*throw to this address*/;
22398+ stack[base + 49LLU] = 1941LLU/*throw to this address*/;
2233122399 stack[base + 50LLU] = base;
22332- stack[base + 51LLU] = 1934LLU;
22400+ stack[base + 51LLU] = 1942LLU;
2233322401 // arguments for call to reportnr
2233422402 stack[base + 52LLU] = stack[base + 32]/*index*/;
2233522403 // set stack-base & callee-address
@@ -22337,13 +22405,13 @@
2233722405 label = 18446744073709551589LLU; // reportnr
2233822406 break;
2233922407 }
22340- case 1933LLU: // copy-back deleter (reportnr to ProcCall)
22408+ case 1941LLU: // copy-back deleter (reportnr to ProcCall)
2234122409 {
2234222410 // copy mutable arguments back from call to reportnr
22343- label = 1922LLU; // continue to roll stack
22411+ label = 1930LLU; // continue to roll stack
2234422412 break;
2234522413 }
22346- case 1934LLU: // return from reportnr to ProcCall
22414+ case 1942LLU: // return from reportnr to ProcCall
2234722415 {
2234822416 // copy mutable arguments back from call to reportnr
2234922417 fprintf(stderr, "%s", " parameter type ");
@@ -22350,7 +22418,7 @@
2235022418 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2235122419 if(!newstack)
2235222420 {
22353- label = 1922LLU; // throw: begin to unroll stack
22421+ label = 1930LLU; // throw: begin to unroll stack
2235422422 break;
2235522423 }
2235622424
@@ -22357,9 +22425,9 @@
2235722425 newstack[10LLU] = 9876543210LLU; // overflow-marker
2235822426 // call reporttype from ProcCall
2235922427 newstack[0] = (uint64_t)stack; // backup stack location
22360- newstack[1] = 1935LLU;
22428+ newstack[1] = 1943LLU;
2236122429 newstack[2] = base;
22362- newstack[3] = 1936LLU;
22430+ newstack[3] = 1944LLU;
2236322431 // arguments for call to reporttype
2236422432 newstack[4LLU] = stack[base + 41]/*expected*/;
2236522433 stack = newstack;
@@ -22368,7 +22436,7 @@
2236822436 label = 330LLU; // reporttype
2236922437 break;
2237022438 }
22371- case 1935LLU: // copy-back deleter (reporttype to ProcCall)
22439+ case 1943LLU: // copy-back deleter (reporttype to ProcCall)
2237222440 {
2237322441 uint64_t *oldstack = (uint64_t *)stack[0];
2237422442 // copy mutable arguments back from call to reporttype
@@ -22379,10 +22447,10 @@
2237922447 }
2238022448 Free(10LLU + 1, sizeof(uint64_t), stack);
2238122449 stack = oldstack;
22382- label = 1922LLU; // continue to unroll stack
22450+ label = 1930LLU; // continue to unroll stack
2238322451 break;
2238422452 }
22385- case 1936LLU: // return from reporttype to ProcCall
22453+ case 1944LLU: // return from reporttype to ProcCall
2238622454 {
2238722455 uint64_t *oldstack = (uint64_t *)stack[0];
2238822456 // copy mutable arguments back from call to reporttype
@@ -22397,7 +22465,7 @@
2239722465 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2239822466 if(!newstack)
2239922467 {
22400- label = 1922LLU; // throw: begin to unroll stack
22468+ label = 1930LLU; // throw: begin to unroll stack
2240122469 break;
2240222470 }
2240322471
@@ -22404,9 +22472,9 @@
2240422472 newstack[10LLU] = 9876543210LLU; // overflow-marker
2240522473 // call reporttype from ProcCall
2240622474 newstack[0] = (uint64_t)stack; // backup stack location
22407- newstack[1] = 1937LLU;
22475+ newstack[1] = 1945LLU;
2240822476 newstack[2] = base;
22409- newstack[3] = 1938LLU;
22477+ newstack[3] = 1946LLU;
2241022478 // arguments for call to reporttype
2241122479 newstack[4LLU] = stack[base + 44]/*type*/;
2241222480 stack = newstack;
@@ -22415,7 +22483,7 @@
2241522483 label = 330LLU; // reporttype
2241622484 break;
2241722485 }
22418- case 1937LLU: // copy-back deleter (reporttype to ProcCall)
22486+ case 1945LLU: // copy-back deleter (reporttype to ProcCall)
2241922487 {
2242022488 uint64_t *oldstack = (uint64_t *)stack[0];
2242122489 // copy mutable arguments back from call to reporttype
@@ -22426,10 +22494,10 @@
2242622494 }
2242722495 Free(10LLU + 1, sizeof(uint64_t), stack);
2242822496 stack = oldstack;
22429- label = 1922LLU; // continue to unroll stack
22497+ label = 1930LLU; // continue to unroll stack
2243022498 break;
2243122499 }
22432- case 1938LLU: // return from reporttype to ProcCall
22500+ case 1946LLU: // return from reporttype to ProcCall
2243322501 {
2243422502 uint64_t *oldstack = (uint64_t *)stack[0];
2243522503 // copy mutable arguments back from call to reporttype
@@ -22442,18 +22510,18 @@
2244222510 stack = oldstack;
2244322511 fprintf(stderr, "%s", "\n");
2244422512 {
22445- label = 1922LLU; // throw: begin to unroll stack
22513+ label = 1930LLU; // throw: begin to unroll stack
2244622514 break;
2244722515 }
2244822516
22449- label = 1928LLU; // alternative complete
22517+ label = 1936LLU; // alternative complete
2245022518 break;
2245122519 }
22452- case 1928LLU: // completed if-then-else
22520+ case 1936LLU: // completed if-then-else
2245322521 {
2245422522 if(!stack[base + 40]/*mutable*/)
2245522523 {
22456- label = 1939LLU; // jump to alternative
22524+ label = 1947LLU; // jump to alternative
2245722525 break;
2245822526 }
2245922527
@@ -22460,31 +22528,31 @@
2246022528 // consequent
2246122529 if(!stack[base + 47]/*mutarg*/)
2246222530 {
22463- label = 1941LLU; // jump to alternative
22531+ label = 1949LLU; // jump to alternative
2246422532 break;
2246522533 }
2246622534
2246722535 // consequent
22468- label = 1944LLU; // skip deleter
22536+ label = 1952LLU; // skip deleter
2246922537 break;
2247022538 }
22471- case 1943LLU: // deleter
22539+ case 1951LLU: // deleter
2247222540 {
2247322541 // throw from ProcCall
2247422542 if(!stack[base + 49])
2247522543 {
22476- label = 1922LLU; // skip, variable already deleted/unscoped
22544+ label = 1930LLU; // skip, variable already deleted/unscoped
2247722545 break;
2247822546 }
22479- label = 1922LLU; // continue unrolling stack, delete next variable
22547+ label = 1930LLU; // continue unrolling stack, delete next variable
2248022548 break;
2248122549 }
22482- case 1944LLU: // skipped deleter
22550+ case 1952LLU: // skipped deleter
2248322551 {
2248422552 // call lookidnr from ProcCall
22485- stack[base + 50LLU] = 1945LLU/*throw to this address*/;
22553+ stack[base + 50LLU] = 1953LLU/*throw to this address*/;
2248622554 stack[base + 51LLU] = base;
22487- stack[base + 52LLU] = 1946LLU;
22555+ stack[base + 52LLU] = 1954LLU;
2248822556 // arguments for call to lookidnr
2248922557 stack[base + 54LLU] = stack[base + 19]/*copyback*/;
2249022558 stack[base + 55LLU] = stack[base + 16]/*content*/;
@@ -22493,13 +22561,13 @@
2249322561 label = 835LLU; // lookidnr
2249422562 break;
2249522563 }
22496- case 1945LLU: // copy-back deleter (lookidnr to ProcCall)
22564+ case 1953LLU: // copy-back deleter (lookidnr to ProcCall)
2249722565 {
2249822566 // copy mutable arguments back from call to lookidnr
22499- label = 1922LLU; // continue to roll stack
22567+ label = 1930LLU; // continue to roll stack
2250022568 break;
2250122569 }
22502- case 1946LLU: // return from lookidnr to ProcCall
22570+ case 1954LLU: // return from lookidnr to ProcCall
2250322571 {
2250422572 // copy mutable arguments back from call to lookidnr
2250522573 // copy back results provided by call to lookidnr
@@ -22506,7 +22574,7 @@
2250622574 stack[base + 49] = stack[base + 53LLU];
2250722575 if(!stack[base + 49]/*found*/)
2250822576 {
22509- label = 1947LLU; // jump to alternative
22577+ label = 1955LLU; // jump to alternative
2251022578 break;
2251122579 }
2251222580
@@ -22513,9 +22581,9 @@
2251322581 // consequent
2251422582 fprintf(stderr, "%s", "in function ");
2251522583 // call reportid from ProcCall
22516- stack[base + 50LLU] = 1949LLU/*throw to this address*/;
22584+ stack[base + 50LLU] = 1957LLU/*throw to this address*/;
2251722585 stack[base + 51LLU] = base;
22518- stack[base + 52LLU] = 1950LLU;
22586+ stack[base + 52LLU] = 1958LLU;
2251922587 // arguments for call to reportid
2252022588 stack[base + 53LLU] = stack[base + 8]/*fnid*/;
2252122589 // set stack-base & callee-address
@@ -22523,20 +22591,20 @@
2252322591 label = 18446744073709551586LLU; // reportid
2252422592 break;
2252522593 }
22526- case 1949LLU: // copy-back deleter (reportid to ProcCall)
22594+ case 1957LLU: // copy-back deleter (reportid to ProcCall)
2252722595 {
2252822596 // copy mutable arguments back from call to reportid
22529- label = 1943LLU; // continue to roll stack
22597+ label = 1951LLU; // continue to roll stack
2253022598 break;
2253122599 }
22532- case 1950LLU: // return from reportid to ProcCall
22600+ case 1958LLU: // return from reportid to ProcCall
2253322601 {
2253422602 // copy mutable arguments back from call to reportid
2253522603 fprintf(stderr, "%s", " call to ");
2253622604 // call reportid from ProcCall
22537- stack[base + 50LLU] = 1951LLU/*throw to this address*/;
22605+ stack[base + 50LLU] = 1959LLU/*throw to this address*/;
2253822606 stack[base + 51LLU] = base;
22539- stack[base + 52LLU] = 1952LLU;
22607+ stack[base + 52LLU] = 1960LLU;
2254022608 // arguments for call to reportid
2254122609 stack[base + 53LLU] = stack[base + 24]/*ceid*/;
2254222610 // set stack-base & callee-address
@@ -22544,20 +22612,20 @@
2254422612 label = 18446744073709551586LLU; // reportid
2254522613 break;
2254622614 }
22547- case 1951LLU: // copy-back deleter (reportid to ProcCall)
22615+ case 1959LLU: // copy-back deleter (reportid to ProcCall)
2254822616 {
2254922617 // copy mutable arguments back from call to reportid
22550- label = 1943LLU; // continue to roll stack
22618+ label = 1951LLU; // continue to roll stack
2255122619 break;
2255222620 }
22553- case 1952LLU: // return from reportid to ProcCall
22621+ case 1960LLU: // return from reportid to ProcCall
2255422622 {
2255522623 // copy mutable arguments back from call to reportid
2255622624 fprintf(stderr, "%s", " - duplicate mutable argument ");
2255722625 // call reportid from ProcCall
22558- stack[base + 50LLU] = 1953LLU/*throw to this address*/;
22626+ stack[base + 50LLU] = 1961LLU/*throw to this address*/;
2255922627 stack[base + 51LLU] = base;
22560- stack[base + 52LLU] = 1954LLU;
22628+ stack[base + 52LLU] = 1962LLU;
2256122629 // arguments for call to reportid
2256222630 stack[base + 53LLU] = stack[base + 16]/*content*/;
2256322631 // set stack-base & callee-address
@@ -22565,40 +22633,40 @@
2256522633 label = 18446744073709551586LLU; // reportid
2256622634 break;
2256722635 }
22568- case 1953LLU: // copy-back deleter (reportid to ProcCall)
22636+ case 1961LLU: // copy-back deleter (reportid to ProcCall)
2256922637 {
2257022638 // copy mutable arguments back from call to reportid
22571- label = 1943LLU; // continue to roll stack
22639+ label = 1951LLU; // continue to roll stack
2257222640 break;
2257322641 }
22574- case 1954LLU: // return from reportid to ProcCall
22642+ case 1962LLU: // return from reportid to ProcCall
2257522643 {
2257622644 // copy mutable arguments back from call to reportid
2257722645 fprintf(stderr, "%s", "\n");
2257822646 {
22579- label = 1943LLU; // throw: begin to unroll stack
22647+ label = 1951LLU; // throw: begin to unroll stack
2258022648 break;
2258122649 }
2258222650
22583- label = 1948LLU; // consequent complete
22651+ label = 1956LLU; // consequent complete
2258422652 break;
2258522653 }
22586- case 1947LLU: // alternative
22654+ case 1955LLU: // alternative
2258722655 {
22588- label = 1948LLU; // alternative complete
22656+ label = 1956LLU; // alternative complete
2258922657 break;
2259022658 }
22591- case 1948LLU: // completed if-then-else
22659+ case 1956LLU: // completed if-then-else
2259222660 {
22593- label = 1956LLU; // skip deleter
22661+ label = 1964LLU; // skip deleter
2259422662 break;
2259522663 }
22596- case 1955LLU: // deleter
22664+ case 1963LLU: // deleter
2259722665 {
2259822666 // throw from ProcCall
2259922667 if(!stack[base + 49])
2260022668 {
22601- label = 1922LLU; // skip, variable already deleted/unscoped
22669+ label = 1930LLU; // skip, variable already deleted/unscoped
2260222670 break;
2260322671 }
2260422672
@@ -22607,7 +22675,7 @@
2260722675 newstack[0] = (uint64_t)stack; // backup stack location
2260822676 newstack[1] = 1234567890;
2260922677 newstack[2] = base;
22610- newstack[3] = 1957LLU;
22678+ newstack[3] = 1965LLU;
2261122679 stack = newstack;
2261222680 // set stack-base & callee-address
2261322681 base = 4/*deloffset*/;
@@ -22614,21 +22682,21 @@
2261422682 label = 833LLU; // ~idnr
2261522683 break;
2261622684 }
22617- case 1957LLU: // return from ~idnr to ProcCall
22685+ case 1965LLU: // return from ~idnr to ProcCall
2261822686 {
2261922687 stack = (uint64_t *)stack[0];
2262022688 // releasing toplevel container
2262122689 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4));
2262222690
22623- label = 1922LLU; // continue unrolling stack, delete next variable
22691+ label = 1930LLU; // continue unrolling stack, delete next variable
2262422692 break;
2262522693 }
22626- case 1956LLU: // skipped deleter
22694+ case 1964LLU: // skipped deleter
2262722695 {
2262822696 // construct idnr.idnr
2262922697 if(!(stack[base + 49] = construct(2)))
2263022698 {
22631- label = 1922LLU; // throw: begin to unroll stack
22699+ label = 1930LLU; // throw: begin to unroll stack
2263222700 break;
2263322701 }
2263422702
@@ -22649,16 +22717,16 @@
2264922717 /*copyback*/stack[base + 19] = (uint64_t)list;
2265022718 MOVE(&list->data, &stack[base + 49]/*idnr*/);
2265122719 }
22652- label = 1942LLU; // consequent complete
22720+ label = 1950LLU; // consequent complete
2265322721 break;
2265422722 }
22655- case 1941LLU: // alternative
22723+ case 1949LLU: // alternative
2265622724 {
2265722725 fprintf(stderr, "%s", "in function ");
2265822726 // call reportid from ProcCall
22659- stack[base + 49LLU] = 1958LLU/*throw to this address*/;
22727+ stack[base + 49LLU] = 1966LLU/*throw to this address*/;
2266022728 stack[base + 50LLU] = base;
22661- stack[base + 51LLU] = 1959LLU;
22729+ stack[base + 51LLU] = 1967LLU;
2266222730 // arguments for call to reportid
2266322731 stack[base + 52LLU] = stack[base + 8]/*fnid*/;
2266422732 // set stack-base & callee-address
@@ -22666,20 +22734,20 @@
2266622734 label = 18446744073709551586LLU; // reportid
2266722735 break;
2266822736 }
22669- case 1958LLU: // copy-back deleter (reportid to ProcCall)
22737+ case 1966LLU: // copy-back deleter (reportid to ProcCall)
2267022738 {
2267122739 // copy mutable arguments back from call to reportid
22672- label = 1922LLU; // continue to roll stack
22740+ label = 1930LLU; // continue to roll stack
2267322741 break;
2267422742 }
22675- case 1959LLU: // return from reportid to ProcCall
22743+ case 1967LLU: // return from reportid to ProcCall
2267622744 {
2267722745 // copy mutable arguments back from call to reportid
2267822746 fprintf(stderr, "%s", ", call to ");
2267922747 // call reportid from ProcCall
22680- stack[base + 49LLU] = 1960LLU/*throw to this address*/;
22748+ stack[base + 49LLU] = 1968LLU/*throw to this address*/;
2268122749 stack[base + 50LLU] = base;
22682- stack[base + 51LLU] = 1961LLU;
22750+ stack[base + 51LLU] = 1969LLU;
2268322751 // arguments for call to reportid
2268422752 stack[base + 52LLU] = stack[base + 24]/*ceid*/;
2268522753 // set stack-base & callee-address
@@ -22687,13 +22755,13 @@
2268722755 label = 18446744073709551586LLU; // reportid
2268822756 break;
2268922757 }
22690- case 1960LLU: // copy-back deleter (reportid to ProcCall)
22758+ case 1968LLU: // copy-back deleter (reportid to ProcCall)
2269122759 {
2269222760 // copy mutable arguments back from call to reportid
22693- label = 1922LLU; // continue to roll stack
22761+ label = 1930LLU; // continue to roll stack
2269422762 break;
2269522763 }
22696- case 1961LLU: // return from reportid to ProcCall
22764+ case 1969LLU: // return from reportid to ProcCall
2269722765 {
2269822766 // copy mutable arguments back from call to reportid
2269922767 fprintf(stderr, "%s", ": can't put constant argument ");
@@ -22700,7 +22768,7 @@
2270022768 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2270122769 if(!newstack)
2270222770 {
22703- label = 1922LLU; // throw: begin to unroll stack
22771+ label = 1930LLU; // throw: begin to unroll stack
2270422772 break;
2270522773 }
2270622774
@@ -22707,9 +22775,9 @@
2270722775 newstack[10LLU] = 9876543210LLU; // overflow-marker
2270822776 // call reporttype from ProcCall
2270922777 newstack[0] = (uint64_t)stack; // backup stack location
22710- newstack[1] = 1962LLU;
22778+ newstack[1] = 1970LLU;
2271122779 newstack[2] = base;
22712- newstack[3] = 1963LLU;
22780+ newstack[3] = 1971LLU;
2271322781 // arguments for call to reporttype
2271422782 newstack[4LLU] = stack[base + 44]/*type*/;
2271522783 stack = newstack;
@@ -22718,7 +22786,7 @@
2271822786 label = 330LLU; // reporttype
2271922787 break;
2272022788 }
22721- case 1962LLU: // copy-back deleter (reporttype to ProcCall)
22789+ case 1970LLU: // copy-back deleter (reporttype to ProcCall)
2272222790 {
2272322791 uint64_t *oldstack = (uint64_t *)stack[0];
2272422792 // copy mutable arguments back from call to reporttype
@@ -22729,10 +22797,10 @@
2272922797 }
2273022798 Free(10LLU + 1, sizeof(uint64_t), stack);
2273122799 stack = oldstack;
22732- label = 1922LLU; // continue to unroll stack
22800+ label = 1930LLU; // continue to unroll stack
2273322801 break;
2273422802 }
22735- case 1963LLU: // return from reporttype to ProcCall
22803+ case 1971LLU: // return from reporttype to ProcCall
2273622804 {
2273722805 uint64_t *oldstack = (uint64_t *)stack[0];
2273822806 // copy mutable arguments back from call to reporttype
@@ -22745,9 +22813,9 @@
2274522813 stack = oldstack;
2274622814 fprintf(stderr, "%s", " ");
2274722815 // call reportid from ProcCall
22748- stack[base + 49LLU] = 1964LLU/*throw to this address*/;
22816+ stack[base + 49LLU] = 1972LLU/*throw to this address*/;
2274922817 stack[base + 50LLU] = base;
22750- stack[base + 51LLU] = 1965LLU;
22818+ stack[base + 51LLU] = 1973LLU;
2275122819 // arguments for call to reportid
2275222820 stack[base + 52LLU] = stack[base + 16]/*content*/;
2275322821 // set stack-base & callee-address
@@ -22755,13 +22823,13 @@
2275522823 label = 18446744073709551586LLU; // reportid
2275622824 break;
2275722825 }
22758- case 1964LLU: // copy-back deleter (reportid to ProcCall)
22826+ case 1972LLU: // copy-back deleter (reportid to ProcCall)
2275922827 {
2276022828 // copy mutable arguments back from call to reportid
22761- label = 1922LLU; // continue to roll stack
22829+ label = 1930LLU; // continue to roll stack
2276222830 break;
2276322831 }
22764- case 1965LLU: // return from reportid to ProcCall
22832+ case 1973LLU: // return from reportid to ProcCall
2276522833 {
2276622834 // copy mutable arguments back from call to reportid
2276722835 fprintf(stderr, "%s", " into mutable parameter ");
@@ -22768,7 +22836,7 @@
2276822836 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2276922837 if(!newstack)
2277022838 {
22771- label = 1922LLU; // throw: begin to unroll stack
22839+ label = 1930LLU; // throw: begin to unroll stack
2277222840 break;
2277322841 }
2277422842
@@ -22775,9 +22843,9 @@
2277522843 newstack[10LLU] = 9876543210LLU; // overflow-marker
2277622844 // call reporttype from ProcCall
2277722845 newstack[0] = (uint64_t)stack; // backup stack location
22778- newstack[1] = 1966LLU;
22846+ newstack[1] = 1974LLU;
2277922847 newstack[2] = base;
22780- newstack[3] = 1967LLU;
22848+ newstack[3] = 1975LLU;
2278122849 // arguments for call to reporttype
2278222850 newstack[4LLU] = stack[base + 41]/*expected*/;
2278322851 stack = newstack;
@@ -22786,7 +22854,7 @@
2278622854 label = 330LLU; // reporttype
2278722855 break;
2278822856 }
22789- case 1966LLU: // copy-back deleter (reporttype to ProcCall)
22857+ case 1974LLU: // copy-back deleter (reporttype to ProcCall)
2279022858 {
2279122859 uint64_t *oldstack = (uint64_t *)stack[0];
2279222860 // copy mutable arguments back from call to reporttype
@@ -22797,10 +22865,10 @@
2279722865 }
2279822866 Free(10LLU + 1, sizeof(uint64_t), stack);
2279922867 stack = oldstack;
22800- label = 1922LLU; // continue to unroll stack
22868+ label = 1930LLU; // continue to unroll stack
2280122869 break;
2280222870 }
22803- case 1967LLU: // return from reporttype to ProcCall
22871+ case 1975LLU: // return from reporttype to ProcCall
2280422872 {
2280522873 uint64_t *oldstack = (uint64_t *)stack[0];
2280622874 // copy mutable arguments back from call to reporttype
@@ -22812,9 +22880,9 @@
2281222880 Free(10LLU + 1, sizeof(uint64_t), stack);
2281322881 stack = oldstack;
2281422882 // call reportid from ProcCall
22815- stack[base + 49LLU] = 1968LLU/*throw to this address*/;
22883+ stack[base + 49LLU] = 1976LLU/*throw to this address*/;
2281622884 stack[base + 50LLU] = base;
22817- stack[base + 51LLU] = 1969LLU;
22885+ stack[base + 51LLU] = 1977LLU;
2281822886 // arguments for call to reportid
2281922887 stack[base + 52LLU] = stack[base + 42]/*paramname*/;
2282022888 // set stack-base & callee-address
@@ -22822,35 +22890,35 @@
2282222890 label = 18446744073709551586LLU; // reportid
2282322891 break;
2282422892 }
22825- case 1968LLU: // copy-back deleter (reportid to ProcCall)
22893+ case 1976LLU: // copy-back deleter (reportid to ProcCall)
2282622894 {
2282722895 // copy mutable arguments back from call to reportid
22828- label = 1922LLU; // continue to roll stack
22896+ label = 1930LLU; // continue to roll stack
2282922897 break;
2283022898 }
22831- case 1969LLU: // return from reportid to ProcCall
22899+ case 1977LLU: // return from reportid to ProcCall
2283222900 {
2283322901 // copy mutable arguments back from call to reportid
2283422902 fprintf(stderr, "%s", "\n");
2283522903 {
22836- label = 1922LLU; // throw: begin to unroll stack
22904+ label = 1930LLU; // throw: begin to unroll stack
2283722905 break;
2283822906 }
2283922907
22840- label = 1942LLU; // alternative complete
22908+ label = 1950LLU; // alternative complete
2284122909 break;
2284222910 }
22843- case 1942LLU: // completed if-then-else
22911+ case 1950LLU: // completed if-then-else
2284422912 {
22845- label = 1940LLU; // consequent complete
22913+ label = 1948LLU; // consequent complete
2284622914 break;
2284722915 }
22848- case 1939LLU: // alternative
22916+ case 1947LLU: // alternative
2284922917 {
22850- label = 1940LLU; // alternative complete
22918+ label = 1948LLU; // alternative complete
2285122919 break;
2285222920 }
22853- case 1940LLU: // completed if-then-else
22921+ case 1948LLU: // completed if-then-else
2285422922 {
2285522923 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2285622924 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -22857,10 +22925,10 @@
2285722925 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2285822926 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2285922927 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
22860- label = 1920LLU; // case complete
22928+ label = 1928LLU; // case complete
2286122929 break;
2286222930 }
22863- case 1922LLU: // copy-back deleter (switch)
22931+ case 1930LLU: // copy-back deleter (switch)
2286422932 {
2286522933 ((uint64_t **)(stack[base + 43]))[1][4] = stack[base + 48];
2286622934 ((uint64_t **)(stack[base + 43]))[1][3] = stack[base + 47];
@@ -22867,21 +22935,21 @@
2286722935 ((uint64_t **)(stack[base + 43]))[1][2] = stack[base + 46];
2286822936 ((uint64_t **)(stack[base + 43]))[1][1] = stack[base + 45];
2286922937 ((uint64_t **)(stack[base + 43]))[1][0] = stack[base + 44];
22870- label = 1915LLU; // continue to unroll stack
22938+ label = 1923LLU; // continue to unroll stack
2287122939 break;
2287222940 }
22873- case 1921LLU: // try next case
22941+ case 1929LLU: // try next case
2287422942 {
2287522943 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2287622944 exit(-1);
2287722945 }
22878- case 1920LLU: // completed switch
22946+ case 1928LLU: // completed switch
2287922947 {
2288022948 printf("%s", "\n newstack[");
2288122949 // call printnr from ProcCall
22882- stack[base + 44LLU] = 1970LLU/*throw to this address*/;
22950+ stack[base + 44LLU] = 1978LLU/*throw to this address*/;
2288322951 stack[base + 45LLU] = base;
22884- stack[base + 46LLU] = 1971LLU;
22952+ stack[base + 46LLU] = 1979LLU;
2288522953 // arguments for call to printnr
2288622954 stack[base + 47LLU] = stack[base + 30]/*sum*/;
2288722955 // set stack-base & callee-address
@@ -22889,20 +22957,20 @@
2288922957 label = 18446744073709551590LLU; // printnr
2289022958 break;
2289122959 }
22892- case 1970LLU: // copy-back deleter (printnr to ProcCall)
22960+ case 1978LLU: // copy-back deleter (printnr to ProcCall)
2289322961 {
2289422962 // copy mutable arguments back from call to printnr
22895- label = 1915LLU; // continue to roll stack
22963+ label = 1923LLU; // continue to roll stack
2289622964 break;
2289722965 }
22898- case 1971LLU: // return from printnr to ProcCall
22966+ case 1979LLU: // return from printnr to ProcCall
2289922967 {
2290022968 // copy mutable arguments back from call to printnr
2290122969 printf("%s", "LLU] = ");
2290222970 // call emitvar from ProcCall
22903- stack[base + 44LLU] = 1972LLU/*throw to this address*/;
22971+ stack[base + 44LLU] = 1980LLU/*throw to this address*/;
2290422972 stack[base + 45LLU] = base;
22905- stack[base + 46LLU] = 1973LLU;
22973+ stack[base + 46LLU] = 1981LLU;
2290622974 // arguments for call to emitvar
2290722975 stack[base + 47LLU] = stack[base + 8]/*fnid*/;
2290822976 stack[base + 48LLU] = stack[base + 16]/*content*/;
@@ -22913,13 +22981,13 @@
2291322981 label = 749LLU; // emitvar
2291422982 break;
2291522983 }
22916- case 1972LLU: // copy-back deleter (emitvar to ProcCall)
22984+ case 1980LLU: // copy-back deleter (emitvar to ProcCall)
2291722985 {
2291822986 // copy mutable arguments back from call to emitvar
22919- label = 1915LLU; // continue to roll stack
22987+ label = 1923LLU; // continue to roll stack
2292022988 break;
2292122989 }
22922- case 1973LLU: // return from emitvar to ProcCall
22990+ case 1981LLU: // return from emitvar to ProcCall
2292322991 {
2292422992 // copy mutable arguments back from call to emitvar
2292522993 printf("%s", ";");
@@ -22929,7 +22997,7 @@
2292922997 newstack[0] = (uint64_t)stack; // backup stack location
2293022998 newstack[1] = 1234567890;
2293122999 newstack[2] = base;
22932- newstack[3] = 1974LLU;
23000+ newstack[3] = 1982LLU;
2293323001 stack = newstack;
2293423002 // set stack-base & callee-address
2293523003 base = 4/*deloffset*/;
@@ -22936,27 +23004,27 @@
2293623004 label = 486LLU; // ~letdef
2293723005 break;
2293823006 }
22939- case 1974LLU: // return from ~letdef to ProcCall
23007+ case 1982LLU: // return from ~letdef to ProcCall
2294023008 {
2294123009 stack = (uint64_t *)stack[0];
2294223010 // releasing toplevel container
2294323011 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4));
2294423012
22945- label = 1871LLU; // alternative complete
23013+ label = 1879LLU; // alternative complete
2294623014 break;
2294723015 }
22948- case 1871LLU: // completed if-then-else
23016+ case 1879LLU: // completed if-then-else
2294923017 {
22950- label = 1867LLU; // consequent complete
23018+ label = 1875LLU; // consequent complete
2295123019 break;
2295223020 }
22953- case 1866LLU: // alternative
23021+ case 1874LLU: // alternative
2295423022 {
2295523023 fprintf(stderr, "%s", "in function ");
2295623024 // call reportid from ProcCall
22957- stack[base + 43LLU] = 1975LLU/*throw to this address*/;
23025+ stack[base + 43LLU] = 1983LLU/*throw to this address*/;
2295823026 stack[base + 44LLU] = base;
22959- stack[base + 45LLU] = 1976LLU;
23027+ stack[base + 45LLU] = 1984LLU;
2296023028 // arguments for call to reportid
2296123029 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2296223030 // set stack-base & callee-address
@@ -22964,20 +23032,20 @@
2296423032 label = 18446744073709551586LLU; // reportid
2296523033 break;
2296623034 }
22967- case 1975LLU: // copy-back deleter (reportid to ProcCall)
23035+ case 1983LLU: // copy-back deleter (reportid to ProcCall)
2296823036 {
2296923037 // copy mutable arguments back from call to reportid
22970- label = 1823LLU; // continue to roll stack
23038+ label = 1831LLU; // continue to roll stack
2297123039 break;
2297223040 }
22973- case 1976LLU: // return from reportid to ProcCall
23041+ case 1984LLU: // return from reportid to ProcCall
2297423042 {
2297523043 // copy mutable arguments back from call to reportid
2297623044 fprintf(stderr, "%s", " call to ");
2297723045 // call reportid from ProcCall
22978- stack[base + 43LLU] = 1977LLU/*throw to this address*/;
23046+ stack[base + 43LLU] = 1985LLU/*throw to this address*/;
2297923047 stack[base + 44LLU] = base;
22980- stack[base + 45LLU] = 1978LLU;
23048+ stack[base + 45LLU] = 1986LLU;
2298123049 // arguments for call to reportid
2298223050 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2298323051 // set stack-base & callee-address
@@ -22985,20 +23053,20 @@
2298523053 label = 18446744073709551586LLU; // reportid
2298623054 break;
2298723055 }
22988- case 1977LLU: // copy-back deleter (reportid to ProcCall)
23056+ case 1985LLU: // copy-back deleter (reportid to ProcCall)
2298923057 {
2299023058 // copy mutable arguments back from call to reportid
22991- label = 1823LLU; // continue to roll stack
23059+ label = 1831LLU; // continue to roll stack
2299223060 break;
2299323061 }
22994- case 1978LLU: // return from reportid to ProcCall
23062+ case 1986LLU: // return from reportid to ProcCall
2299523063 {
2299623064 // copy mutable arguments back from call to reportid
2299723065 fprintf(stderr, "%s", ": expected identifier or constant argument but found ");
2299823066 // call printtoken from ProcCall
22999- stack[base + 43LLU] = 1979LLU/*throw to this address*/;
23067+ stack[base + 43LLU] = 1987LLU/*throw to this address*/;
2300023068 stack[base + 44LLU] = base;
23001- stack[base + 45LLU] = 1980LLU;
23069+ stack[base + 45LLU] = 1988LLU;
2300223070 // arguments for call to printtoken
2300323071 stack[base + 46LLU] = stack[base + 15]/*variant*/;
2300423072 stack[base + 47LLU] = stack[base + 16]/*content*/;
@@ -23007,85 +23075,85 @@
2300723075 label = 18446744073709551583LLU; // printtoken
2300823076 break;
2300923077 }
23010- case 1979LLU: // copy-back deleter (printtoken to ProcCall)
23078+ case 1987LLU: // copy-back deleter (printtoken to ProcCall)
2301123079 {
2301223080 // copy mutable arguments back from call to printtoken
23013- label = 1823LLU; // continue to roll stack
23081+ label = 1831LLU; // continue to roll stack
2301423082 break;
2301523083 }
23016- case 1980LLU: // return from printtoken to ProcCall
23084+ case 1988LLU: // return from printtoken to ProcCall
2301723085 {
2301823086 // copy mutable arguments back from call to printtoken
2301923087 fprintf(stderr, "%s", "\n");
2302023088 {
23021- label = 1823LLU; // throw: begin to unroll stack
23089+ label = 1831LLU; // throw: begin to unroll stack
2302223090 break;
2302323091 }
2302423092
23025- label = 1867LLU; // alternative complete
23093+ label = 1875LLU; // alternative complete
2302623094 break;
2302723095 }
23028- case 1867LLU: // completed if-then-else
23096+ case 1875LLU: // completed if-then-else
2302923097 {
23030- label = 1829LLU; // alternative complete
23098+ label = 1837LLU; // alternative complete
2303123099 break;
2303223100 }
23033- case 1829LLU: // completed if-then-else
23101+ case 1837LLU: // completed if-then-else
2303423102 {
2303523103 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2303623104 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23037- label = 1821LLU; // case complete
23105+ label = 1829LLU; // case complete
2303823106 break;
2303923107 }
23040- case 1823LLU: // copy-back deleter (switch)
23108+ case 1831LLU: // copy-back deleter (switch)
2304123109 {
2304223110 ((uint64_t **)(stack[base + 39]))[1][1] = stack[base + 42];
2304323111 ((uint64_t **)(stack[base + 39]))[1][0] = stack[base + 41];
23044- label = 1820LLU; // continue to unroll stack
23112+ label = 1828LLU; // continue to unroll stack
2304523113 break;
2304623114 }
23047- case 1822LLU: // try next case
23115+ case 1830LLU: // try next case
2304823116 {
2304923117 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2305023118 exit(-1);
2305123119 }
23052- case 1821LLU: // completed switch
23120+ case 1829LLU: // completed switch
2305323121 {
2305423122 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2305523123 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23056- label = 1818LLU; // case complete
23124+ label = 1826LLU; // case complete
2305723125 break;
2305823126 }
23059- case 1820LLU: // copy-back deleter (switch)
23127+ case 1828LLU: // copy-back deleter (switch)
2306023128 {
2306123129 ((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
2306223130 ((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
23063- label = 1803LLU; // continue to unroll stack
23131+ label = 1811LLU; // continue to unroll stack
2306423132 break;
2306523133 }
23066- case 1819LLU: // try next case
23134+ case 1827LLU: // try next case
2306723135 {
2306823136 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2306923137 exit(-1);
2307023138 }
23071- case 1818LLU: // completed switch
23139+ case 1826LLU: // completed switch
2307223140 {
2307323141 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23074- label = 1801LLU; // repeat
23142+ label = 1809LLU; // repeat
2307523143 break;
2307623144 }
23077- case 1803LLU: // copy-back deleter for while next
23145+ case 1811LLU: // copy-back deleter for while next
2307823146 {
2307923147 ((struct listnode *)(stack[base + 38]/*previous*/))->data = stack[base + 37];
23080- label = 1799LLU; // continue to unroll stack
23148+ label = 1807LLU; // continue to unroll stack
2308123149 break;
2308223150 }
23083- case 1802LLU: // loop finished
23151+ case 1810LLU: // loop finished
2308423152 {
2308523153 // call equ from ProcCall
23086- stack[base + 39LLU] = 1981LLU/*throw to this address*/;
23154+ stack[base + 39LLU] = 1989LLU/*throw to this address*/;
2308723155 stack[base + 40LLU] = base;
23088- stack[base + 41LLU] = 1982LLU;
23156+ stack[base + 41LLU] = 1990LLU;
2308923157 // arguments for call to equ
2309023158 stack[base + 43LLU] = stack[base + 8]/*fnid*/;
2309123159 stack[base + 44LLU] = stack[base + 24]/*ceid*/;
@@ -23094,13 +23162,13 @@
2309423162 label = 18446744073709551600LLU; // equ
2309523163 break;
2309623164 }
23097- case 1981LLU: // copy-back deleter (equ to ProcCall)
23165+ case 1989LLU: // copy-back deleter (equ to ProcCall)
2309823166 {
2309923167 // copy mutable arguments back from call to equ
23100- label = 1799LLU; // continue to roll stack
23168+ label = 1807LLU; // continue to roll stack
2310123169 break;
2310223170 }
23103- case 1982LLU: // return from equ to ProcCall
23171+ case 1990LLU: // return from equ to ProcCall
2310423172 {
2310523173 // copy mutable arguments back from call to equ
2310623174 // copy back results provided by call to equ
@@ -23107,7 +23175,7 @@
2310723175 stack[base + 18] = stack[base + 42LLU];
2310823176 if(!stack[base + 18]/*isequal*/)
2310923177 {
23110- label = 1983LLU; // jump to alternative
23178+ label = 1991LLU; // jump to alternative
2311123179 break;
2311223180 }
2311323181
@@ -23114,21 +23182,21 @@
2311423182 // consequent
2311523183 if(!stack[base + 35]/*csubstruct*/)
2311623184 {
23117- label = 1985LLU; // jump to alternative
23185+ label = 1993LLU; // jump to alternative
2311823186 break;
2311923187 }
2312023188
2312123189 // consequent
23122- label = 1986LLU; // consequent complete
23190+ label = 1994LLU; // consequent complete
2312323191 break;
2312423192 }
23125- case 1985LLU: // alternative
23193+ case 1993LLU: // alternative
2312623194 {
2312723195 fprintf(stderr, "%s", "in function ");
2312823196 // call reportid from ProcCall
23129- stack[base + 39LLU] = 1987LLU/*throw to this address*/;
23197+ stack[base + 39LLU] = 1995LLU/*throw to this address*/;
2313023198 stack[base + 40LLU] = base;
23131- stack[base + 41LLU] = 1988LLU;
23199+ stack[base + 41LLU] = 1996LLU;
2313223200 // arguments for call to reportid
2313323201 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2313423202 // set stack-base & callee-address
@@ -23136,20 +23204,20 @@
2313623204 label = 18446744073709551586LLU; // reportid
2313723205 break;
2313823206 }
23139- case 1987LLU: // copy-back deleter (reportid to ProcCall)
23207+ case 1995LLU: // copy-back deleter (reportid to ProcCall)
2314023208 {
2314123209 // copy mutable arguments back from call to reportid
23142- label = 1799LLU; // continue to roll stack
23210+ label = 1807LLU; // continue to roll stack
2314323211 break;
2314423212 }
23145- case 1988LLU: // return from reportid to ProcCall
23213+ case 1996LLU: // return from reportid to ProcCall
2314623214 {
2314723215 // copy mutable arguments back from call to reportid
2314823216 fprintf(stderr, "%s", " recursive call to ");
2314923217 // call reportid from ProcCall
23150- stack[base + 39LLU] = 1989LLU/*throw to this address*/;
23218+ stack[base + 39LLU] = 1997LLU/*throw to this address*/;
2315123219 stack[base + 40LLU] = base;
23152- stack[base + 41LLU] = 1990LLU;
23220+ stack[base + 41LLU] = 1998LLU;
2315323221 // arguments for call to reportid
2315423222 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2315523223 // set stack-base & callee-address
@@ -23157,35 +23225,35 @@
2315723225 label = 18446744073709551586LLU; // reportid
2315823226 break;
2315923227 }
23160- case 1989LLU: // copy-back deleter (reportid to ProcCall)
23228+ case 1997LLU: // copy-back deleter (reportid to ProcCall)
2316123229 {
2316223230 // copy mutable arguments back from call to reportid
23163- label = 1799LLU; // continue to roll stack
23231+ label = 1807LLU; // continue to roll stack
2316423232 break;
2316523233 }
23166- case 1990LLU: // return from reportid to ProcCall
23234+ case 1998LLU: // return from reportid to ProcCall
2316723235 {
2316823236 // copy mutable arguments back from call to reportid
2316923237 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");
2317023238 {
23171- label = 1799LLU; // throw: begin to unroll stack
23239+ label = 1807LLU; // throw: begin to unroll stack
2317223240 break;
2317323241 }
2317423242
23175- label = 1986LLU; // alternative complete
23243+ label = 1994LLU; // alternative complete
2317623244 break;
2317723245 }
23178- case 1986LLU: // completed if-then-else
23246+ case 1994LLU: // completed if-then-else
2317923247 {
23180- label = 1984LLU; // consequent complete
23248+ label = 1992LLU; // consequent complete
2318123249 break;
2318223250 }
23183- case 1983LLU: // alternative
23251+ case 1991LLU: // alternative
2318423252 {
23185- label = 1984LLU; // alternative complete
23253+ label = 1992LLU; // alternative complete
2318623254 break;
2318723255 }
23188- case 1984LLU: // completed if-then-else
23256+ case 1992LLU: // completed if-then-else
2318923257 {
2319023258 printf("%s", "\n stack = newstack;");
2319123259 printf("%s", "\n // set stack-base & callee-address");
@@ -23192,9 +23260,9 @@
2319223260 printf("%s", "\n base = 4/*deloffset*/;");
2319323261 printf("%s", "\n label = ");
2319423262 // call printnr from ProcCall
23195- stack[base + 35LLU] = 1991LLU/*throw to this address*/;
23263+ stack[base + 35LLU] = 1999LLU/*throw to this address*/;
2319623264 stack[base + 36LLU] = base;
23197- stack[base + 37LLU] = 1992LLU;
23265+ stack[base + 37LLU] = 2000LLU;
2319823266 // arguments for call to printnr
2319923267 stack[base + 38LLU] = stack[base + 20]/*celabel*/;
2320023268 // set stack-base & callee-address
@@ -23202,20 +23270,20 @@
2320223270 label = 18446744073709551590LLU; // printnr
2320323271 break;
2320423272 }
23205- case 1991LLU: // copy-back deleter (printnr to ProcCall)
23273+ case 1999LLU: // copy-back deleter (printnr to ProcCall)
2320623274 {
2320723275 // copy mutable arguments back from call to printnr
23208- label = 1771LLU; // continue to roll stack
23276+ label = 1779LLU; // continue to roll stack
2320923277 break;
2321023278 }
23211- case 1992LLU: // return from printnr to ProcCall
23279+ case 2000LLU: // return from printnr to ProcCall
2321223280 {
2321323281 // copy mutable arguments back from call to printnr
2321423282 printf("%s", "LLU; // ");
2321523283 // call printid from ProcCall
23216- stack[base + 35LLU] = 1993LLU/*throw to this address*/;
23284+ stack[base + 35LLU] = 2001LLU/*throw to this address*/;
2321723285 stack[base + 36LLU] = base;
23218- stack[base + 37LLU] = 1994LLU;
23286+ stack[base + 37LLU] = 2002LLU;
2321923287 // arguments for call to printid
2322023288 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2322123289 // set stack-base & callee-address
@@ -23223,13 +23291,13 @@
2322323291 label = 18446744073709551587LLU; // printid
2322423292 break;
2322523293 }
23226- case 1993LLU: // copy-back deleter (printid to ProcCall)
23294+ case 2001LLU: // copy-back deleter (printid to ProcCall)
2322723295 {
2322823296 // copy mutable arguments back from call to printid
23229- label = 1771LLU; // continue to roll stack
23297+ label = 1779LLU; // continue to roll stack
2323023298 break;
2323123299 }
23232- case 1994LLU: // return from printid to ProcCall
23300+ case 2002LLU: // return from printid to ProcCall
2323323301 {
2323423302 // copy mutable arguments back from call to printid
2323523303 printf("%s", "\n break;");
@@ -23236,7 +23304,7 @@
2323623304 printf("%s", "\n }");
2323723305 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
2323823306 {
23239- label = 1996LLU; // jump to alternative
23307+ label = 2004LLU; // jump to alternative
2324023308 break;
2324123309 }
2324223310
@@ -23246,9 +23314,9 @@
2324623314 // case
2324723315 printf("%s", "\n case ");
2324823316 // call printnr from ProcCall
23249- stack[base + 37LLU] = 1998LLU/*throw to this address*/;
23317+ stack[base + 37LLU] = 2006LLU/*throw to this address*/;
2325023318 stack[base + 38LLU] = base;
23251- stack[base + 39LLU] = 1999LLU;
23319+ stack[base + 39LLU] = 2007LLU;
2325223320 // arguments for call to printnr
2325323321 stack[base + 40LLU] = stack[base + 33]/*labelfail*/;
2325423322 // set stack-base & callee-address
@@ -23256,20 +23324,20 @@
2325623324 label = 18446744073709551590LLU; // printnr
2325723325 break;
2325823326 }
23259- case 1998LLU: // copy-back deleter (printnr to ProcCall)
23327+ case 2006LLU: // copy-back deleter (printnr to ProcCall)
2326023328 {
2326123329 // copy mutable arguments back from call to printnr
23262- label = 1997LLU; // continue to roll stack
23330+ label = 2005LLU; // continue to roll stack
2326323331 break;
2326423332 }
23265- case 1999LLU: // return from printnr to ProcCall
23333+ case 2007LLU: // return from printnr to ProcCall
2326623334 {
2326723335 // copy mutable arguments back from call to printnr
2326823336 printf("%s", "LLU: // copy-back deleter (");
2326923337 // call printid from ProcCall
23270- stack[base + 37LLU] = 2000LLU/*throw to this address*/;
23338+ stack[base + 37LLU] = 2008LLU/*throw to this address*/;
2327123339 stack[base + 38LLU] = base;
23272- stack[base + 39LLU] = 2001LLU;
23340+ stack[base + 39LLU] = 2009LLU;
2327323341 // arguments for call to printid
2327423342 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2327523343 // set stack-base & callee-address
@@ -23277,20 +23345,20 @@
2327723345 label = 18446744073709551587LLU; // printid
2327823346 break;
2327923347 }
23280- case 2000LLU: // copy-back deleter (printid to ProcCall)
23348+ case 2008LLU: // copy-back deleter (printid to ProcCall)
2328123349 {
2328223350 // copy mutable arguments back from call to printid
23283- label = 1997LLU; // continue to roll stack
23351+ label = 2005LLU; // continue to roll stack
2328423352 break;
2328523353 }
23286- case 2001LLU: // return from printid to ProcCall
23354+ case 2009LLU: // return from printid to ProcCall
2328723355 {
2328823356 // copy mutable arguments back from call to printid
2328923357 printf("%s", " to ");
2329023358 // call printid from ProcCall
23291- stack[base + 37LLU] = 2002LLU/*throw to this address*/;
23359+ stack[base + 37LLU] = 2010LLU/*throw to this address*/;
2329223360 stack[base + 38LLU] = base;
23293- stack[base + 39LLU] = 2003LLU;
23361+ stack[base + 39LLU] = 2011LLU;
2329423362 // arguments for call to printid
2329523363 stack[base + 40LLU] = stack[base + 8]/*fnid*/;
2329623364 // set stack-base & callee-address
@@ -23298,13 +23366,13 @@
2329823366 label = 18446744073709551587LLU; // printid
2329923367 break;
2330023368 }
23301- case 2002LLU: // copy-back deleter (printid to ProcCall)
23369+ case 2010LLU: // copy-back deleter (printid to ProcCall)
2330223370 {
2330323371 // copy mutable arguments back from call to printid
23304- label = 1997LLU; // continue to roll stack
23372+ label = 2005LLU; // continue to roll stack
2330523373 break;
2330623374 }
23307- case 2003LLU: // return from printid to ProcCall
23375+ case 2011LLU: // return from printid to ProcCall
2330823376 {
2330923377 // copy mutable arguments back from call to printid
2331023378 printf("%s", ")");
@@ -23312,9 +23380,9 @@
2331223380 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2331323381 printf("%s", "\n // copy mutable arguments back from call to ");
2331423382 // call printid from ProcCall
23315- stack[base + 37LLU] = 2004LLU/*throw to this address*/;
23383+ stack[base + 37LLU] = 2012LLU/*throw to this address*/;
2331623384 stack[base + 38LLU] = base;
23317- stack[base + 39LLU] = 2005LLU;
23385+ stack[base + 39LLU] = 2013LLU;
2331823386 // arguments for call to printid
2331923387 stack[base + 40LLU] = stack[base + 24]/*ceid*/;
2332023388 // set stack-base & callee-address
@@ -23322,24 +23390,24 @@
2332223390 label = 18446744073709551587LLU; // printid
2332323391 break;
2332423392 }
23325- case 2004LLU: // copy-back deleter (printid to ProcCall)
23393+ case 2012LLU: // copy-back deleter (printid to ProcCall)
2332623394 {
2332723395 // copy mutable arguments back from call to printid
23328- label = 1997LLU; // continue to roll stack
23396+ label = 2005LLU; // continue to roll stack
2332923397 break;
2333023398 }
23331- case 2005LLU: // return from printid to ProcCall
23399+ case 2013LLU: // return from printid to ProcCall
2333223400 {
2333323401 // copy mutable arguments back from call to printid
2333423402 flippedassign(stack[base + 19]/*copyback*/, &stack[base + 37]);
23335- label = 2006LLU; // start to repeat
23403+ label = 2014LLU; // start to repeat
2333623404 break;
2333723405 }
23338- case 2006LLU: // repeat from here
23406+ case 2014LLU: // repeat from here
2333923407 {
2334023408 if(!stack[base + 37])
2334123409 {
23342- label = 2007LLU; // break loop
23410+ label = 2015LLU; // break loop
2334323411 break;
2334423412 }
2334523413
@@ -23349,7 +23417,7 @@
2334923417 stack[base + 37] = (uint64_t)(((const struct listnode *)(stack[base + 37]))->next);
2335023418 if(/*idnr*/0 != ((uint64_t *)(stack[base + 38]/*idnr*/))[0])
2335123419 {
23352- label = 2010LLU; // jump to alternative
23420+ label = 2018LLU; // jump to alternative
2335323421 break;
2335423422 }
2335523423
@@ -23359,9 +23427,9 @@
2335923427 // case
2336023428 printf("%s", "\n old");
2336123429 // call emitvar from ProcCall
23362- stack[base + 42LLU] = 2012LLU/*throw to this address*/;
23430+ stack[base + 42LLU] = 2020LLU/*throw to this address*/;
2336323431 stack[base + 43LLU] = base;
23364- stack[base + 44LLU] = 2013LLU;
23432+ stack[base + 44LLU] = 2021LLU;
2336523433 // arguments for call to emitvar
2336623434 stack[base + 45LLU] = stack[base + 8]/*fnid*/;
2336723435 stack[base + 46LLU] = stack[base + 40]/*content*/;
@@ -23372,20 +23440,20 @@
2337223440 label = 749LLU; // emitvar
2337323441 break;
2337423442 }
23375- case 2012LLU: // copy-back deleter (emitvar to ProcCall)
23443+ case 2020LLU: // copy-back deleter (emitvar to ProcCall)
2337623444 {
2337723445 // copy mutable arguments back from call to emitvar
23378- label = 2011LLU; // continue to roll stack
23446+ label = 2019LLU; // continue to roll stack
2337923447 break;
2338023448 }
23381- case 2013LLU: // return from emitvar to ProcCall
23449+ case 2021LLU: // return from emitvar to ProcCall
2338223450 {
2338323451 // copy mutable arguments back from call to emitvar
2338423452 printf("%s", " = stack[");
2338523453 // call printnr from ProcCall
23386- stack[base + 42LLU] = 2014LLU/*throw to this address*/;
23454+ stack[base + 42LLU] = 2022LLU/*throw to this address*/;
2338723455 stack[base + 43LLU] = base;
23388- stack[base + 44LLU] = 2015LLU;
23456+ stack[base + 44LLU] = 2023LLU;
2338923457 // arguments for call to printnr
2339023458 stack[base + 45LLU] = stack[base + 41]/*sum*/;
2339123459 // set stack-base & callee-address
@@ -23393,52 +23461,52 @@
2339323461 label = 18446744073709551590LLU; // printnr
2339423462 break;
2339523463 }
23396- case 2014LLU: // copy-back deleter (printnr to ProcCall)
23464+ case 2022LLU: // copy-back deleter (printnr to ProcCall)
2339723465 {
2339823466 // copy mutable arguments back from call to printnr
23399- label = 2011LLU; // continue to roll stack
23467+ label = 2019LLU; // continue to roll stack
2340023468 break;
2340123469 }
23402- case 2015LLU: // return from printnr to ProcCall
23470+ case 2023LLU: // return from printnr to ProcCall
2340323471 {
2340423472 // copy mutable arguments back from call to printnr
2340523473 printf("%s", "LLU];");
2340623474 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2340723475 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23408- label = 2009LLU; // case complete
23476+ label = 2017LLU; // case complete
2340923477 break;
2341023478 }
23411- case 2011LLU: // copy-back deleter (switch)
23479+ case 2019LLU: // copy-back deleter (switch)
2341223480 {
2341323481 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 41];
2341423482 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 40];
23415- label = 2008LLU; // continue to unroll stack
23483+ label = 2016LLU; // continue to unroll stack
2341623484 break;
2341723485 }
23418- case 2010LLU: // try next case
23486+ case 2018LLU: // try next case
2341923487 {
2342023488 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2342123489 exit(-1);
2342223490 }
23423- case 2009LLU: // completed switch
23491+ case 2017LLU: // completed switch
2342423492 {
2342523493 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23426- label = 2006LLU; // repeat
23494+ label = 2014LLU; // repeat
2342723495 break;
2342823496 }
23429- case 2008LLU: // copy-back deleter for while next
23497+ case 2016LLU: // copy-back deleter for while next
2343023498 {
2343123499 ((struct listnode *)(stack[base + 39]/*previous*/))->data = stack[base + 38];
23432- label = 1997LLU; // continue to unroll stack
23500+ label = 2005LLU; // continue to unroll stack
2343323501 break;
2343423502 }
23435- case 2007LLU: // loop finished
23503+ case 2015LLU: // loop finished
2343623504 {
2343723505 printf("%s", "\n if(stack[");
2343823506 // call printnr from ProcCall
23439- stack[base + 40LLU] = 2016LLU/*throw to this address*/;
23507+ stack[base + 40LLU] = 2024LLU/*throw to this address*/;
2344023508 stack[base + 41LLU] = base;
23441- stack[base + 42LLU] = 2017LLU;
23509+ stack[base + 42LLU] = 2025LLU;
2344223510 // arguments for call to printnr
2344323511 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2344423512 // set stack-base & callee-address
@@ -23446,13 +23514,13 @@
2344623514 label = 18446744073709551590LLU; // printnr
2344723515 break;
2344823516 }
23449- case 2016LLU: // copy-back deleter (printnr to ProcCall)
23517+ case 2024LLU: // copy-back deleter (printnr to ProcCall)
2345023518 {
2345123519 // copy mutable arguments back from call to printnr
23452- label = 1997LLU; // continue to roll stack
23520+ label = 2005LLU; // continue to roll stack
2345323521 break;
2345423522 }
23455- case 2017LLU: // return from printnr to ProcCall
23523+ case 2025LLU: // return from printnr to ProcCall
2345623524 {
2345723525 // copy mutable arguments back from call to printnr
2345823526 printf("%s", "LLU] != 9876543210LLU)");
@@ -23459,9 +23527,9 @@
2345923527 printf("%s", "\n {");
2346023528 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2346123529 // call printid from ProcCall
23462- stack[base + 40LLU] = 2018LLU/*throw to this address*/;
23530+ stack[base + 40LLU] = 2026LLU/*throw to this address*/;
2346323531 stack[base + 41LLU] = base;
23464- stack[base + 42LLU] = 2019LLU;
23532+ stack[base + 42LLU] = 2027LLU;
2346523533 // arguments for call to printid
2346623534 stack[base + 43LLU] = stack[base + 24]/*ceid*/;
2346723535 // set stack-base & callee-address
@@ -23469,13 +23537,13 @@
2346923537 label = 18446744073709551587LLU; // printid
2347023538 break;
2347123539 }
23472- case 2018LLU: // copy-back deleter (printid to ProcCall)
23540+ case 2026LLU: // copy-back deleter (printid to ProcCall)
2347323541 {
2347423542 // copy mutable arguments back from call to printid
23475- label = 1997LLU; // continue to roll stack
23543+ label = 2005LLU; // continue to roll stack
2347623544 break;
2347723545 }
23478- case 2019LLU: // return from printid to ProcCall
23546+ case 2027LLU: // return from printid to ProcCall
2347923547 {
2348023548 // copy mutable arguments back from call to printid
2348123549 printf("%s", ")!\\n\");");
@@ -23483,9 +23551,9 @@
2348323551 printf("%s", "\n }");
2348423552 printf("%s", "\n Free(");
2348523553 // call printnr from ProcCall
23486- stack[base + 40LLU] = 2020LLU/*throw to this address*/;
23554+ stack[base + 40LLU] = 2028LLU/*throw to this address*/;
2348723555 stack[base + 41LLU] = base;
23488- stack[base + 42LLU] = 2021LLU;
23556+ stack[base + 42LLU] = 2029LLU;
2348923557 // arguments for call to printnr
2349023558 stack[base + 43LLU] = stack[base + 34]/*recsztotal*/;
2349123559 // set stack-base & callee-address
@@ -23493,13 +23561,13 @@
2349323561 label = 18446744073709551590LLU; // printnr
2349423562 break;
2349523563 }
23496- case 2020LLU: // copy-back deleter (printnr to ProcCall)
23564+ case 2028LLU: // copy-back deleter (printnr to ProcCall)
2349723565 {
2349823566 // copy mutable arguments back from call to printnr
23499- label = 1997LLU; // continue to roll stack
23567+ label = 2005LLU; // continue to roll stack
2350023568 break;
2350123569 }
23502- case 2021LLU: // return from printnr to ProcCall
23570+ case 2029LLU: // return from printnr to ProcCall
2350323571 {
2350423572 // copy mutable arguments back from call to printnr
2350523573 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
@@ -23506,9 +23574,9 @@
2350623574 printf("%s", "\n stack = oldstack;");
2350723575 printf("%s", "\n label = ");
2350823576 // call printnr from ProcCall
23509- stack[base + 40LLU] = 2022LLU/*throw to this address*/;
23577+ stack[base + 40LLU] = 2030LLU/*throw to this address*/;
2351023578 stack[base + 41LLU] = base;
23511- stack[base + 42LLU] = 2023LLU;
23579+ stack[base + 42LLU] = 2031LLU;
2351223580 // arguments for call to printnr
2351323581 stack[base + 43LLU] = stack[base + 35]/*labelthrow*/;
2351423582 // set stack-base & callee-address
@@ -23516,13 +23584,13 @@
2351623584 label = 18446744073709551590LLU; // printnr
2351723585 break;
2351823586 }
23519- case 2022LLU: // copy-back deleter (printnr to ProcCall)
23587+ case 2030LLU: // copy-back deleter (printnr to ProcCall)
2352023588 {
2352123589 // copy mutable arguments back from call to printnr
23522- label = 1997LLU; // continue to roll stack
23590+ label = 2005LLU; // continue to roll stack
2352323591 break;
2352423592 }
23525- case 2023LLU: // return from printnr to ProcCall
23593+ case 2031LLU: // return from printnr to ProcCall
2352623594 {
2352723595 // copy mutable arguments back from call to printnr
2352823596 printf("%s", "LLU; // continue to unroll stack");
@@ -23530,28 +23598,28 @@
2353023598 printf("%s", "\n }");
2353123599 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2353223600 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23533- label = 1995LLU; // case complete
23601+ label = 2003LLU; // case complete
2353423602 break;
2353523603 }
23536- case 1997LLU: // copy-back deleter (switch)
23604+ case 2005LLU: // copy-back deleter (switch)
2353723605 {
2353823606 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 36];
2353923607 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 35];
23540- label = 1771LLU; // continue to unroll stack
23608+ label = 1779LLU; // continue to unroll stack
2354123609 break;
2354223610 }
23543- case 1996LLU: // try next case
23611+ case 2004LLU: // try next case
2354423612 {
2354523613 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2354623614 exit(-1);
2354723615 }
23548- case 1995LLU: // completed switch
23616+ case 2003LLU: // completed switch
2354923617 {
2355023618 printf("%s", "\n case ");
2355123619 // call printnr from ProcCall
23552- stack[base + 35LLU] = 2024LLU/*throw to this address*/;
23620+ stack[base + 35LLU] = 2032LLU/*throw to this address*/;
2355323621 stack[base + 36LLU] = base;
23554- stack[base + 37LLU] = 2025LLU;
23622+ stack[base + 37LLU] = 2033LLU;
2355523623 // arguments for call to printnr
2355623624 stack[base + 38LLU] = stack[base + 17]/*label*/;
2355723625 // set stack-base & callee-address
@@ -23559,20 +23627,20 @@
2355923627 label = 18446744073709551590LLU; // printnr
2356023628 break;
2356123629 }
23562- case 2024LLU: // copy-back deleter (printnr to ProcCall)
23630+ case 2032LLU: // copy-back deleter (printnr to ProcCall)
2356323631 {
2356423632 // copy mutable arguments back from call to printnr
23565- label = 1771LLU; // continue to roll stack
23633+ label = 1779LLU; // continue to roll stack
2356623634 break;
2356723635 }
23568- case 2025LLU: // return from printnr to ProcCall
23636+ case 2033LLU: // return from printnr to ProcCall
2356923637 {
2357023638 // copy mutable arguments back from call to printnr
2357123639 printf("%s", "LLU: // return from ");
2357223640 // call printid from ProcCall
23573- stack[base + 35LLU] = 2026LLU/*throw to this address*/;
23641+ stack[base + 35LLU] = 2034LLU/*throw to this address*/;
2357423642 stack[base + 36LLU] = base;
23575- stack[base + 37LLU] = 2027LLU;
23643+ stack[base + 37LLU] = 2035LLU;
2357623644 // arguments for call to printid
2357723645 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2357823646 // set stack-base & callee-address
@@ -23580,20 +23648,20 @@
2358023648 label = 18446744073709551587LLU; // printid
2358123649 break;
2358223650 }
23583- case 2026LLU: // copy-back deleter (printid to ProcCall)
23651+ case 2034LLU: // copy-back deleter (printid to ProcCall)
2358423652 {
2358523653 // copy mutable arguments back from call to printid
23586- label = 1771LLU; // continue to roll stack
23654+ label = 1779LLU; // continue to roll stack
2358723655 break;
2358823656 }
23589- case 2027LLU: // return from printid to ProcCall
23657+ case 2035LLU: // return from printid to ProcCall
2359023658 {
2359123659 // copy mutable arguments back from call to printid
2359223660 printf("%s", " to ");
2359323661 // call printid from ProcCall
23594- stack[base + 35LLU] = 2028LLU/*throw to this address*/;
23662+ stack[base + 35LLU] = 2036LLU/*throw to this address*/;
2359523663 stack[base + 36LLU] = base;
23596- stack[base + 37LLU] = 2029LLU;
23664+ stack[base + 37LLU] = 2037LLU;
2359723665 // arguments for call to printid
2359823666 stack[base + 38LLU] = stack[base + 8]/*fnid*/;
2359923667 // set stack-base & callee-address
@@ -23601,13 +23669,13 @@
2360123669 label = 18446744073709551587LLU; // printid
2360223670 break;
2360323671 }
23604- case 2028LLU: // copy-back deleter (printid to ProcCall)
23672+ case 2036LLU: // copy-back deleter (printid to ProcCall)
2360523673 {
2360623674 // copy mutable arguments back from call to printid
23607- label = 1771LLU; // continue to roll stack
23675+ label = 1779LLU; // continue to roll stack
2360823676 break;
2360923677 }
23610- case 2029LLU: // return from printid to ProcCall
23678+ case 2037LLU: // return from printid to ProcCall
2361123679 {
2361223680 // copy mutable arguments back from call to printid
2361323681 printf("%s", "\n {");
@@ -23614,9 +23682,9 @@
2361423682 printf("%s", "\n uint64_t *oldstack = (uint64_t *)stack[0];");
2361523683 printf("%s", "\n // copy mutable arguments back from call to ");
2361623684 // call printid from ProcCall
23617- stack[base + 35LLU] = 2030LLU/*throw to this address*/;
23685+ stack[base + 35LLU] = 2038LLU/*throw to this address*/;
2361823686 stack[base + 36LLU] = base;
23619- stack[base + 37LLU] = 2031LLU;
23687+ stack[base + 37LLU] = 2039LLU;
2362023688 // arguments for call to printid
2362123689 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2362223690 // set stack-base & callee-address
@@ -23624,23 +23692,23 @@
2362423692 label = 18446744073709551587LLU; // printid
2362523693 break;
2362623694 }
23627- case 2030LLU: // copy-back deleter (printid to ProcCall)
23695+ case 2038LLU: // copy-back deleter (printid to ProcCall)
2362823696 {
2362923697 // copy mutable arguments back from call to printid
23630- label = 1771LLU; // continue to roll stack
23698+ label = 1779LLU; // continue to roll stack
2363123699 break;
2363223700 }
23633- case 2031LLU: // return from printid to ProcCall
23701+ case 2039LLU: // return from printid to ProcCall
2363423702 {
2363523703 // copy mutable arguments back from call to printid
23636- label = 2032LLU; // start to repeat
23704+ label = 2040LLU; // start to repeat
2363723705 break;
2363823706 }
23639- case 2032LLU: // repeat from here
23707+ case 2040LLU: // repeat from here
2364023708 {
2364123709 if(!stack[base + 19])
2364223710 {
23643- label = 2033LLU; // break loop
23711+ label = 2041LLU; // break loop
2364423712 break;
2364523713 }
2364623714
@@ -23653,7 +23721,7 @@
2365323721 }
2365423722 if(/*idnr*/0 != ((uint64_t *)(stack[base + 35]/*idnr*/))[0])
2365523723 {
23656- label = 2036LLU; // jump to alternative
23724+ label = 2044LLU; // jump to alternative
2365723725 break;
2365823726 }
2365923727
@@ -23663,9 +23731,9 @@
2366323731 // case
2366423732 printf("%s", "\n old");
2366523733 // call emitvar from ProcCall
23666- stack[base + 38LLU] = 2038LLU/*throw to this address*/;
23734+ stack[base + 38LLU] = 2046LLU/*throw to this address*/;
2366723735 stack[base + 39LLU] = base;
23668- stack[base + 40LLU] = 2039LLU;
23736+ stack[base + 40LLU] = 2047LLU;
2366923737 // arguments for call to emitvar
2367023738 stack[base + 41LLU] = stack[base + 8]/*fnid*/;
2367123739 stack[base + 42LLU] = stack[base + 36]/*content*/;
@@ -23676,20 +23744,20 @@
2367623744 label = 749LLU; // emitvar
2367723745 break;
2367823746 }
23679- case 2038LLU: // copy-back deleter (emitvar to ProcCall)
23747+ case 2046LLU: // copy-back deleter (emitvar to ProcCall)
2368023748 {
2368123749 // copy mutable arguments back from call to emitvar
23682- label = 2037LLU; // continue to roll stack
23750+ label = 2045LLU; // continue to roll stack
2368323751 break;
2368423752 }
23685- case 2039LLU: // return from emitvar to ProcCall
23753+ case 2047LLU: // return from emitvar to ProcCall
2368623754 {
2368723755 // copy mutable arguments back from call to emitvar
2368823756 printf("%s", " = stack[");
2368923757 // call printnr from ProcCall
23690- stack[base + 38LLU] = 2040LLU/*throw to this address*/;
23758+ stack[base + 38LLU] = 2048LLU/*throw to this address*/;
2369123759 stack[base + 39LLU] = base;
23692- stack[base + 40LLU] = 2041LLU;
23760+ stack[base + 40LLU] = 2049LLU;
2369323761 // arguments for call to printnr
2369423762 stack[base + 41LLU] = stack[base + 37]/*sum*/;
2369523763 // set stack-base & callee-address
@@ -23697,34 +23765,34 @@
2369723765 label = 18446744073709551590LLU; // printnr
2369823766 break;
2369923767 }
23700- case 2040LLU: // copy-back deleter (printnr to ProcCall)
23768+ case 2048LLU: // copy-back deleter (printnr to ProcCall)
2370123769 {
2370223770 // copy mutable arguments back from call to printnr
23703- label = 2037LLU; // continue to roll stack
23771+ label = 2045LLU; // continue to roll stack
2370423772 break;
2370523773 }
23706- case 2041LLU: // return from printnr to ProcCall
23774+ case 2049LLU: // return from printnr to ProcCall
2370723775 {
2370823776 // copy mutable arguments back from call to printnr
2370923777 printf("%s", "LLU];");
2371023778 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2371123779 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23712- label = 2035LLU; // case complete
23780+ label = 2043LLU; // case complete
2371323781 break;
2371423782 }
23715- case 2037LLU: // copy-back deleter (switch)
23783+ case 2045LLU: // copy-back deleter (switch)
2371623784 {
2371723785 ((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 37];
2371823786 ((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 36];
23719- label = 2034LLU; // continue to unroll stack
23787+ label = 2042LLU; // continue to unroll stack
2372023788 break;
2372123789 }
23722- case 2036LLU: // try next case
23790+ case 2044LLU: // try next case
2372323791 {
2372423792 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2372523793 exit(-1);
2372623794 }
23727- case 2035LLU: // completed switch
23795+ case 2043LLU: // completed switch
2372823796 {
2372923797
2373023798 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23732,7 +23800,7 @@
2373223800 newstack[0] = (uint64_t)stack; // backup stack location
2373323801 newstack[1] = 1234567890;
2373423802 newstack[2] = base;
23735- newstack[3] = 2042LLU;
23803+ newstack[3] = 2050LLU;
2373623804 stack = newstack;
2373723805 // set stack-base & callee-address
2373823806 base = 4/*deloffset*/;
@@ -23739,16 +23807,16 @@
2373923807 label = 833LLU; // ~idnr
2374023808 break;
2374123809 }
23742- case 2042LLU: // return from ~idnr to ProcCall
23810+ case 2050LLU: // return from ~idnr to ProcCall
2374323811 {
2374423812 stack = (uint64_t *)stack[0];
2374523813 // releasing toplevel container
2374623814 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2374723815
23748- label = 2032LLU; // repeat
23816+ label = 2040LLU; // repeat
2374923817 break;
2375023818 }
23751- case 2034LLU: // copy-back deleter for while next
23819+ case 2042LLU: // copy-back deleter for while next
2375223820 {
2375323821
2375423822 uint64_t *newstack = (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4);
@@ -23756,7 +23824,7 @@
2375623824 newstack[0] = (uint64_t)stack; // backup stack location
2375723825 newstack[1] = 1234567890;
2375823826 newstack[2] = base;
23759- newstack[3] = 2043LLU;
23827+ newstack[3] = 2051LLU;
2376023828 stack = newstack;
2376123829 // set stack-base & callee-address
2376223830 base = 4/*deloffset*/;
@@ -23763,20 +23831,20 @@
2376323831 label = 833LLU; // ~idnr
2376423832 break;
2376523833 }
23766- case 2043LLU: // return from ~idnr to ProcCall
23834+ case 2051LLU: // return from ~idnr to ProcCall
2376723835 {
2376823836 stack = (uint64_t *)stack[0];
2376923837 // releasing toplevel container
2377023838 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 35] - sizeof(uint64_t) * 4));
2377123839
23772- label = 1771LLU; // continue to unroll stack
23840+ label = 1779LLU; // continue to unroll stack
2377323841 break;
2377423842 }
23775- case 2033LLU: // loop finished
23843+ case 2041LLU: // loop finished
2377623844 {
2377723845 if(!stack[base + 28]/*cerescount*/)
2377823846 {
23779- label = 2044LLU; // jump to alternative
23847+ label = 2052LLU; // jump to alternative
2378023848 break;
2378123849 }
2378223850
@@ -23783,9 +23851,9 @@
2378323851 // consequent
2378423852 printf("%s", "\n // copy back results provided by call to ");
2378523853 // call printid from ProcCall
23786- stack[base + 35LLU] = 2046LLU/*throw to this address*/;
23854+ stack[base + 35LLU] = 2054LLU/*throw to this address*/;
2378723855 stack[base + 36LLU] = base;
23788- stack[base + 37LLU] = 2047LLU;
23856+ stack[base + 37LLU] = 2055LLU;
2378923857 // arguments for call to printid
2379023858 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2379123859 // set stack-base & callee-address
@@ -23793,25 +23861,25 @@
2379323861 label = 18446744073709551587LLU; // printid
2379423862 break;
2379523863 }
23796- case 2046LLU: // copy-back deleter (printid to ProcCall)
23864+ case 2054LLU: // copy-back deleter (printid to ProcCall)
2379723865 {
2379823866 // copy mutable arguments back from call to printid
23799- label = 1771LLU; // continue to roll stack
23867+ label = 1779LLU; // continue to roll stack
2380023868 break;
2380123869 }
23802- case 2047LLU: // return from printid to ProcCall
23870+ case 2055LLU: // return from printid to ProcCall
2380323871 {
2380423872 // copy mutable arguments back from call to printid
2380523873 stack[base + 31]/*n*/ = stack[base + 28]/*cerescount*/;
2380623874 flippedassign(stack[base + 21]/*cerestypes*/, &stack[base + 35]);
23807- label = 2048LLU; // start to repeat
23875+ label = 2056LLU; // start to repeat
2380823876 break;
2380923877 }
23810- case 2048LLU: // repeat from here
23878+ case 2056LLU: // repeat from here
2381123879 {
2381223880 if(!stack[base + 35])
2381323881 {
23814- label = 2049LLU; // break loop
23882+ label = 2057LLU; // break loop
2381523883 break;
2381623884 }
2381723885
@@ -23820,9 +23888,9 @@
2382023888 stack[base + 37]/*previous*/ = stack[base + 35];
2382123889 stack[base + 35] = (uint64_t)(((const struct listnode *)(stack[base + 35]))->next);
2382223890 // call sub from ProcCall
23823- stack[base + 38LLU] = 2051LLU/*throw to this address*/;
23891+ stack[base + 38LLU] = 2059LLU/*throw to this address*/;
2382423892 stack[base + 39LLU] = base;
23825- stack[base + 40LLU] = 2052LLU;
23893+ stack[base + 40LLU] = 2060LLU;
2382623894 // arguments for call to sub
2382723895 stack[base + 42LLU] = stack[base + 28]/*cerescount*/;
2382823896 stack[base + 43LLU] = stack[base + 31]/*n*/;
@@ -23831,21 +23899,21 @@
2383123899 label = 18446744073709551604LLU; // sub
2383223900 break;
2383323901 }
23834- case 2051LLU: // copy-back deleter (sub to ProcCall)
23902+ case 2059LLU: // copy-back deleter (sub to ProcCall)
2383523903 {
2383623904 // copy mutable arguments back from call to sub
23837- label = 2050LLU; // continue to roll stack
23905+ label = 2058LLU; // continue to roll stack
2383823906 break;
2383923907 }
23840- case 2052LLU: // return from sub to ProcCall
23908+ case 2060LLU: // return from sub to ProcCall
2384123909 {
2384223910 // copy mutable arguments back from call to sub
2384323911 // copy back results provided by call to sub
2384423912 stack[base + 32] = stack[base + 41LLU];
2384523913 // call sub from ProcCall
23846- stack[base + 38LLU] = 2053LLU/*throw to this address*/;
23914+ stack[base + 38LLU] = 2061LLU/*throw to this address*/;
2384723915 stack[base + 39LLU] = base;
23848- stack[base + 40LLU] = 2054LLU;
23916+ stack[base + 40LLU] = 2062LLU;
2384923917 // arguments for call to sub
2385023918 stack[base + 42LLU] = stack[base + 31]/*n*/;
2385123919 stack[base + 43LLU] = 1LLU;
@@ -23854,13 +23922,13 @@
2385423922 label = 18446744073709551604LLU; // sub
2385523923 break;
2385623924 }
23857- case 2053LLU: // copy-back deleter (sub to ProcCall)
23925+ case 2061LLU: // copy-back deleter (sub to ProcCall)
2385823926 {
2385923927 // copy mutable arguments back from call to sub
23860- label = 2050LLU; // continue to roll stack
23928+ label = 2058LLU; // continue to roll stack
2386123929 break;
2386223930 }
23863- case 2054LLU: // return from sub to ProcCall
23931+ case 2062LLU: // return from sub to ProcCall
2386423932 {
2386523933 // copy mutable arguments back from call to sub
2386623934 // copy back results provided by call to sub
@@ -23869,7 +23937,7 @@
2386923937 struct listnode *list = (struct listnode *)stack[base + 0]/*dsttypeids*/;
2387023938 if(!list)
2387123939 {
23872- label = 2055LLU; // jump to alternative
23940+ label = 2063LLU; // jump to alternative
2387323941 break;
2387423942 }
2387523943
@@ -23881,7 +23949,7 @@
2388123949 }
2388223950 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 38]/*typeidx*/))[0])
2388323951 {
23884- label = 2059LLU; // jump to alternative
23952+ label = 2067LLU; // jump to alternative
2388523953 break;
2388623954 }
2388723955
@@ -23891,7 +23959,7 @@
2389123959 // case
2389223960 if(/*result*/0 != ((uint64_t *)(stack[base + 36]/*result*/))[0])
2389323961 {
23894- label = 2062LLU; // jump to alternative
23962+ label = 2070LLU; // jump to alternative
2389523963 break;
2389623964 }
2389723965
@@ -23902,7 +23970,7 @@
2390223970 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2390323971 if(!newstack)
2390423972 {
23905- label = 2063LLU; // throw: begin to unroll stack
23973+ label = 2071LLU; // throw: begin to unroll stack
2390623974 break;
2390723975 }
2390823976
@@ -23909,9 +23977,9 @@
2390923977 newstack[15LLU] = 9876543210LLU; // overflow-marker
2391023978 // call equtype from ProcCall
2391123979 newstack[0] = (uint64_t)stack; // backup stack location
23912- newstack[1] = 2064LLU;
23980+ newstack[1] = 2072LLU;
2391323981 newstack[2] = base;
23914- newstack[3] = 2065LLU;
23982+ newstack[3] = 2073LLU;
2391523983 // arguments for call to equtype
2391623984 newstack[5LLU] = stack[base + 39]/*dsttype*/;
2391723985 newstack[6LLU] = stack[base + 41]/*srctype*/;
@@ -23921,7 +23989,7 @@
2392123989 label = 359LLU; // equtype
2392223990 break;
2392323991 }
23924- case 2064LLU: // copy-back deleter (equtype to ProcCall)
23992+ case 2072LLU: // copy-back deleter (equtype to ProcCall)
2392523993 {
2392623994 uint64_t *oldstack = (uint64_t *)stack[0];
2392723995 // copy mutable arguments back from call to equtype
@@ -23932,10 +24000,10 @@
2393224000 }
2393324001 Free(15LLU + 1, sizeof(uint64_t), stack);
2393424002 stack = oldstack;
23935- label = 2063LLU; // continue to unroll stack
24003+ label = 2071LLU; // continue to unroll stack
2393624004 break;
2393724005 }
23938- case 2065LLU: // return from equtype to ProcCall
24006+ case 2073LLU: // return from equtype to ProcCall
2393924007 {
2394024008 uint64_t *oldstack = (uint64_t *)stack[0];
2394124009 // copy mutable arguments back from call to equtype
@@ -23950,21 +24018,21 @@
2395024018 stack = oldstack;
2395124019 if(!stack[base + 18]/*isequal*/)
2395224020 {
23953- label = 2066LLU; // jump to alternative
24021+ label = 2074LLU; // jump to alternative
2395424022 break;
2395524023 }
2395624024
2395724025 // consequent
23958- label = 2067LLU; // consequent complete
24026+ label = 2075LLU; // consequent complete
2395924027 break;
2396024028 }
23961- case 2066LLU: // alternative
24029+ case 2074LLU: // alternative
2396224030 {
2396324031 fprintf(stderr, "%s", "in function ");
2396424032 // call reportid from ProcCall
23965- stack[base + 43LLU] = 2068LLU/*throw to this address*/;
24033+ stack[base + 43LLU] = 2076LLU/*throw to this address*/;
2396624034 stack[base + 44LLU] = base;
23967- stack[base + 45LLU] = 2069LLU;
24035+ stack[base + 45LLU] = 2077LLU;
2396824036 // arguments for call to reportid
2396924037 stack[base + 46LLU] = stack[base + 8]/*fnid*/;
2397024038 // set stack-base & callee-address
@@ -23972,20 +24040,20 @@
2397224040 label = 18446744073709551586LLU; // reportid
2397324041 break;
2397424042 }
23975- case 2068LLU: // copy-back deleter (reportid to ProcCall)
24043+ case 2076LLU: // copy-back deleter (reportid to ProcCall)
2397624044 {
2397724045 // copy mutable arguments back from call to reportid
23978- label = 2063LLU; // continue to roll stack
24046+ label = 2071LLU; // continue to roll stack
2397924047 break;
2398024048 }
23981- case 2069LLU: // return from reportid to ProcCall
24049+ case 2077LLU: // return from reportid to ProcCall
2398224050 {
2398324051 // copy mutable arguments back from call to reportid
2398424052 fprintf(stderr, "%s", " call to ");
2398524053 // call reportid from ProcCall
23986- stack[base + 43LLU] = 2070LLU/*throw to this address*/;
24054+ stack[base + 43LLU] = 2078LLU/*throw to this address*/;
2398724055 stack[base + 44LLU] = base;
23988- stack[base + 45LLU] = 2071LLU;
24056+ stack[base + 45LLU] = 2079LLU;
2398924057 // arguments for call to reportid
2399024058 stack[base + 46LLU] = stack[base + 24]/*ceid*/;
2399124059 // set stack-base & callee-address
@@ -23993,20 +24061,20 @@
2399324061 label = 18446744073709551586LLU; // reportid
2399424062 break;
2399524063 }
23996- case 2070LLU: // copy-back deleter (reportid to ProcCall)
24064+ case 2078LLU: // copy-back deleter (reportid to ProcCall)
2399724065 {
2399824066 // copy mutable arguments back from call to reportid
23999- label = 2063LLU; // continue to roll stack
24067+ label = 2071LLU; // continue to roll stack
2400024068 break;
2400124069 }
24002- case 2071LLU: // return from reportid to ProcCall
24070+ case 2079LLU: // return from reportid to ProcCall
2400324071 {
2400424072 // copy mutable arguments back from call to reportid
2400524073 fprintf(stderr, "%s", " at position ");
2400624074 // call reportnr from ProcCall
24007- stack[base + 43LLU] = 2072LLU/*throw to this address*/;
24075+ stack[base + 43LLU] = 2080LLU/*throw to this address*/;
2400824076 stack[base + 44LLU] = base;
24009- stack[base + 45LLU] = 2073LLU;
24077+ stack[base + 45LLU] = 2081LLU;
2401024078 // arguments for call to reportnr
2401124079 stack[base + 46LLU] = stack[base + 32]/*index*/;
2401224080 // set stack-base & callee-address
@@ -24014,13 +24082,13 @@
2401424082 label = 18446744073709551589LLU; // reportnr
2401524083 break;
2401624084 }
24017- case 2072LLU: // copy-back deleter (reportnr to ProcCall)
24085+ case 2080LLU: // copy-back deleter (reportnr to ProcCall)
2401824086 {
2401924087 // copy mutable arguments back from call to reportnr
24020- label = 2063LLU; // continue to roll stack
24088+ label = 2071LLU; // continue to roll stack
2402124089 break;
2402224090 }
24023- case 2073LLU: // return from reportnr to ProcCall
24091+ case 2081LLU: // return from reportnr to ProcCall
2402424092 {
2402524093 // copy mutable arguments back from call to reportnr
2402624094 fprintf(stderr, "%s", " cannot return source of type ");
@@ -24027,7 +24095,7 @@
2402724095 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2402824096 if(!newstack)
2402924097 {
24030- label = 2063LLU; // throw: begin to unroll stack
24098+ label = 2071LLU; // throw: begin to unroll stack
2403124099 break;
2403224100 }
2403324101
@@ -24034,9 +24102,9 @@
2403424102 newstack[10LLU] = 9876543210LLU; // overflow-marker
2403524103 // call reporttype from ProcCall
2403624104 newstack[0] = (uint64_t)stack; // backup stack location
24037- newstack[1] = 2074LLU;
24105+ newstack[1] = 2082LLU;
2403824106 newstack[2] = base;
24039- newstack[3] = 2075LLU;
24107+ newstack[3] = 2083LLU;
2404024108 // arguments for call to reporttype
2404124109 newstack[4LLU] = stack[base + 41]/*srctype*/;
2404224110 stack = newstack;
@@ -24045,7 +24113,7 @@
2404524113 label = 330LLU; // reporttype
2404624114 break;
2404724115 }
24048- case 2074LLU: // copy-back deleter (reporttype to ProcCall)
24116+ case 2082LLU: // copy-back deleter (reporttype to ProcCall)
2404924117 {
2405024118 uint64_t *oldstack = (uint64_t *)stack[0];
2405124119 // copy mutable arguments back from call to reporttype
@@ -24056,10 +24124,10 @@
2405624124 }
2405724125 Free(10LLU + 1, sizeof(uint64_t), stack);
2405824126 stack = oldstack;
24059- label = 2063LLU; // continue to unroll stack
24127+ label = 2071LLU; // continue to unroll stack
2406024128 break;
2406124129 }
24062- case 2075LLU: // return from reporttype to ProcCall
24130+ case 2083LLU: // return from reporttype to ProcCall
2406324131 {
2406424132 uint64_t *oldstack = (uint64_t *)stack[0];
2406524133 // copy mutable arguments back from call to reporttype
@@ -24074,7 +24142,7 @@
2407424142 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2407524143 if(!newstack)
2407624144 {
24077- label = 2063LLU; // throw: begin to unroll stack
24145+ label = 2071LLU; // throw: begin to unroll stack
2407824146 break;
2407924147 }
2408024148
@@ -24081,9 +24149,9 @@
2408124149 newstack[10LLU] = 9876543210LLU; // overflow-marker
2408224150 // call reporttype from ProcCall
2408324151 newstack[0] = (uint64_t)stack; // backup stack location
24084- newstack[1] = 2076LLU;
24152+ newstack[1] = 2084LLU;
2408524153 newstack[2] = base;
24086- newstack[3] = 2077LLU;
24154+ newstack[3] = 2085LLU;
2408724155 // arguments for call to reporttype
2408824156 newstack[4LLU] = stack[base + 39]/*dsttype*/;
2408924157 stack = newstack;
@@ -24092,7 +24160,7 @@
2409224160 label = 330LLU; // reporttype
2409324161 break;
2409424162 }
24095- case 2076LLU: // copy-back deleter (reporttype to ProcCall)
24163+ case 2084LLU: // copy-back deleter (reporttype to ProcCall)
2409624164 {
2409724165 uint64_t *oldstack = (uint64_t *)stack[0];
2409824166 // copy mutable arguments back from call to reporttype
@@ -24103,10 +24171,10 @@
2410324171 }
2410424172 Free(10LLU + 1, sizeof(uint64_t), stack);
2410524173 stack = oldstack;
24106- label = 2063LLU; // continue to unroll stack
24174+ label = 2071LLU; // continue to unroll stack
2410724175 break;
2410824176 }
24109- case 2077LLU: // return from reporttype to ProcCall
24177+ case 2085LLU: // return from reporttype to ProcCall
2411024178 {
2411124179 uint64_t *oldstack = (uint64_t *)stack[0];
2411224180 // copy mutable arguments back from call to reporttype
@@ -24119,20 +24187,20 @@
2411924187 stack = oldstack;
2412024188 fprintf(stderr, "%s", "\n");
2412124189 {
24122- label = 2063LLU; // throw: begin to unroll stack
24190+ label = 2071LLU; // throw: begin to unroll stack
2412324191 break;
2412424192 }
2412524193
24126- label = 2067LLU; // alternative complete
24194+ label = 2075LLU; // alternative complete
2412724195 break;
2412824196 }
24129- case 2067LLU: // completed if-then-else
24197+ case 2075LLU: // completed if-then-else
2413024198 {
2413124199 stack[base + 30]/*sum*/ = 0;
2413224200 // call add from ProcCall
24133- stack[base + 43LLU] = 2078LLU/*throw to this address*/;
24201+ stack[base + 43LLU] = 2086LLU/*throw to this address*/;
2413424202 stack[base + 44LLU] = base;
24135- stack[base + 45LLU] = 2079LLU;
24203+ stack[base + 45LLU] = 2087LLU;
2413624204 // arguments for call to add
2413724205 stack[base + 47LLU] = 4LLU;
2413824206 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24141,21 +24209,21 @@
2414124209 label = 18446744073709551605LLU; // add
2414224210 break;
2414324211 }
24144- case 2078LLU: // copy-back deleter (add to ProcCall)
24212+ case 2086LLU: // copy-back deleter (add to ProcCall)
2414524213 {
2414624214 // copy mutable arguments back from call to add
24147- label = 2063LLU; // continue to roll stack
24215+ label = 2071LLU; // continue to roll stack
2414824216 break;
2414924217 }
24150- case 2079LLU: // return from add to ProcCall
24218+ case 2087LLU: // return from add to ProcCall
2415124219 {
2415224220 // copy mutable arguments back from call to add
2415324221 // copy back results provided by call to add
2415424222 stack[base + 30] = stack[base + 46LLU];
2415524223 // call add from ProcCall
24156- stack[base + 43LLU] = 2080LLU/*throw to this address*/;
24224+ stack[base + 43LLU] = 2088LLU/*throw to this address*/;
2415724225 stack[base + 44LLU] = base;
24158- stack[base + 45LLU] = 2081LLU;
24226+ stack[base + 45LLU] = 2089LLU;
2415924227 // arguments for call to add
2416024228 stack[base + 47LLU] = stack[base + 32]/*index*/;
2416124229 stack[base + 48LLU] = stack[base + 30]/*sum*/;
@@ -24164,13 +24232,13 @@
2416424232 label = 18446744073709551605LLU; // add
2416524233 break;
2416624234 }
24167- case 2080LLU: // copy-back deleter (add to ProcCall)
24235+ case 2088LLU: // copy-back deleter (add to ProcCall)
2416824236 {
2416924237 // copy mutable arguments back from call to add
24170- label = 2063LLU; // continue to roll stack
24238+ label = 2071LLU; // continue to roll stack
2417124239 break;
2417224240 }
24173- case 2081LLU: // return from add to ProcCall
24241+ case 2089LLU: // return from add to ProcCall
2417424242 {
2417524243 // copy mutable arguments back from call to add
2417624244 // copy back results provided by call to add
@@ -24177,9 +24245,9 @@
2417724245 stack[base + 30] = stack[base + 46LLU];
2417824246 printf("%s", "\n old");
2417924247 // call emitvaridx from ProcCall
24180- stack[base + 43LLU] = 2082LLU/*throw to this address*/;
24248+ stack[base + 43LLU] = 2090LLU/*throw to this address*/;
2418124249 stack[base + 44LLU] = base;
24182- stack[base + 45LLU] = 2083LLU;
24250+ stack[base + 45LLU] = 2091LLU;
2418324251 // arguments for call to emitvaridx
2418424252 stack[base + 46LLU] = stack[base + 40]/*INDEX*/;
2418524253 // set stack-base & callee-address
@@ -24187,20 +24255,20 @@
2418724255 label = 745LLU; // emitvaridx
2418824256 break;
2418924257 }
24190- case 2082LLU: // copy-back deleter (emitvaridx to ProcCall)
24258+ case 2090LLU: // copy-back deleter (emitvaridx to ProcCall)
2419124259 {
2419224260 // copy mutable arguments back from call to emitvaridx
24193- label = 2063LLU; // continue to roll stack
24261+ label = 2071LLU; // continue to roll stack
2419424262 break;
2419524263 }
24196- case 2083LLU: // return from emitvaridx to ProcCall
24264+ case 2091LLU: // return from emitvaridx to ProcCall
2419724265 {
2419824266 // copy mutable arguments back from call to emitvaridx
2419924267 printf("%s", " = stack[");
2420024268 // call printnr from ProcCall
24201- stack[base + 43LLU] = 2084LLU/*throw to this address*/;
24269+ stack[base + 43LLU] = 2092LLU/*throw to this address*/;
2420224270 stack[base + 44LLU] = base;
24203- stack[base + 45LLU] = 2085LLU;
24271+ stack[base + 45LLU] = 2093LLU;
2420424272 // arguments for call to printnr
2420524273 stack[base + 46LLU] = stack[base + 30]/*sum*/;
2420624274 // set stack-base & callee-address
@@ -24208,53 +24276,53 @@
2420824276 label = 18446744073709551590LLU; // printnr
2420924277 break;
2421024278 }
24211- case 2084LLU: // copy-back deleter (printnr to ProcCall)
24279+ case 2092LLU: // copy-back deleter (printnr to ProcCall)
2421224280 {
2421324281 // copy mutable arguments back from call to printnr
24214- label = 2063LLU; // continue to roll stack
24282+ label = 2071LLU; // continue to roll stack
2421524283 break;
2421624284 }
24217- case 2085LLU: // return from printnr to ProcCall
24285+ case 2093LLU: // return from printnr to ProcCall
2421824286 {
2421924287 // copy mutable arguments back from call to printnr
2422024288 printf("%s", "LLU];");
2422124289 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2422224290 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24223- label = 2061LLU; // case complete
24291+ label = 2069LLU; // case complete
2422424292 break;
2422524293 }
24226- case 2063LLU: // copy-back deleter (switch)
24294+ case 2071LLU: // copy-back deleter (switch)
2422724295 {
2422824296 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
2422924297 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
24230- label = 2060LLU; // continue to unroll stack
24298+ label = 2068LLU; // continue to unroll stack
2423124299 break;
2423224300 }
24233- case 2062LLU: // try next case
24301+ case 2070LLU: // try next case
2423424302 {
2423524303 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2423624304 exit(-1);
2423724305 }
24238- case 2061LLU: // completed switch
24306+ case 2069LLU: // completed switch
2423924307 {
2424024308 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2424124309 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24242- label = 2058LLU; // case complete
24310+ label = 2066LLU; // case complete
2424324311 break;
2424424312 }
24245- case 2060LLU: // copy-back deleter (switch)
24313+ case 2068LLU: // copy-back deleter (switch)
2424624314 {
2424724315 ((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
2424824316 ((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
24249- label = 2057LLU; // continue to unroll stack
24317+ label = 2065LLU; // continue to unroll stack
2425024318 break;
2425124319 }
24252- case 2059LLU: // try next case
24320+ case 2067LLU: // try next case
2425324321 {
2425424322 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2425524323 exit(-1);
2425624324 }
24257- case 2058LLU: // completed switch
24325+ case 2066LLU: // completed switch
2425824326 {
2425924327
2426024328 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24262,7 +24330,7 @@
2426224330 newstack[0] = (uint64_t)stack; // backup stack location
2426324331 newstack[1] = 1234567890;
2426424332 newstack[2] = base;
24265- newstack[3] = 2086LLU;
24333+ newstack[3] = 2094LLU;
2426624334 stack = newstack;
2426724335 // set stack-base & callee-address
2426824336 base = 4/*deloffset*/;
@@ -24269,16 +24337,16 @@
2426924337 label = 399LLU; // ~typeidx
2427024338 break;
2427124339 }
24272- case 2086LLU: // return from ~typeidx to ProcCall
24340+ case 2094LLU: // return from ~typeidx to ProcCall
2427324341 {
2427424342 stack = (uint64_t *)stack[0];
2427524343 // releasing toplevel container
2427624344 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2427724345
24278- label = 2056LLU; // consequent complete
24346+ label = 2064LLU; // consequent complete
2427924347 break;
2428024348 }
24281- case 2057LLU: // copy-back deleter (if pop)
24349+ case 2065LLU: // copy-back deleter (if pop)
2428224350 {
2428324351
2428424352 uint64_t *newstack = (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4);
@@ -24286,7 +24354,7 @@
2428624354 newstack[0] = (uint64_t)stack; // backup stack location
2428724355 newstack[1] = 1234567890;
2428824356 newstack[2] = base;
24289- newstack[3] = 2087LLU;
24357+ newstack[3] = 2095LLU;
2429024358 stack = newstack;
2429124359 // set stack-base & callee-address
2429224360 base = 4/*deloffset*/;
@@ -24293,22 +24361,22 @@
2429324361 label = 399LLU; // ~typeidx
2429424362 break;
2429524363 }
24296- case 2087LLU: // return from ~typeidx to ProcCall
24364+ case 2095LLU: // return from ~typeidx to ProcCall
2429724365 {
2429824366 stack = (uint64_t *)stack[0];
2429924367 // releasing toplevel container
2430024368 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 38] - sizeof(uint64_t) * 4));
2430124369
24302- label = 2050LLU; // consequent complete
24370+ label = 2058LLU; // consequent complete
2430324371 break;
2430424372 }
24305- case 2055LLU: // alternative
24373+ case 2063LLU: // alternative
2430624374 {
2430724375 fprintf(stderr, "%s", "in function ");
2430824376 // call reportid from ProcCall
24309- stack[base + 39LLU] = 2088LLU/*throw to this address*/;
24377+ stack[base + 39LLU] = 2096LLU/*throw to this address*/;
2431024378 stack[base + 40LLU] = base;
24311- stack[base + 41LLU] = 2089LLU;
24379+ stack[base + 41LLU] = 2097LLU;
2431224380 // arguments for call to reportid
2431324381 stack[base + 42LLU] = stack[base + 8]/*fnid*/;
2431424382 // set stack-base & callee-address
@@ -24316,20 +24384,20 @@
2431624384 label = 18446744073709551586LLU; // reportid
2431724385 break;
2431824386 }
24319- case 2088LLU: // copy-back deleter (reportid to ProcCall)
24387+ case 2096LLU: // copy-back deleter (reportid to ProcCall)
2432024388 {
2432124389 // copy mutable arguments back from call to reportid
24322- label = 2050LLU; // continue to roll stack
24390+ label = 2058LLU; // continue to roll stack
2432324391 break;
2432424392 }
24325- case 2089LLU: // return from reportid to ProcCall
24393+ case 2097LLU: // return from reportid to ProcCall
2432624394 {
2432724395 // copy mutable arguments back from call to reportid
2432824396 fprintf(stderr, "%s", " call to ");
2432924397 // call reportid from ProcCall
24330- stack[base + 39LLU] = 2090LLU/*throw to this address*/;
24398+ stack[base + 39LLU] = 2098LLU/*throw to this address*/;
2433124399 stack[base + 40LLU] = base;
24332- stack[base + 41LLU] = 2091LLU;
24400+ stack[base + 41LLU] = 2099LLU;
2433324401 // arguments for call to reportid
2433424402 stack[base + 42LLU] = stack[base + 24]/*ceid*/;
2433524403 // set stack-base & callee-address
@@ -24337,20 +24405,20 @@
2433724405 label = 18446744073709551586LLU; // reportid
2433824406 break;
2433924407 }
24340- case 2090LLU: // copy-back deleter (reportid to ProcCall)
24408+ case 2098LLU: // copy-back deleter (reportid to ProcCall)
2434124409 {
2434224410 // copy mutable arguments back from call to reportid
24343- label = 2050LLU; // continue to roll stack
24411+ label = 2058LLU; // continue to roll stack
2434424412 break;
2434524413 }
24346- case 2091LLU: // return from reportid to ProcCall
24414+ case 2099LLU: // return from reportid to ProcCall
2434724415 {
2434824416 // copy mutable arguments back from call to reportid
2434924417 fprintf(stderr, "%s", " at position ");
2435024418 // call reportnr from ProcCall
24351- stack[base + 39LLU] = 2092LLU/*throw to this address*/;
24419+ stack[base + 39LLU] = 2100LLU/*throw to this address*/;
2435224420 stack[base + 40LLU] = base;
24353- stack[base + 41LLU] = 2093LLU;
24421+ stack[base + 41LLU] = 2101LLU;
2435424422 // arguments for call to reportnr
2435524423 stack[base + 42LLU] = stack[base + 32]/*index*/;
2435624424 // set stack-base & callee-address
@@ -24358,54 +24426,54 @@
2435824426 label = 18446744073709551589LLU; // reportnr
2435924427 break;
2436024428 }
24361- case 2092LLU: // copy-back deleter (reportnr to ProcCall)
24429+ case 2100LLU: // copy-back deleter (reportnr to ProcCall)
2436224430 {
2436324431 // copy mutable arguments back from call to reportnr
24364- label = 2050LLU; // continue to roll stack
24432+ label = 2058LLU; // continue to roll stack
2436524433 break;
2436624434 }
24367- case 2093LLU: // return from reportnr to ProcCall
24435+ case 2101LLU: // return from reportnr to ProcCall
2436824436 {
2436924437 // copy mutable arguments back from call to reportnr
2437024438 fprintf(stderr, "%s", " not enough destination-variables for results");
2437124439 fprintf(stderr, "%s", "\n");
2437224440 {
24373- label = 2050LLU; // throw: begin to unroll stack
24441+ label = 2058LLU; // throw: begin to unroll stack
2437424442 break;
2437524443 }
2437624444
24377- label = 2056LLU; // alternative complete
24445+ label = 2064LLU; // alternative complete
2437824446 break;
2437924447 }
24380- case 2056LLU: // completed if-then-else
24448+ case 2064LLU: // completed if-then-else
2438124449 {
2438224450 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24383- label = 2048LLU; // repeat
24451+ label = 2056LLU; // repeat
2438424452 break;
2438524453 }
24386- case 2050LLU: // copy-back deleter for while next
24454+ case 2058LLU: // copy-back deleter for while next
2438724455 {
2438824456 ((struct listnode *)(stack[base + 37]/*previous*/))->data = stack[base + 36];
24389- label = 1771LLU; // continue to unroll stack
24457+ label = 1779LLU; // continue to unroll stack
2439024458 break;
2439124459 }
24392- case 2049LLU: // loop finished
24460+ case 2057LLU: // loop finished
2439324461 {
24394- label = 2045LLU; // consequent complete
24462+ label = 2053LLU; // consequent complete
2439524463 break;
2439624464 }
24397- case 2044LLU: // alternative
24465+ case 2052LLU: // alternative
2439824466 {
24399- label = 2045LLU; // alternative complete
24467+ label = 2053LLU; // alternative complete
2440024468 break;
2440124469 }
24402- case 2045LLU: // completed if-then-else
24470+ case 2053LLU: // completed if-then-else
2440324471 {
2440424472 printf("%s", "\n if(stack[");
2440524473 // call printnr from ProcCall
24406- stack[base + 35LLU] = 2094LLU/*throw to this address*/;
24474+ stack[base + 35LLU] = 2102LLU/*throw to this address*/;
2440724475 stack[base + 36LLU] = base;
24408- stack[base + 37LLU] = 2095LLU;
24476+ stack[base + 37LLU] = 2103LLU;
2440924477 // arguments for call to printnr
2441024478 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2441124479 // set stack-base & callee-address
@@ -24413,13 +24481,13 @@
2441324481 label = 18446744073709551590LLU; // printnr
2441424482 break;
2441524483 }
24416- case 2094LLU: // copy-back deleter (printnr to ProcCall)
24484+ case 2102LLU: // copy-back deleter (printnr to ProcCall)
2441724485 {
2441824486 // copy mutable arguments back from call to printnr
24419- label = 1771LLU; // continue to roll stack
24487+ label = 1779LLU; // continue to roll stack
2442024488 break;
2442124489 }
24422- case 2095LLU: // return from printnr to ProcCall
24490+ case 2103LLU: // return from printnr to ProcCall
2442324491 {
2442424492 // copy mutable arguments back from call to printnr
2442524493 printf("%s", "LLU] != 9876543210LLU)");
@@ -24426,9 +24494,9 @@
2442624494 printf("%s", "\n {");
2442724495 printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
2442824496 // call printid from ProcCall
24429- stack[base + 35LLU] = 2096LLU/*throw to this address*/;
24497+ stack[base + 35LLU] = 2104LLU/*throw to this address*/;
2443024498 stack[base + 36LLU] = base;
24431- stack[base + 37LLU] = 2097LLU;
24499+ stack[base + 37LLU] = 2105LLU;
2443224500 // arguments for call to printid
2443324501 stack[base + 38LLU] = stack[base + 24]/*ceid*/;
2443424502 // set stack-base & callee-address
@@ -24436,13 +24504,13 @@
2443624504 label = 18446744073709551587LLU; // printid
2443724505 break;
2443824506 }
24439- case 2096LLU: // copy-back deleter (printid to ProcCall)
24507+ case 2104LLU: // copy-back deleter (printid to ProcCall)
2444024508 {
2444124509 // copy mutable arguments back from call to printid
24442- label = 1771LLU; // continue to roll stack
24510+ label = 1779LLU; // continue to roll stack
2444324511 break;
2444424512 }
24445- case 2097LLU: // return from printid to ProcCall
24513+ case 2105LLU: // return from printid to ProcCall
2444624514 {
2444724515 // copy mutable arguments back from call to printid
2444824516 printf("%s", ")!\\n\");");
@@ -24450,9 +24518,9 @@
2445024518 printf("%s", "\n }");
2445124519 printf("%s", "\n Free(");
2445224520 // call printnr from ProcCall
24453- stack[base + 35LLU] = 2098LLU/*throw to this address*/;
24521+ stack[base + 35LLU] = 2106LLU/*throw to this address*/;
2445424522 stack[base + 36LLU] = base;
24455- stack[base + 37LLU] = 2099LLU;
24523+ stack[base + 37LLU] = 2107LLU;
2445624524 // arguments for call to printnr
2445724525 stack[base + 38LLU] = stack[base + 34]/*recsztotal*/;
2445824526 // set stack-base & callee-address
@@ -24460,26 +24528,26 @@
2446024528 label = 18446744073709551590LLU; // printnr
2446124529 break;
2446224530 }
24463- case 2098LLU: // copy-back deleter (printnr to ProcCall)
24531+ case 2106LLU: // copy-back deleter (printnr to ProcCall)
2446424532 {
2446524533 // copy mutable arguments back from call to printnr
24466- label = 1771LLU; // continue to roll stack
24534+ label = 1779LLU; // continue to roll stack
2446724535 break;
2446824536 }
24469- case 2099LLU: // return from printnr to ProcCall
24537+ case 2107LLU: // return from printnr to ProcCall
2447024538 {
2447124539 // copy mutable arguments back from call to printnr
2447224540 printf("%s", "LLU + 1, sizeof(uint64_t), stack);");
2447324541 printf("%s", "\n stack = oldstack;");
24474- label = 1760LLU; // consequent complete
24542+ label = 1768LLU; // consequent complete
2447524543 break;
2447624544 }
24477- case 1759LLU: // alternative
24545+ case 1767LLU: // alternative
2447824546 {
2447924547 // call add from ProcCall
24480- stack[base + 33LLU] = 2100LLU/*throw to this address*/;
24548+ stack[base + 33LLU] = 2108LLU/*throw to this address*/;
2448124549 stack[base + 34LLU] = base;
24482- stack[base + 35LLU] = 2101LLU;
24550+ stack[base + 35LLU] = 2109LLU;
2448324551 // arguments for call to add
2448424552 stack[base + 37LLU] = 1LLU;
2448524553 stack[base + 38LLU] = stack[base + 17]/*label*/;
@@ -24488,39 +24556,39 @@
2448824556 label = 18446744073709551605LLU; // add
2448924557 break;
2449024558 }
24491- case 2100LLU: // copy-back deleter (add to ProcCall)
24559+ case 2108LLU: // copy-back deleter (add to ProcCall)
2449224560 {
2449324561 // copy mutable arguments back from call to add
24494- label = 1757LLU; // continue to roll stack
24562+ label = 1765LLU; // continue to roll stack
2449524563 break;
2449624564 }
24497- case 2101LLU: // return from add to ProcCall
24565+ case 2109LLU: // return from add to ProcCall
2449824566 {
2449924567 // copy mutable arguments back from call to add
2450024568 // copy back results provided by call to add
2450124569 stack[base + 17] = stack[base + 36LLU];
24502- label = 2103LLU; // skip deleter
24570+ label = 2111LLU; // skip deleter
2450324571 break;
2450424572 }
24505- case 2102LLU: // deleter
24573+ case 2110LLU: // deleter
2450624574 {
2450724575 // throw from ProcCall
2450824576 if(!stack[base + 33])
2450924577 {
24510- label = 1757LLU; // skip, variable already deleted/unscoped
24578+ label = 1765LLU; // skip, variable already deleted/unscoped
2451124579 break;
2451224580 }
24513- label = 1757LLU; // continue unrolling stack, delete next variable
24581+ label = 1765LLU; // continue unrolling stack, delete next variable
2451424582 break;
2451524583 }
24516- case 2103LLU: // skipped deleter
24584+ case 2111LLU: // skipped deleter
2451724585 {
2451824586 stack[base + 33] = stack[base + 17]/*label*/;
2451924587 printf("%s", "\n // call ");
2452024588 // call printid from ProcCall
24521- stack[base + 34LLU] = 2104LLU/*throw to this address*/;
24589+ stack[base + 34LLU] = 2112LLU/*throw to this address*/;
2452224590 stack[base + 35LLU] = base;
24523- stack[base + 36LLU] = 2105LLU;
24591+ stack[base + 36LLU] = 2113LLU;
2452424592 // arguments for call to printid
2452524593 stack[base + 37LLU] = stack[base + 24]/*ceid*/;
2452624594 // set stack-base & callee-address
@@ -24528,20 +24596,20 @@
2452824596 label = 18446744073709551587LLU; // printid
2452924597 break;
2453024598 }
24531- case 2104LLU: // copy-back deleter (printid to ProcCall)
24599+ case 2112LLU: // copy-back deleter (printid to ProcCall)
2453224600 {
2453324601 // copy mutable arguments back from call to printid
24534- label = 2102LLU; // continue to roll stack
24602+ label = 2110LLU; // continue to roll stack
2453524603 break;
2453624604 }
24537- case 2105LLU: // return from printid to ProcCall
24605+ case 2113LLU: // return from printid to ProcCall
2453824606 {
2453924607 // copy mutable arguments back from call to printid
2454024608 printf("%s", " from ");
2454124609 // call printid from ProcCall
24542- stack[base + 34LLU] = 2106LLU/*throw to this address*/;
24610+ stack[base + 34LLU] = 2114LLU/*throw to this address*/;
2454324611 stack[base + 35LLU] = base;
24544- stack[base + 36LLU] = 2107LLU;
24612+ stack[base + 36LLU] = 2115LLU;
2454524613 // arguments for call to printid
2454624614 stack[base + 37LLU] = stack[base + 8]/*fnid*/;
2454724615 // set stack-base & callee-address
@@ -24549,20 +24617,20 @@
2454924617 label = 18446744073709551587LLU; // printid
2455024618 break;
2455124619 }
24552- case 2106LLU: // copy-back deleter (printid to ProcCall)
24620+ case 2114LLU: // copy-back deleter (printid to ProcCall)
2455324621 {
2455424622 // copy mutable arguments back from call to printid
24555- label = 2102LLU; // continue to roll stack
24623+ label = 2110LLU; // continue to roll stack
2455624624 break;
2455724625 }
24558- case 2107LLU: // return from printid to ProcCall
24626+ case 2115LLU: // return from printid to ProcCall
2455924627 {
2456024628 // copy mutable arguments back from call to printid
2456124629 stack[base + 30]/*sum*/ = 0;
2456224630 // call add from ProcCall
24563- stack[base + 34LLU] = 2108LLU/*throw to this address*/;
24631+ stack[base + 34LLU] = 2116LLU/*throw to this address*/;
2456424632 stack[base + 35LLU] = base;
24565- stack[base + 36LLU] = 2109LLU;
24633+ stack[base + 36LLU] = 2117LLU;
2456624634 // arguments for call to add
2456724635 stack[base + 38LLU] = stack[base + 4]/*offset*/;
2456824636 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -24571,21 +24639,21 @@
2457124639 label = 18446744073709551605LLU; // add
2457224640 break;
2457324641 }
24574- case 2108LLU: // copy-back deleter (add to ProcCall)
24642+ case 2116LLU: // copy-back deleter (add to ProcCall)
2457524643 {
2457624644 // copy mutable arguments back from call to add
24577- label = 2102LLU; // continue to roll stack
24645+ label = 2110LLU; // continue to roll stack
2457824646 break;
2457924647 }
24580- case 2109LLU: // return from add to ProcCall
24648+ case 2117LLU: // return from add to ProcCall
2458124649 {
2458224650 // copy mutable arguments back from call to add
2458324651 // copy back results provided by call to add
2458424652 stack[base + 30] = stack[base + 37LLU];
2458524653 // call add from ProcCall
24586- stack[base + 34LLU] = 2110LLU/*throw to this address*/;
24654+ stack[base + 34LLU] = 2118LLU/*throw to this address*/;
2458724655 stack[base + 35LLU] = base;
24588- stack[base + 36LLU] = 2111LLU;
24656+ stack[base + 36LLU] = 2119LLU;
2458924657 // arguments for call to add
2459024658 stack[base + 38LLU] = stack[base + 10]/*fnrescount*/;
2459124659 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -24594,21 +24662,21 @@
2459424662 label = 18446744073709551605LLU; // add
2459524663 break;
2459624664 }
24597- case 2110LLU: // copy-back deleter (add to ProcCall)
24665+ case 2118LLU: // copy-back deleter (add to ProcCall)
2459824666 {
2459924667 // copy mutable arguments back from call to add
24600- label = 2102LLU; // continue to roll stack
24668+ label = 2110LLU; // continue to roll stack
2460124669 break;
2460224670 }
24603- case 2111LLU: // return from add to ProcCall
24671+ case 2119LLU: // return from add to ProcCall
2460424672 {
2460524673 // copy mutable arguments back from call to add
2460624674 // copy back results provided by call to add
2460724675 stack[base + 30] = stack[base + 37LLU];
2460824676 // call add from ProcCall
24609- stack[base + 34LLU] = 2112LLU/*throw to this address*/;
24677+ stack[base + 34LLU] = 2120LLU/*throw to this address*/;
2461024678 stack[base + 35LLU] = base;
24611- stack[base + 36LLU] = 2113LLU;
24679+ stack[base + 36LLU] = 2121LLU;
2461224680 // arguments for call to add
2461324681 stack[base + 38LLU] = stack[base + 11]/*fnargcount*/;
2461424682 stack[base + 39LLU] = stack[base + 30]/*sum*/;
@@ -24617,21 +24685,21 @@
24617