• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1215 (tree)
Time2021-04-01 21:04:01
Authorjakobthomsen

Log Message

fix bug: report error when more results expected than actually provided by call

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1214)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1215)
@@ -36703,6 +36703,72 @@
3670336703 }
3670436704 case 3070LLU: // loop finished
3670536705 {
36706+ if(!stack[base + 17]/*results*/)
36707+ {
36708+ label = 3119LLU; // jump to alternative
36709+ break;
36710+ }
36711+
36712+ // consequent
36713+ fprintf(stderr, "%s", "in function ");
36714+ // call reportid from PROCCALL
36715+ stack[base + 31LLU] = 3121LLU/*throw to this address*/;
36716+ stack[base + 32LLU] = base;
36717+ stack[base + 33LLU] = 3122LLU;
36718+ // arguments for call to reportid
36719+ stack[base + 34LLU] = stack[base + 7]/*fnid*/;
36720+ // set stack-base & callee-address
36721+ base += 34LLU;
36722+ label = 18446744073709551586LLU; // reportid
36723+ break;
36724+ }
36725+ case 3121LLU: // copy-back deleter (reportid to PROCCALL)
36726+ {
36727+ // copy mutable arguments back from call to reportid
36728+ label = 3068LLU; // continue to roll stack
36729+ break;
36730+ }
36731+ case 3122LLU: // return from reportid to PROCCALL
36732+ {
36733+ // copy mutable arguments back from call to reportid
36734+ fprintf(stderr, "%s", " call to ");
36735+ // call reportid from PROCCALL
36736+ stack[base + 31LLU] = 3123LLU/*throw to this address*/;
36737+ stack[base + 32LLU] = base;
36738+ stack[base + 33LLU] = 3124LLU;
36739+ // arguments for call to reportid
36740+ stack[base + 34LLU] = stack[base + 24]/*ceid*/;
36741+ // set stack-base & callee-address
36742+ base += 34LLU;
36743+ label = 18446744073709551586LLU; // reportid
36744+ break;
36745+ }
36746+ case 3123LLU: // copy-back deleter (reportid to PROCCALL)
36747+ {
36748+ // copy mutable arguments back from call to reportid
36749+ label = 3068LLU; // continue to roll stack
36750+ break;
36751+ }
36752+ case 3124LLU: // return from reportid to PROCCALL
36753+ {
36754+ // copy mutable arguments back from call to reportid
36755+ fprintf(stderr, "%s", " too many destination-variables for results");
36756+ fprintf(stderr, "%s", "\n");
36757+ {
36758+ label = 3068LLU; // throw: begin to unroll stack
36759+ break;
36760+ }
36761+
36762+ label = 3120LLU; // consequent complete
36763+ break;
36764+ }
36765+ case 3119LLU: // alternative
36766+ {
36767+ label = 3120LLU; // alternative complete
36768+ break;
36769+ }
36770+ case 3120LLU: // completed if-then-else
36771+ {
3670636772 ((uint64_t **)(stack[base + 19]))[1][7] = stack[base + 27];
3670736773 ((uint64_t **)(stack[base + 19]))[1][6] = stack[base + 26];
3670836774 ((uint64_t **)(stack[base + 19]))[1][5] = stack[base + 25];
@@ -36736,9 +36802,9 @@
3673636802 {
3673736803 list_reverse(((struct listnode **)(&stack[base + 16]/*dsttypeidx*/)));
3673836804 // call matchsym from PROCCALL
36739- stack[base + 20LLU] = 3119LLU/*throw to this address*/;
36805+ stack[base + 20LLU] = 3125LLU/*throw to this address*/;
3674036806 stack[base + 21LLU] = base;
36741- stack[base + 22LLU] = 3120LLU;
36807+ stack[base + 22LLU] = 3126LLU;
3674236808 // arguments for call to matchsym
3674336809 stack[base + 23LLU] = stack[base + 7]/*fnid*/;
3674436810 stack[base + 24LLU] = 40LLU;
@@ -36748,7 +36814,7 @@
3674836814 label = 246LLU; // matchsym
3674936815 break;
3675036816 }
36751- case 3119LLU: // copy-back deleter (matchsym to PROCCALL)
36817+ case 3125LLU: // copy-back deleter (matchsym to PROCCALL)
3675236818 {
3675336819 // copy mutable arguments back from call to matchsym
3675436820 stack[base + 12]/*lookahead*/ = stack[base + 25LLU];
@@ -36755,14 +36821,14 @@
3675536821 label = 3061LLU; // continue to roll stack
3675636822 break;
3675736823 }
36758- case 3120LLU: // return from matchsym to PROCCALL
36824+ case 3126LLU: // return from matchsym to PROCCALL
3675936825 {
3676036826 // copy mutable arguments back from call to matchsym
3676136827 stack[base + 12]/*lookahead*/ = stack[base + 25LLU];
3676236828 // call ProcCall from PROCCALL
36763- stack[base + 20LLU] = 3121LLU/*throw to this address*/;
36829+ stack[base + 20LLU] = 3127LLU/*throw to this address*/;
3676436830 stack[base + 21LLU] = base;
36765- stack[base + 22LLU] = 3122LLU;
36831+ stack[base + 22LLU] = 3128LLU;
3676636832 // arguments for call to ProcCall
3676736833 stack[base + 23LLU] = stack[base + 16]/*dsttypeidx*/;
3676836834 stack[base + 24LLU] = stack[base + 0]/*fndefs*/;
@@ -36787,7 +36853,7 @@
3678736853 label = 1755LLU; // ProcCall
3678836854 break;
3678936855 }
36790- case 3121LLU: // copy-back deleter (ProcCall to PROCCALL)
36856+ case 3127LLU: // copy-back deleter (ProcCall to PROCCALL)
3679136857 {
3679236858 // copy mutable arguments back from call to ProcCall
3679336859 stack[base + 15]/*label*/ = stack[base + 40LLU];
@@ -36799,7 +36865,7 @@
3679936865 label = 3061LLU; // continue to roll stack
3680036866 break;
3680136867 }
36802- case 3122LLU: // return from ProcCall to PROCCALL
36868+ case 3128LLU: // return from ProcCall to PROCCALL
3680336869 {
3680436870 // copy mutable arguments back from call to ProcCall
3680536871 stack[base + 15]/*label*/ = stack[base + 40LLU];
@@ -36809,9 +36875,9 @@
3680936875 stack[base + 11]/*fnmaxcount*/ = stack[base + 35LLU];
3681036876 stack[base + 16]/*dsttypeidx*/ = stack[base + 23LLU];
3681136877 // call matchsym from PROCCALL
36812- stack[base + 20LLU] = 3123LLU/*throw to this address*/;
36878+ stack[base + 20LLU] = 3129LLU/*throw to this address*/;
3681336879 stack[base + 21LLU] = base;
36814- stack[base + 22LLU] = 3124LLU;
36880+ stack[base + 22LLU] = 3130LLU;
3681536881 // arguments for call to matchsym
3681636882 stack[base + 23LLU] = stack[base + 7]/*fnid*/;
3681736883 stack[base + 24LLU] = 41LLU;
@@ -36821,7 +36887,7 @@
3682136887 label = 246LLU; // matchsym
3682236888 break;
3682336889 }
36824- case 3123LLU: // copy-back deleter (matchsym to PROCCALL)
36890+ case 3129LLU: // copy-back deleter (matchsym to PROCCALL)
3682536891 {
3682636892 // copy mutable arguments back from call to matchsym
3682736893 stack[base + 12]/*lookahead*/ = stack[base + 25LLU];
@@ -36828,7 +36894,7 @@
3682836894 label = 3061LLU; // continue to roll stack
3682936895 break;
3683036896 }
36831- case 3124LLU: // return from matchsym to PROCCALL
36897+ case 3130LLU: // return from matchsym to PROCCALL
3683236898 {
3683336899 // copy mutable arguments back from call to matchsym
3683436900 stack[base + 12]/*lookahead*/ = stack[base + 25LLU];
@@ -36838,7 +36904,7 @@
3683836904 newstack[0] = (uint64_t)stack; // backup stack location
3683936905 newstack[1] = 1234567890;
3684036906 newstack[2] = base;
36841- newstack[3] = 3125LLU;
36907+ newstack[3] = 3131LLU;
3684236908 stack = newstack;
3684336909 // set stack-base & callee-address
3684436910 base = 4/*deloffset*/;
@@ -36845,7 +36911,7 @@
3684536911 label = 1420LLU; // ~fndef
3684636912 break;
3684736913 }
36848- case 3125LLU: // return from ~fndef to PROCCALL
36914+ case 3131LLU: // return from ~fndef to PROCCALL
3684936915 {
3685036916 stack = (uint64_t *)stack[0];
3685136917 // releasing toplevel container
@@ -36857,14 +36923,14 @@
3685736923 case 3042LLU: // completed if-then-else
3685836924 {
3685936925 // delete list
36860- label = 3126LLU; // start to repeat
36926+ label = 3132LLU; // start to repeat
3686136927 break;
3686236928 }
36863- case 3126LLU: // repeat from here
36929+ case 3132LLU: // repeat from here
3686436930 {
3686536931 if(!stack[base + 17])
3686636932 {
36867- label = 3127LLU; // break loop
36933+ label = 3133LLU; // break loop
3686836934 break;
3686936935 }
3687036936
@@ -36875,7 +36941,7 @@
3687536941 newstack[0] = (uint64_t)stack; // backup stack location
3687636942 newstack[1] = 1234567890;
3687736943 newstack[2] = base;
36878- newstack[3] = 3128LLU;
36944+ newstack[3] = 3134LLU;
3687936945 stack = newstack;
3688036946 // set stack-base & callee-address
3688136947 base = 4/*deloffset*/;
@@ -36882,7 +36948,7 @@
3688236948 label = 486LLU; // ~letdef
3688336949 break;
3688436950 }
36885- case 3128LLU: // return from ~letdef to PROCCALL
36951+ case 3134LLU: // return from ~letdef to PROCCALL
3688636952 {
3688736953 stack = (uint64_t *)stack[0];
3688836954 // releasing toplevel container
@@ -36893,20 +36959,20 @@
3689336959 stack[base + 17] = (uint64_t)list->next;
3689436960 Free(1, sizeof(struct listnode), list);
3689536961 }
36896- label = 3126LLU; // repeat
36962+ label = 3132LLU; // repeat
3689736963 break;
3689836964 }
36899- case 3127LLU: // loop finished
36965+ case 3133LLU: // loop finished
3690036966 {
3690136967 // delete list
36902- label = 3129LLU; // start to repeat
36968+ label = 3135LLU; // start to repeat
3690336969 break;
3690436970 }
36905- case 3129LLU: // repeat from here
36971+ case 3135LLU: // repeat from here
3690636972 {
3690736973 if(!stack[base + 16])
3690836974 {
36909- label = 3130LLU; // break loop
36975+ label = 3136LLU; // break loop
3691036976 break;
3691136977 }
3691236978
@@ -36917,7 +36983,7 @@
3691736983 newstack[0] = (uint64_t)stack; // backup stack location
3691836984 newstack[1] = 1234567890;
3691936985 newstack[2] = base;
36920- newstack[3] = 3131LLU;
36986+ newstack[3] = 3137LLU;
3692136987 stack = newstack;
3692236988 // set stack-base & callee-address
3692336989 base = 4/*deloffset*/;
@@ -36924,7 +36990,7 @@
3692436990 label = 399LLU; // ~typeidx
3692536991 break;
3692636992 }
36927- case 3131LLU: // return from ~typeidx to PROCCALL
36993+ case 3137LLU: // return from ~typeidx to PROCCALL
3692836994 {
3692936995 stack = (uint64_t *)stack[0];
3693036996 // releasing toplevel container
@@ -36935,10 +37001,10 @@
3693537001 stack[base + 16] = (uint64_t)list->next;
3693637002 Free(1, sizeof(struct listnode), list);
3693737003 }
36938- label = 3129LLU; // repeat
37004+ label = 3135LLU; // repeat
3693937005 break;
3694037006 }
36941- case 3130LLU: // loop finished
37007+ case 3136LLU: // loop finished
3694237008 {
3694337009 // return from PROCCALL
3694437010 label = stack[base - 1];
@@ -36945,13 +37011,13 @@
3694537011 base = stack[base - 2];
3694637012 break;
3694737013 }
36948- case 3133LLU: // function markswap failed
37014+ case 3139LLU: // function markswap failed
3694937015 {
3695037016 label = stack[base - 3];
3695137017 base = stack[base - 2];
3695237018 break;
3695337019 }
36954- case 3132LLU: // markswap
37020+ case 3138LLU: // markswap
3695537021 {
3695637022 //#define arg0 0
3695737023 //#define arg1 1
@@ -36958,32 +37024,32 @@
3695837024 //#define arg2 2
3695937025 //#define arg3 3
3696037026 //#define arg4 4
36961- label = 3135LLU; // skip deleter
37027+ label = 3141LLU; // skip deleter
3696237028 break;
3696337029 }
36964- case 3134LLU: // deleter
37030+ case 3140LLU: // deleter
3696537031 {
3696637032 // throw from markswap
3696737033 if(!stack[base + 5])
3696837034 {
36969- label = 3133LLU; // skip, variable already deleted/unscoped
37035+ label = 3139LLU; // skip, variable already deleted/unscoped
3697037036 break;
3697137037 }
36972- label = 3133LLU; // continue unrolling stack, delete next variable
37038+ label = 3139LLU; // continue unrolling stack, delete next variable
3697337039 break;
3697437040 }
36975- case 3135LLU: // skipped deleter
37041+ case 3141LLU: // skipped deleter
3697637042 {
3697737043 stack[base + 5] = 0;
36978- label = 3137LLU; // skip deleter
37044+ label = 3143LLU; // skip deleter
3697937045 break;
3698037046 }
36981- case 3136LLU: // deleter
37047+ case 3142LLU: // deleter
3698237048 {
3698337049 // throw from markswap
3698437050 if(!stack[base + 6])
3698537051 {
36986- label = 3134LLU; // skip, variable already deleted/unscoped
37052+ label = 3140LLU; // skip, variable already deleted/unscoped
3698737053 break;
3698837054 }
3698937055
@@ -36992,7 +37058,7 @@
3699237058 newstack[0] = (uint64_t)stack; // backup stack location
3699337059 newstack[1] = 1234567890;
3699437060 newstack[2] = base;
36995- newstack[3] = 3138LLU;
37061+ newstack[3] = 3144LLU;
3699637062 stack = newstack;
3699737063 // set stack-base & callee-address
3699837064 base = 4/*deloffset*/;
@@ -36999,21 +37065,21 @@
3699937065 label = 486LLU; // ~letdef
3700037066 break;
3700137067 }
37002- case 3138LLU: // return from ~letdef to markswap
37068+ case 3144LLU: // return from ~letdef to markswap
3700337069 {
3700437070 stack = (uint64_t *)stack[0];
3700537071 // releasing toplevel container
3700637072 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 6] - sizeof(uint64_t) * 4));
3700737073
37008- label = 3134LLU; // continue unrolling stack, delete next variable
37074+ label = 3140LLU; // continue unrolling stack, delete next variable
3700937075 break;
3701037076 }
37011- case 3137LLU: // skipped deleter
37077+ case 3143LLU: // skipped deleter
3701237078 {
3701337079 // call FindLet from markswap
37014- stack[base + 7LLU] = 3139LLU/*throw to this address*/;
37080+ stack[base + 7LLU] = 3145LLU/*throw to this address*/;
3701537081 stack[base + 8LLU] = base;
37016- stack[base + 9LLU] = 3140LLU;
37082+ stack[base + 9LLU] = 3146LLU;
3701737083 // arguments for call to FindLet
3701837084 stack[base + 11LLU] = stack[base + 0]/*fnid*/;
3701937085 stack[base + 12LLU] = stack[base + 3]/*xidsearch*/;
@@ -37024,26 +37090,26 @@
3702437090 label = 619LLU; // FindLet
3702537091 break;
3702637092 }
37027- case 3139LLU: // copy-back deleter (FindLet to markswap)
37093+ case 3145LLU: // copy-back deleter (FindLet to markswap)
3702837094 {
3702937095 // copy mutable arguments back from call to FindLet
37030- label = 3134LLU; // continue to roll stack
37096+ label = 3140LLU; // continue to roll stack
3703137097 break;
3703237098 }
37033- case 3140LLU: // return from FindLet to markswap
37099+ case 3146LLU: // return from FindLet to markswap
3703437100 {
3703537101 // copy mutable arguments back from call to FindLet
3703637102 // copy back results provided by call to FindLet
3703737103 stack[base + 6] = stack[base + 10LLU];
37038- label = 3142LLU; // skip deleter
37104+ label = 3148LLU; // skip deleter
3703937105 break;
3704037106 }
37041- case 3141LLU: // deleter
37107+ case 3147LLU: // deleter
3704237108 {
3704337109 // throw from markswap
3704437110 if(!stack[base + 7])
3704537111 {
37046- label = 3136LLU; // skip, variable already deleted/unscoped
37112+ label = 3142LLU; // skip, variable already deleted/unscoped
3704737113 break;
3704837114 }
3704937115
@@ -37052,7 +37118,7 @@
3705237118 newstack[0] = (uint64_t)stack; // backup stack location
3705337119 newstack[1] = 1234567890;
3705437120 newstack[2] = base;
37055- newstack[3] = 3143LLU;
37121+ newstack[3] = 3149LLU;
3705637122 stack = newstack;
3705737123 // set stack-base & callee-address
3705837124 base = 4/*deloffset*/;
@@ -37059,21 +37125,21 @@
3705937125 label = 486LLU; // ~letdef
3706037126 break;
3706137127 }
37062- case 3143LLU: // return from ~letdef to markswap
37128+ case 3149LLU: // return from ~letdef to markswap
3706337129 {
3706437130 stack = (uint64_t *)stack[0];
3706537131 // releasing toplevel container
3706637132 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4));
3706737133
37068- label = 3136LLU; // continue unrolling stack, delete next variable
37134+ label = 3142LLU; // continue unrolling stack, delete next variable
3706937135 break;
3707037136 }
37071- case 3142LLU: // skipped deleter
37137+ case 3148LLU: // skipped deleter
3707237138 {
3707337139 // call FindLet from markswap
37074- stack[base + 8LLU] = 3144LLU/*throw to this address*/;
37140+ stack[base + 8LLU] = 3150LLU/*throw to this address*/;
3707537141 stack[base + 9LLU] = base;
37076- stack[base + 10LLU] = 3145LLU;
37142+ stack[base + 10LLU] = 3151LLU;
3707737143 // arguments for call to FindLet
3707837144 stack[base + 12LLU] = stack[base + 0]/*fnid*/;
3707937145 stack[base + 13LLU] = stack[base + 4]/*yidsearch*/;
@@ -37084,13 +37150,13 @@
3708437150 label = 619LLU; // FindLet
3708537151 break;
3708637152 }
37087- case 3144LLU: // copy-back deleter (FindLet to markswap)
37153+ case 3150LLU: // copy-back deleter (FindLet to markswap)
3708837154 {
3708937155 // copy mutable arguments back from call to FindLet
37090- label = 3136LLU; // continue to roll stack
37156+ label = 3142LLU; // continue to roll stack
3709137157 break;
3709237158 }
37093- case 3145LLU: // return from FindLet to markswap
37159+ case 3151LLU: // return from FindLet to markswap
3709437160 {
3709537161 // copy mutable arguments back from call to FindLet
3709637162 // copy back results provided by call to FindLet
@@ -37097,7 +37163,7 @@
3709737163 stack[base + 7] = stack[base + 11LLU];
3709837164 if(/*letdef*/0 != ((uint64_t *)(stack[base + 6]/*x*/))[0])
3709937165 {
37100- label = 3147LLU; // jump to alternative
37166+ label = 3153LLU; // jump to alternative
3710137167 break;
3710237168 }
3710337169
@@ -37109,7 +37175,7 @@
3710937175
3711037176 if(/*letdef*/0 != ((uint64_t *)(stack[base + 7]/*y*/))[0])
3711137177 {
37112- label = 3147LLU; // jump to alternative
37178+ label = 3153LLU; // jump to alternative
3711337179 break;
3711437180 }
3711537181
@@ -37123,7 +37189,7 @@
3712337189 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
3712437190 if(!newstack)
3712537191 {
37126- label = 3148LLU; // throw: begin to unroll stack
37192+ label = 3154LLU; // throw: begin to unroll stack
3712737193 break;
3712837194 }
3712937195
@@ -37130,9 +37196,9 @@
3713037196 newstack[15LLU] = 9876543210LLU; // overflow-marker
3713137197 // call equtype from markswap
3713237198 newstack[0] = (uint64_t)stack; // backup stack location
37133- newstack[1] = 3149LLU;
37199+ newstack[1] = 3155LLU;
3713437200 newstack[2] = base;
37135- newstack[3] = 3150LLU;
37201+ newstack[3] = 3156LLU;
3713637202 // arguments for call to equtype
3713737203 newstack[5LLU] = stack[base + 8]/*xtype*/;
3713837204 newstack[6LLU] = stack[base + 13]/*ytype*/;
@@ -37142,7 +37208,7 @@
3714237208 label = 359LLU; // equtype
3714337209 break;
3714437210 }
37145- case 3149LLU: // copy-back deleter (equtype to markswap)
37211+ case 3155LLU: // copy-back deleter (equtype to markswap)
3714637212 {
3714737213 uint64_t *oldstack = (uint64_t *)stack[0];
3714837214 // copy mutable arguments back from call to equtype
@@ -37153,10 +37219,10 @@
3715337219 }
3715437220 Free(15LLU + 1, sizeof(uint64_t), stack);
3715537221 stack = oldstack;
37156- label = 3148LLU; // continue to unroll stack
37222+ label = 3154LLU; // continue to unroll stack
3715737223 break;
3715837224 }
37159- case 3150LLU: // return from equtype to markswap
37225+ case 3156LLU: // return from equtype to markswap
3716037226 {
3716137227 uint64_t *oldstack = (uint64_t *)stack[0];
3716237228 // copy mutable arguments back from call to equtype
@@ -37171,21 +37237,21 @@
3717137237 stack = oldstack;
3717237238 if(!stack[base + 5]/*isequal*/)
3717337239 {
37174- label = 3151LLU; // jump to alternative
37240+ label = 3157LLU; // jump to alternative
3717537241 break;
3717637242 }
3717737243
3717837244 // consequent
37179- label = 3152LLU; // consequent complete
37245+ label = 3158LLU; // consequent complete
3718037246 break;
3718137247 }
37182- case 3151LLU: // alternative
37248+ case 3157LLU: // alternative
3718337249 {
3718437250 fprintf(stderr, "%s", "in function ");
3718537251 // call reportid from markswap
37186- stack[base + 18LLU] = 3153LLU/*throw to this address*/;
37252+ stack[base + 18LLU] = 3159LLU/*throw to this address*/;
3718737253 stack[base + 19LLU] = base;
37188- stack[base + 20LLU] = 3154LLU;
37254+ stack[base + 20LLU] = 3160LLU;
3718937255 // arguments for call to reportid
3719037256 stack[base + 21LLU] = stack[base + 0]/*fnid*/;
3719137257 // set stack-base & callee-address
@@ -37193,13 +37259,13 @@
3719337259 label = 18446744073709551586LLU; // reportid
3719437260 break;
3719537261 }
37196- case 3153LLU: // copy-back deleter (reportid to markswap)
37262+ case 3159LLU: // copy-back deleter (reportid to markswap)
3719737263 {
3719837264 // copy mutable arguments back from call to reportid
37199- label = 3148LLU; // continue to roll stack
37265+ label = 3154LLU; // continue to roll stack
3720037266 break;
3720137267 }
37202- case 3154LLU: // return from reportid to markswap
37268+ case 3160LLU: // return from reportid to markswap
3720337269 {
3720437270 // copy mutable arguments back from call to reportid
3720537271 fprintf(stderr, "%s", ": can't swap different types ");
@@ -37206,7 +37272,7 @@
3720637272 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3720737273 if(!newstack)
3720837274 {
37209- label = 3148LLU; // throw: begin to unroll stack
37275+ label = 3154LLU; // throw: begin to unroll stack
3721037276 break;
3721137277 }
3721237278
@@ -37213,9 +37279,9 @@
3721337279 newstack[10LLU] = 9876543210LLU; // overflow-marker
3721437280 // call reporttype from markswap
3721537281 newstack[0] = (uint64_t)stack; // backup stack location
37216- newstack[1] = 3155LLU;
37282+ newstack[1] = 3161LLU;
3721737283 newstack[2] = base;
37218- newstack[3] = 3156LLU;
37284+ newstack[3] = 3162LLU;
3721937285 // arguments for call to reporttype
3722037286 newstack[4LLU] = stack[base + 8]/*xtype*/;
3722137287 stack = newstack;
@@ -37224,7 +37290,7 @@
3722437290 label = 330LLU; // reporttype
3722537291 break;
3722637292 }
37227- case 3155LLU: // copy-back deleter (reporttype to markswap)
37293+ case 3161LLU: // copy-back deleter (reporttype to markswap)
3722837294 {
3722937295 uint64_t *oldstack = (uint64_t *)stack[0];
3723037296 // copy mutable arguments back from call to reporttype
@@ -37235,10 +37301,10 @@
3723537301 }
3723637302 Free(10LLU + 1, sizeof(uint64_t), stack);
3723737303 stack = oldstack;
37238- label = 3148LLU; // continue to unroll stack
37304+ label = 3154LLU; // continue to unroll stack
3723937305 break;
3724037306 }
37241- case 3156LLU: // return from reporttype to markswap
37307+ case 3162LLU: // return from reporttype to markswap
3724237308 {
3724337309 uint64_t *oldstack = (uint64_t *)stack[0];
3724437310 // copy mutable arguments back from call to reporttype
@@ -37253,7 +37319,7 @@
3725337319 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3725437320 if(!newstack)
3725537321 {
37256- label = 3148LLU; // throw: begin to unroll stack
37322+ label = 3154LLU; // throw: begin to unroll stack
3725737323 break;
3725837324 }
3725937325
@@ -37260,9 +37326,9 @@
3726037326 newstack[10LLU] = 9876543210LLU; // overflow-marker
3726137327 // call reporttype from markswap
3726237328 newstack[0] = (uint64_t)stack; // backup stack location
37263- newstack[1] = 3157LLU;
37329+ newstack[1] = 3163LLU;
3726437330 newstack[2] = base;
37265- newstack[3] = 3158LLU;
37331+ newstack[3] = 3164LLU;
3726637332 // arguments for call to reporttype
3726737333 newstack[4LLU] = stack[base + 13]/*ytype*/;
3726837334 stack = newstack;
@@ -37271,7 +37337,7 @@
3727137337 label = 330LLU; // reporttype
3727237338 break;
3727337339 }
37274- case 3157LLU: // copy-back deleter (reporttype to markswap)
37340+ case 3163LLU: // copy-back deleter (reporttype to markswap)
3727537341 {
3727637342 uint64_t *oldstack = (uint64_t *)stack[0];
3727737343 // copy mutable arguments back from call to reporttype
@@ -37282,10 +37348,10 @@
3728237348 }
3728337349 Free(10LLU + 1, sizeof(uint64_t), stack);
3728437350 stack = oldstack;
37285- label = 3148LLU; // continue to unroll stack
37351+ label = 3154LLU; // continue to unroll stack
3728637352 break;
3728737353 }
37288- case 3158LLU: // return from reporttype to markswap
37354+ case 3164LLU: // return from reporttype to markswap
3728937355 {
3729037356 uint64_t *oldstack = (uint64_t *)stack[0];
3729137357 // copy mutable arguments back from call to reporttype
@@ -37298,32 +37364,32 @@
3729837364 stack = oldstack;
3729937365 fprintf(stderr, "%s", "\n");
3730037366 {
37301- label = 3148LLU; // throw: begin to unroll stack
37367+ label = 3154LLU; // throw: begin to unroll stack
3730237368 break;
3730337369 }
3730437370
37305- label = 3152LLU; // alternative complete
37371+ label = 3158LLU; // alternative complete
3730637372 break;
3730737373 }
37308- case 3152LLU: // completed if-then-else
37374+ case 3158LLU: // completed if-then-else
3730937375 {
3731037376 if(!stack[base + 11]/*xmutable*/)
3731137377 {
37312- label = 3159LLU; // jump to alternative
37378+ label = 3165LLU; // jump to alternative
3731337379 break;
3731437380 }
3731537381
3731637382 // consequent
37317- label = 3160LLU; // consequent complete
37383+ label = 3166LLU; // consequent complete
3731837384 break;
3731937385 }
37320- case 3159LLU: // alternative
37386+ case 3165LLU: // alternative
3732137387 {
3732237388 fprintf(stderr, "%s", "can't swap constant ");
3732337389 // call reportid from markswap
37324- stack[base + 18LLU] = 3161LLU/*throw to this address*/;
37390+ stack[base + 18LLU] = 3167LLU/*throw to this address*/;
3732537391 stack[base + 19LLU] = base;
37326- stack[base + 20LLU] = 3162LLU;
37392+ stack[base + 20LLU] = 3168LLU;
3732737393 // arguments for call to reportid
3732837394 stack[base + 21LLU] = stack[base + 3]/*xidsearch*/;
3732937395 // set stack-base & callee-address
@@ -37331,13 +37397,13 @@
3733137397 label = 18446744073709551586LLU; // reportid
3733237398 break;
3733337399 }
37334- case 3161LLU: // copy-back deleter (reportid to markswap)
37400+ case 3167LLU: // copy-back deleter (reportid to markswap)
3733537401 {
3733637402 // copy mutable arguments back from call to reportid
37337- label = 3148LLU; // continue to roll stack
37403+ label = 3154LLU; // continue to roll stack
3733837404 break;
3733937405 }
37340- case 3162LLU: // return from reportid to markswap
37406+ case 3168LLU: // return from reportid to markswap
3734137407 {
3734237408 // copy mutable arguments back from call to reportid
3734337409 fprintf(stderr, "%s", " of type ");
@@ -37344,7 +37410,7 @@
3734437410 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3734537411 if(!newstack)
3734637412 {
37347- label = 3148LLU; // throw: begin to unroll stack
37413+ label = 3154LLU; // throw: begin to unroll stack
3734837414 break;
3734937415 }
3735037416
@@ -37351,9 +37417,9 @@
3735137417 newstack[10LLU] = 9876543210LLU; // overflow-marker
3735237418 // call reporttype from markswap
3735337419 newstack[0] = (uint64_t)stack; // backup stack location
37354- newstack[1] = 3163LLU;
37420+ newstack[1] = 3169LLU;
3735537421 newstack[2] = base;
37356- newstack[3] = 3164LLU;
37422+ newstack[3] = 3170LLU;
3735737423 // arguments for call to reporttype
3735837424 newstack[4LLU] = stack[base + 8]/*xtype*/;
3735937425 stack = newstack;
@@ -37362,7 +37428,7 @@
3736237428 label = 330LLU; // reporttype
3736337429 break;
3736437430 }
37365- case 3163LLU: // copy-back deleter (reporttype to markswap)
37431+ case 3169LLU: // copy-back deleter (reporttype to markswap)
3736637432 {
3736737433 uint64_t *oldstack = (uint64_t *)stack[0];
3736837434 // copy mutable arguments back from call to reporttype
@@ -37373,10 +37439,10 @@
3737337439 }
3737437440 Free(10LLU + 1, sizeof(uint64_t), stack);
3737537441 stack = oldstack;
37376- label = 3148LLU; // continue to unroll stack
37442+ label = 3154LLU; // continue to unroll stack
3737737443 break;
3737837444 }
37379- case 3164LLU: // return from reporttype to markswap
37445+ case 3170LLU: // return from reporttype to markswap
3738037446 {
3738137447 uint64_t *oldstack = (uint64_t *)stack[0];
3738237448 // copy mutable arguments back from call to reporttype
@@ -37389,32 +37455,32 @@
3738937455 stack = oldstack;
3739037456 fprintf(stderr, "%s", "\n");
3739137457 {
37392- label = 3148LLU; // throw: begin to unroll stack
37458+ label = 3154LLU; // throw: begin to unroll stack
3739337459 break;
3739437460 }
3739537461
37396- label = 3160LLU; // alternative complete
37462+ label = 3166LLU; // alternative complete
3739737463 break;
3739837464 }
37399- case 3160LLU: // completed if-then-else
37465+ case 3166LLU: // completed if-then-else
3740037466 {
3740137467 if(!stack[base + 16]/*ymutable*/)
3740237468 {
37403- label = 3165LLU; // jump to alternative
37469+ label = 3171LLU; // jump to alternative
3740437470 break;
3740537471 }
3740637472
3740737473 // consequent
37408- label = 3166LLU; // consequent complete
37474+ label = 3172LLU; // consequent complete
3740937475 break;
3741037476 }
37411- case 3165LLU: // alternative
37477+ case 3171LLU: // alternative
3741237478 {
3741337479 fprintf(stderr, "%s", "can't swap constant ");
3741437480 // call reportid from markswap
37415- stack[base + 18LLU] = 3167LLU/*throw to this address*/;
37481+ stack[base + 18LLU] = 3173LLU/*throw to this address*/;
3741637482 stack[base + 19LLU] = base;
37417- stack[base + 20LLU] = 3168LLU;
37483+ stack[base + 20LLU] = 3174LLU;
3741837484 // arguments for call to reportid
3741937485 stack[base + 21LLU] = stack[base + 4]/*yidsearch*/;
3742037486 // set stack-base & callee-address
@@ -37422,13 +37488,13 @@
3742237488 label = 18446744073709551586LLU; // reportid
3742337489 break;
3742437490 }
37425- case 3167LLU: // copy-back deleter (reportid to markswap)
37491+ case 3173LLU: // copy-back deleter (reportid to markswap)
3742637492 {
3742737493 // copy mutable arguments back from call to reportid
37428- label = 3148LLU; // continue to roll stack
37494+ label = 3154LLU; // continue to roll stack
3742937495 break;
3743037496 }
37431- case 3168LLU: // return from reportid to markswap
37497+ case 3174LLU: // return from reportid to markswap
3743237498 {
3743337499 // copy mutable arguments back from call to reportid
3743437500 fprintf(stderr, "%s", " of type ");
@@ -37435,7 +37501,7 @@
3743537501 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3743637502 if(!newstack)
3743737503 {
37438- label = 3148LLU; // throw: begin to unroll stack
37504+ label = 3154LLU; // throw: begin to unroll stack
3743937505 break;
3744037506 }
3744137507
@@ -37442,9 +37508,9 @@
3744237508 newstack[10LLU] = 9876543210LLU; // overflow-marker
3744337509 // call reporttype from markswap
3744437510 newstack[0] = (uint64_t)stack; // backup stack location
37445- newstack[1] = 3169LLU;
37511+ newstack[1] = 3175LLU;
3744637512 newstack[2] = base;
37447- newstack[3] = 3170LLU;
37513+ newstack[3] = 3176LLU;
3744837514 // arguments for call to reporttype
3744937515 newstack[4LLU] = stack[base + 13]/*ytype*/;
3745037516 stack = newstack;
@@ -37453,7 +37519,7 @@
3745337519 label = 330LLU; // reporttype
3745437520 break;
3745537521 }
37456- case 3169LLU: // copy-back deleter (reporttype to markswap)
37522+ case 3175LLU: // copy-back deleter (reporttype to markswap)
3745737523 {
3745837524 uint64_t *oldstack = (uint64_t *)stack[0];
3745937525 // copy mutable arguments back from call to reporttype
@@ -37464,10 +37530,10 @@
3746437530 }
3746537531 Free(10LLU + 1, sizeof(uint64_t), stack);
3746637532 stack = oldstack;
37467- label = 3148LLU; // continue to unroll stack
37533+ label = 3154LLU; // continue to unroll stack
3746837534 break;
3746937535 }
37470- case 3170LLU: // return from reporttype to markswap
37536+ case 3176LLU: // return from reporttype to markswap
3747137537 {
3747237538 uint64_t *oldstack = (uint64_t *)stack[0];
3747337539 // copy mutable arguments back from call to reporttype
@@ -37480,20 +37546,20 @@
3748037546 stack = oldstack;
3748137547 fprintf(stderr, "%s", "\n");
3748237548 {
37483- label = 3148LLU; // throw: begin to unroll stack
37549+ label = 3154LLU; // throw: begin to unroll stack
3748437550 break;
3748537551 }
3748637552
37487- label = 3166LLU; // alternative complete
37553+ label = 3172LLU; // alternative complete
3748837554 break;
3748937555 }
37490- case 3166LLU: // completed if-then-else
37556+ case 3172LLU: // completed if-then-else
3749137557 {
3749237558 printf("%s", "\n swap(&");
3749337559 // call emitvaridx from markswap
37494- stack[base + 18LLU] = 3171LLU/*throw to this address*/;
37560+ stack[base + 18LLU] = 3177LLU/*throw to this address*/;
3749537561 stack[base + 19LLU] = base;
37496- stack[base + 20LLU] = 3172LLU;
37562+ stack[base + 20LLU] = 3178LLU;
3749737563 // arguments for call to emitvaridx
3749837564 stack[base + 21LLU] = stack[base + 10]/*xindex*/;
3749937565 // set stack-base & callee-address
@@ -37501,20 +37567,20 @@
3750137567 label = 745LLU; // emitvaridx
3750237568 break;
3750337569 }
37504- case 3171LLU: // copy-back deleter (emitvaridx to markswap)
37570+ case 3177LLU: // copy-back deleter (emitvaridx to markswap)
3750537571 {
3750637572 // copy mutable arguments back from call to emitvaridx
37507- label = 3148LLU; // continue to roll stack
37573+ label = 3154LLU; // continue to roll stack
3750837574 break;
3750937575 }
37510- case 3172LLU: // return from emitvaridx to markswap
37576+ case 3178LLU: // return from emitvaridx to markswap
3751137577 {
3751237578 // copy mutable arguments back from call to emitvaridx
3751337579 printf("%s", ", &");
3751437580 // call emitvaridx from markswap
37515- stack[base + 18LLU] = 3173LLU/*throw to this address*/;
37581+ stack[base + 18LLU] = 3179LLU/*throw to this address*/;
3751637582 stack[base + 19LLU] = base;
37517- stack[base + 20LLU] = 3174LLU;
37583+ stack[base + 20LLU] = 3180LLU;
3751837584 // arguments for call to emitvaridx
3751937585 stack[base + 21LLU] = stack[base + 15]/*yindex*/;
3752037586 // set stack-base & callee-address
@@ -37522,13 +37588,13 @@
3752237588 label = 745LLU; // emitvaridx
3752337589 break;
3752437590 }
37525- case 3173LLU: // copy-back deleter (emitvaridx to markswap)
37591+ case 3179LLU: // copy-back deleter (emitvaridx to markswap)
3752637592 {
3752737593 // copy mutable arguments back from call to emitvaridx
37528- label = 3148LLU; // continue to roll stack
37594+ label = 3154LLU; // continue to roll stack
3752937595 break;
3753037596 }
37531- case 3174LLU: // return from emitvaridx to markswap
37597+ case 3180LLU: // return from emitvaridx to markswap
3753237598 {
3753337599 // copy mutable arguments back from call to emitvaridx
3753437600 printf("%s", ");");
@@ -37542,10 +37608,10 @@
3754237608 ((uint64_t **)(stack[base + 6]))[1][2] = stack[base + 10];
3754337609 ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 9];
3754437610 ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 8];
37545- label = 3146LLU; // case complete
37611+ label = 3152LLU; // case complete
3754637612 break;
3754737613 }
37548- case 3148LLU: // copy-back deleter (switch)
37614+ case 3154LLU: // copy-back deleter (switch)
3754937615 {
3755037616 ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 17];
3755137617 ((uint64_t **)(stack[base + 7]))[1][3] = stack[base + 16];
@@ -37557,15 +37623,15 @@
3755737623 ((uint64_t **)(stack[base + 6]))[1][2] = stack[base + 10];
3755837624 ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 9];
3755937625 ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 8];
37560- label = 3141LLU; // continue to unroll stack
37626+ label = 3147LLU; // continue to unroll stack
3756137627 break;
3756237628 }
37563- case 3147LLU: // try next case
37629+ case 3153LLU: // try next case
3756437630 {
3756537631 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3756637632 exit(-1);
3756737633 }
37568- case 3146LLU: // completed switch
37634+ case 3152LLU: // completed switch
3756937635 {
3757037636
3757137637 uint64_t *newstack = (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4);
@@ -37573,7 +37639,7 @@
3757337639 newstack[0] = (uint64_t)stack; // backup stack location
3757437640 newstack[1] = 1234567890;
3757537641 newstack[2] = base;
37576- newstack[3] = 3175LLU;
37642+ newstack[3] = 3181LLU;
3757737643 stack = newstack;
3757837644 // set stack-base & callee-address
3757937645 base = 4/*deloffset*/;
@@ -37580,7 +37646,7 @@
3758037646 label = 486LLU; // ~letdef
3758137647 break;
3758237648 }
37583- case 3175LLU: // return from ~letdef to markswap
37649+ case 3181LLU: // return from ~letdef to markswap
3758437650 {
3758537651 stack = (uint64_t *)stack[0];
3758637652 // releasing toplevel container
@@ -37592,7 +37658,7 @@
3759237658 newstack[0] = (uint64_t)stack; // backup stack location
3759337659 newstack[1] = 1234567890;
3759437660 newstack[2] = base;
37595- newstack[3] = 3176LLU;
37661+ newstack[3] = 3182LLU;
3759637662 stack = newstack;
3759737663 // set stack-base & callee-address
3759837664 base = 4/*deloffset*/;
@@ -37599,7 +37665,7 @@
3759937665 label = 486LLU; // ~letdef
3760037666 break;
3760137667 }
37602- case 3176LLU: // return from ~letdef to markswap
37668+ case 3182LLU: // return from ~letdef to markswap
3760337669 {
3760437670 stack = (uint64_t *)stack[0];
3760537671 // releasing toplevel container
@@ -37610,13 +37676,13 @@
3761037676 base = stack[base - 2];
3761137677 break;
3761237678 }
37613- case 3178LLU: // function assignment failed
37679+ case 3184LLU: // function assignment failed
3761437680 {
3761537681 label = stack[base - 3];
3761637682 base = stack[base - 2];
3761737683 break;
3761837684 }
37619- case 3177LLU: // assignment
37685+ case 3183LLU: // assignment
3762037686 {
3762137687 //#define arg0 0
3762237688 //#define arg1 1
@@ -37624,26 +37690,26 @@
3762437690 //#define arg3 3
3762537691 //#define arg4 4
3762637692 //#define arg5 5
37627- label = 3180LLU; // skip deleter
37693+ label = 3186LLU; // skip deleter
3762837694 break;
3762937695 }
37630- case 3179LLU: // deleter
37696+ case 3185LLU: // deleter
3763137697 {
3763237698 // throw from assignment
3763337699 if(!stack[base + 6])
3763437700 {
37635- label = 3178LLU; // skip, variable already deleted/unscoped
37701+ label = 3184LLU; // skip, variable already deleted/unscoped
3763637702 break;
3763737703 }
37638- label = 3178LLU; // continue unrolling stack, delete next variable
37704+ label = 3184LLU; // continue unrolling stack, delete next variable
3763937705 break;
3764037706 }
37641- case 3180LLU: // skipped deleter
37707+ case 3186LLU: // skipped deleter
3764237708 {
3764337709 stack[base + 6] = 0;
3764437710 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*letdef*/))[0])
3764537711 {
37646- label = 3182LLU; // jump to alternative
37712+ label = 3188LLU; // jump to alternative
3764737713 break;
3764837714 }
3764937715
@@ -37656,21 +37722,21 @@
3765637722 // case
3765737723 if(!stack[base + 10]/*mutable*/)
3765837724 {
37659- label = 3184LLU; // jump to alternative
37725+ label = 3190LLU; // jump to alternative
3766037726 break;
3766137727 }
3766237728
3766337729 // consequent
37664- label = 3185LLU; // consequent complete
37730+ label = 3191LLU; // consequent complete
3766537731 break;
3766637732 }
37667- case 3184LLU: // alternative
37733+ case 3190LLU: // alternative
3766837734 {
3766937735 fprintf(stderr, "%s", "in function ");
3767037736 // call reportid from assignment
37671- stack[base + 12LLU] = 3186LLU/*throw to this address*/;
37737+ stack[base + 12LLU] = 3192LLU/*throw to this address*/;
3767237738 stack[base + 13LLU] = base;
37673- stack[base + 14LLU] = 3187LLU;
37739+ stack[base + 14LLU] = 3193LLU;
3767437740 // arguments for call to reportid
3767537741 stack[base + 15LLU] = stack[base + 0]/*fnid*/;
3767637742 // set stack-base & callee-address
@@ -37678,20 +37744,20 @@
3767837744 label = 18446744073709551586LLU; // reportid
3767937745 break;
3768037746 }
37681- case 3186LLU: // copy-back deleter (reportid to assignment)
37747+ case 3192LLU: // copy-back deleter (reportid to assignment)
3768237748 {
3768337749 // copy mutable arguments back from call to reportid
37684- label = 3183LLU; // continue to roll stack
37750+ label = 3189LLU; // continue to roll stack
3768537751 break;
3768637752 }
37687- case 3187LLU: // return from reportid to assignment
37753+ case 3193LLU: // return from reportid to assignment
3768837754 {
3768937755 // copy mutable arguments back from call to reportid
3769037756 fprintf(stderr, "%s", ": assignment to constant ");
3769137757 // call reportid from assignment
37692- stack[base + 12LLU] = 3188LLU/*throw to this address*/;
37758+ stack[base + 12LLU] = 3194LLU/*throw to this address*/;
3769337759 stack[base + 13LLU] = base;
37694- stack[base + 14LLU] = 3189LLU;
37760+ stack[base + 14LLU] = 3195LLU;
3769537761 // arguments for call to reportid
3769637762 stack[base + 15LLU] = stack[base + 8]/*id*/;
3769737763 // set stack-base & callee-address
@@ -37699,62 +37765,62 @@
3769937765 label = 18446744073709551586LLU; // reportid
3770037766 break;
3770137767 }
37702- case 3188LLU: // copy-back deleter (reportid to assignment)
37768+ case 3194LLU: // copy-back deleter (reportid to assignment)
3770337769 {
3770437770 // copy mutable arguments back from call to reportid
37705- label = 3183LLU; // continue to roll stack
37771+ label = 3189LLU; // continue to roll stack
3770637772 break;
3770737773 }
37708- case 3189LLU: // return from reportid to assignment
37774+ case 3195LLU: // return from reportid to assignment
3770937775 {
3771037776 // copy mutable arguments back from call to reportid
3771137777 fprintf(stderr, "%s", "\n");
3771237778 {
37713- label = 3183LLU; // throw: begin to unroll stack
37779+ label = 3189LLU; // throw: begin to unroll stack
3771437780 break;
3771537781 }
3771637782
37717- label = 3185LLU; // alternative complete
37783+ label = 3191LLU; // alternative complete
3771837784 break;
3771937785 }
37720- case 3185LLU: // completed if-then-else
37786+ case 3191LLU: // completed if-then-else
3772137787 {
37722- label = 3191LLU; // skip deleter
37788+ label = 3197LLU; // skip deleter
3772337789 break;
3772437790 }
37725- case 3190LLU: // deleter
37791+ case 3196LLU: // deleter
3772637792 {
3772737793 // throw from assignment
3772837794 if(!stack[base + 12])
3772937795 {
37730- label = 3183LLU; // skip, variable already deleted/unscoped
37796+ label = 3189LLU; // skip, variable already deleted/unscoped
3773137797 break;
3773237798 }
37733- label = 3183LLU; // continue unrolling stack, delete next variable
37799+ label = 3189LLU; // continue unrolling stack, delete next variable
3773437800 break;
3773537801 }
37736- case 3191LLU: // skipped deleter
37802+ case 3197LLU: // skipped deleter
3773737803 {
37738- label = 3193LLU; // skip deleter
37804+ label = 3199LLU; // skip deleter
3773937805 break;
3774037806 }
37741- case 3192LLU: // deleter
37807+ case 3198LLU: // deleter
3774237808 {
3774337809 // throw from assignment
3774437810 if(!stack[base + 13])
3774537811 {
37746- label = 3190LLU; // skip, variable already deleted/unscoped
37812+ label = 3196LLU; // skip, variable already deleted/unscoped
3774737813 break;
3774837814 }
37749- label = 3190LLU; // continue unrolling stack, delete next variable
37815+ label = 3196LLU; // continue unrolling stack, delete next variable
3775037816 break;
3775137817 }
37752- case 3193LLU: // skipped deleter
37818+ case 3199LLU: // skipped deleter
3775337819 {
3775437820 // call ParseToken from assignment
37755- stack[base + 14LLU] = 3194LLU/*throw to this address*/;
37821+ stack[base + 14LLU] = 3200LLU/*throw to this address*/;
3775637822 stack[base + 15LLU] = base;
37757- stack[base + 16LLU] = 3195LLU;
37823+ stack[base + 16LLU] = 3201LLU;
3775837824 // arguments for call to ParseToken
3775937825 stack[base + 19LLU] = stack[base + 5]/*lookahead*/;
3776037826 // set stack-base & callee-address
@@ -37762,14 +37828,14 @@
3776237828 label = 3LLU; // ParseToken
3776337829 break;
3776437830 }
37765- case 3194LLU: // copy-back deleter (ParseToken to assignment)
37831+ case 3200LLU: // copy-back deleter (ParseToken to assignment)
3776637832 {
3776737833 // copy mutable arguments back from call to ParseToken
3776837834 stack[base + 5]/*lookahead*/ = stack[base + 19LLU];
37769- label = 3183LLU; // continue to roll stack
37835+ label = 3189LLU; // continue to roll stack
3777037836 break;
3777137837 }
37772- case 3195LLU: // return from ParseToken to assignment
37838+ case 3201LLU: // return from ParseToken to assignment
3777337839 {
3777437840 // copy mutable arguments back from call to ParseToken
3777537841 stack[base + 5]/*lookahead*/ = stack[base + 19LLU];
@@ -37778,7 +37844,7 @@
3777837844 stack[base + 13] = stack[base + 18LLU];
3777937845 if(/*typedata*/0 != ((uint64_t *)(stack[base + 7]/*type*/))[0])
3778037846 {
37781- label = 3197LLU; // jump to alternative
37847+ label = 3203LLU; // jump to alternative
3778237848 break;
3778337849 }
3778437850
@@ -37786,9 +37852,9 @@
3778637852
3778737853 // case
3778837854 // call equ from assignment
37789- stack[base + 15LLU] = 3199LLU/*throw to this address*/;
37855+ stack[base + 15LLU] = 3205LLU/*throw to this address*/;
3779037856 stack[base + 16LLU] = base;
37791- stack[base + 17LLU] = 3200LLU;
37857+ stack[base + 17LLU] = 3206LLU;
3779237858 // arguments for call to equ
3779337859 stack[base + 19LLU] = 881834713755418624LLU;
3779437860 stack[base + 20LLU] = stack[base + 14]/*name*/;
@@ -37797,13 +37863,13 @@
3779737863 label = 18446744073709551600LLU; // equ
3779837864 break;
3779937865 }
37800- case 3199LLU: // copy-back deleter (equ to assignment)
37866+ case 3205LLU: // copy-back deleter (equ to assignment)
3780137867 {
3780237868 // copy mutable arguments back from call to equ
37803- label = 3198LLU; // continue to roll stack
37869+ label = 3204LLU; // continue to roll stack
3780437870 break;
3780537871 }
37806- case 3200LLU: // return from equ to assignment
37872+ case 3206LLU: // return from equ to assignment
3780737873 {
3780837874 // copy mutable arguments back from call to equ
3780937875 // copy back results provided by call to equ
@@ -37810,15 +37876,15 @@
3781037876 stack[base + 6] = stack[base + 18LLU];
3781137877 if(!stack[base + 6]/*isequal*/)
3781237878 {
37813- label = 3201LLU; // jump to alternative
37879+ label = 3207LLU; // jump to alternative
3781437880 break;
3781537881 }
3781637882
3781737883 // consequent
3781837884 // call isncs from assignment
37819- stack[base + 15LLU] = 3203LLU/*throw to this address*/;
37885+ stack[base + 15LLU] = 3209LLU/*throw to this address*/;
3782037886 stack[base + 16LLU] = base;
37821- stack[base + 17LLU] = 3204LLU;
37887+ stack[base + 17LLU] = 3210LLU;
3782237888 // arguments for call to isncs
3782337889 stack[base + 19LLU] = stack[base + 12]/*variant*/;
3782437890 // set stack-base & callee-address
@@ -37826,13 +37892,13 @@
3782637892 label = 286LLU; // isncs
3782737893 break;
3782837894 }
37829- case 3203LLU: // copy-back deleter (isncs to assignment)
37895+ case 3209LLU: // copy-back deleter (isncs to assignment)
3783037896 {
3783137897 // copy mutable arguments back from call to isncs
37832- label = 3198LLU; // continue to roll stack
37898+ label = 3204LLU; // continue to roll stack
3783337899 break;
3783437900 }
37835- case 3204LLU: // return from isncs to assignment
37901+ case 3210LLU: // return from isncs to assignment
3783637902 {
3783737903 // copy mutable arguments back from call to isncs
3783837904 // copy back results provided by call to isncs
@@ -37839,7 +37905,7 @@
3783937905 stack[base + 6] = stack[base + 18LLU];
3784037906 if(!stack[base + 6]/*isequal*/)
3784137907 {
37842- label = 3205LLU; // jump to alternative
37908+ label = 3211LLU; // jump to alternative
3784337909 break;
3784437910 }
3784537911
@@ -37846,9 +37912,9 @@
3784637912 // consequent
3784737913 printf("%s", "\n ");
3784837914 // call emitvar from assignment
37849- stack[base + 15LLU] = 3207LLU/*throw to this address*/;
37915+ stack[base + 15LLU] = 3213LLU/*throw to this address*/;
3785037916 stack[base + 16LLU] = base;
37851- stack[base + 17LLU] = 3208LLU;
37917+ stack[base + 17LLU] = 3214LLU;
3785237918 // arguments for call to emitvar
3785337919 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
3785437920 stack[base + 19LLU] = stack[base + 8]/*id*/;
@@ -37859,20 +37925,20 @@
3785937925 label = 749LLU; // emitvar
3786037926 break;
3786137927 }
37862- case 3207LLU: // copy-back deleter (emitvar to assignment)
37928+ case 3213LLU: // copy-back deleter (emitvar to assignment)
3786337929 {
3786437930 // copy mutable arguments back from call to emitvar
37865- label = 3198LLU; // continue to roll stack
37931+ label = 3204LLU; // continue to roll stack
3786637932 break;
3786737933 }
37868- case 3208LLU: // return from emitvar to assignment
37934+ case 3214LLU: // return from emitvar to assignment
3786937935 {
3787037936 // copy mutable arguments back from call to emitvar
3787137937 printf("%s", " = ");
3787237938 // call printnr from assignment
37873- stack[base + 15LLU] = 3209LLU/*throw to this address*/;
37939+ stack[base + 15LLU] = 3215LLU/*throw to this address*/;
3787437940 stack[base + 16LLU] = base;
37875- stack[base + 17LLU] = 3210LLU;
37941+ stack[base + 17LLU] = 3216LLU;
3787637942 // arguments for call to printnr
3787737943 stack[base + 18LLU] = stack[base + 13]/*content*/;
3787837944 // set stack-base & callee-address
@@ -37880,25 +37946,25 @@
3788037946 label = 18446744073709551590LLU; // printnr
3788137947 break;
3788237948 }
37883- case 3209LLU: // copy-back deleter (printnr to assignment)
37949+ case 3215LLU: // copy-back deleter (printnr to assignment)
3788437950 {
3788537951 // copy mutable arguments back from call to printnr
37886- label = 3198LLU; // continue to roll stack
37952+ label = 3204LLU; // continue to roll stack
3788737953 break;
3788837954 }
37889- case 3210LLU: // return from printnr to assignment
37955+ case 3216LLU: // return from printnr to assignment
3789037956 {
3789137957 // copy mutable arguments back from call to printnr
3789237958 printf("%s", ";");
37893- label = 3206LLU; // consequent complete
37959+ label = 3212LLU; // consequent complete
3789437960 break;
3789537961 }
37896- case 3205LLU: // alternative
37962+ case 3211LLU: // alternative
3789737963 {
3789837964 // call equ from assignment
37899- stack[base + 15LLU] = 3211LLU/*throw to this address*/;
37965+ stack[base + 15LLU] = 3217LLU/*throw to this address*/;
3790037966 stack[base + 16LLU] = base;
37901- stack[base + 17LLU] = 3212LLU;
37967+ stack[base + 17LLU] = 3218LLU;
3790237968 // arguments for call to equ
3790337969 stack[base + 19LLU] = stack[base + 12]/*variant*/;
3790437970 stack[base + 20LLU] = 4LLU;
@@ -37907,13 +37973,13 @@
3790737973 label = 18446744073709551600LLU; // equ
3790837974 break;
3790937975 }
37910- case 3211LLU: // copy-back deleter (equ to assignment)
37976+ case 3217LLU: // copy-back deleter (equ to assignment)
3791137977 {
3791237978 // copy mutable arguments back from call to equ
37913- label = 3198LLU; // continue to roll stack
37979+ label = 3204LLU; // continue to roll stack
3791437980 break;
3791537981 }
37916- case 3212LLU: // return from equ to assignment
37982+ case 3218LLU: // return from equ to assignment
3791737983 {
3791837984 // copy mutable arguments back from call to equ
3791937985 // copy back results provided by call to equ
@@ -37920,7 +37986,7 @@
3792037986 stack[base + 6] = stack[base + 18LLU];
3792137987 if(!stack[base + 6]/*isequal*/)
3792237988 {
37923- label = 3213LLU; // jump to alternative
37989+ label = 3219LLU; // jump to alternative
3792437990 break;
3792537991 }
3792637992
@@ -37927,9 +37993,9 @@
3792737993 // consequent
3792837994 printf("%s", "\n ");
3792937995 // call emitvar from assignment
37930- stack[base + 15LLU] = 3215LLU/*throw to this address*/;
37996+ stack[base + 15LLU] = 3221LLU/*throw to this address*/;
3793137997 stack[base + 16LLU] = base;
37932- stack[base + 17LLU] = 3216LLU;
37998+ stack[base + 17LLU] = 3222LLU;
3793337999 // arguments for call to emitvar
3793438000 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
3793538001 stack[base + 19LLU] = stack[base + 8]/*id*/;
@@ -37940,20 +38006,20 @@
3794038006 label = 749LLU; // emitvar
3794138007 break;
3794238008 }
37943- case 3215LLU: // copy-back deleter (emitvar to assignment)
38009+ case 3221LLU: // copy-back deleter (emitvar to assignment)
3794438010 {
3794538011 // copy mutable arguments back from call to emitvar
37946- label = 3198LLU; // continue to roll stack
38012+ label = 3204LLU; // continue to roll stack
3794738013 break;
3794838014 }
37949- case 3216LLU: // return from emitvar to assignment
38015+ case 3222LLU: // return from emitvar to assignment
3795038016 {
3795138017 // copy mutable arguments back from call to emitvar
3795238018 printf("%s", " = ");
3795338019 // call emitvar from assignment
37954- stack[base + 15LLU] = 3217LLU/*throw to this address*/;
38020+ stack[base + 15LLU] = 3223LLU/*throw to this address*/;
3795538021 stack[base + 16LLU] = base;
37956- stack[base + 17LLU] = 3218LLU;
38022+ stack[base + 17LLU] = 3224LLU;
3795738023 // arguments for call to emitvar
3795838024 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
3795938025 stack[base + 19LLU] = stack[base + 13]/*content*/;
@@ -37964,26 +38030,26 @@
3796438030 label = 749LLU; // emitvar
3796538031 break;
3796638032 }
37967- case 3217LLU: // copy-back deleter (emitvar to assignment)
38033+ case 3223LLU: // copy-back deleter (emitvar to assignment)
3796838034 {
3796938035 // copy mutable arguments back from call to emitvar
37970- label = 3198LLU; // continue to roll stack
38036+ label = 3204LLU; // continue to roll stack
3797138037 break;
3797238038 }
37973- case 3218LLU: // return from emitvar to assignment
38039+ case 3224LLU: // return from emitvar to assignment
3797438040 {
3797538041 // copy mutable arguments back from call to emitvar
3797638042 printf("%s", ";");
37977- label = 3214LLU; // consequent complete
38043+ label = 3220LLU; // consequent complete
3797838044 break;
3797938045 }
37980- case 3213LLU: // alternative
38046+ case 3219LLU: // alternative
3798138047 {
3798238048 fprintf(stderr, "%s", "parsing assignment unexpected token ");
3798338049 // call reporttok from assignment
37984- stack[base + 15LLU] = 3219LLU/*throw to this address*/;
38050+ stack[base + 15LLU] = 3225LLU/*throw to this address*/;
3798538051 stack[base + 16LLU] = base;
37986- stack[base + 17LLU] = 3220LLU;
38052+ stack[base + 17LLU] = 3226LLU;
3798738053 // arguments for call to reporttok
3798838054 stack[base + 18LLU] = stack[base + 12]/*variant*/;
3798938055 stack[base + 19LLU] = stack[base + 13]/*content*/;
@@ -37992,41 +38058,41 @@
3799238058 label = 18446744073709551582LLU; // reporttok
3799338059 break;
3799438060 }
37995- case 3219LLU: // copy-back deleter (reporttok to assignment)
38061+ case 3225LLU: // copy-back deleter (reporttok to assignment)
3799638062 {
3799738063 // copy mutable arguments back from call to reporttok
37998- label = 3198LLU; // continue to roll stack
38064+ label = 3204LLU; // continue to roll stack
3799938065 break;
3800038066 }
38001- case 3220LLU: // return from reporttok to assignment
38067+ case 3226LLU: // return from reporttok to assignment
3800238068 {
3800338069 // copy mutable arguments back from call to reporttok
3800438070 fprintf(stderr, "%s", "\n");
3800538071 {
38006- label = 3198LLU; // throw: begin to unroll stack
38072+ label = 3204LLU; // throw: begin to unroll stack
3800738073 break;
3800838074 }
3800938075
38010- label = 3214LLU; // alternative complete
38076+ label = 3220LLU; // alternative complete
3801138077 break;
3801238078 }
38013- case 3214LLU: // completed if-then-else
38079+ case 3220LLU: // completed if-then-else
3801438080 {
38015- label = 3206LLU; // alternative complete
38081+ label = 3212LLU; // alternative complete
3801638082 break;
3801738083 }
38018- case 3206LLU: // completed if-then-else
38084+ case 3212LLU: // completed if-then-else
3801938085 {
38020- label = 3202LLU; // consequent complete
38086+ label = 3208LLU; // consequent complete
3802138087 break;
3802238088 }
38023- case 3201LLU: // alternative
38089+ case 3207LLU: // alternative
3802438090 {
3802538091 fprintf(stderr, "%s", "in function ");
3802638092 // call reportid from assignment
38027- stack[base + 15LLU] = 3221LLU/*throw to this address*/;
38093+ stack[base + 15LLU] = 3227LLU/*throw to this address*/;
3802838094 stack[base + 16LLU] = base;
38029- stack[base + 17LLU] = 3222LLU;
38095+ stack[base + 17LLU] = 3228LLU;
3803038096 // arguments for call to reportid
3803138097 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
3803238098 // set stack-base & callee-address
@@ -38034,13 +38100,13 @@
3803438100 label = 18446744073709551586LLU; // reportid
3803538101 break;
3803638102 }
38037- case 3221LLU: // copy-back deleter (reportid to assignment)
38103+ case 3227LLU: // copy-back deleter (reportid to assignment)
3803838104 {
3803938105 // copy mutable arguments back from call to reportid
38040- label = 3198LLU; // continue to roll stack
38106+ label = 3204LLU; // continue to roll stack
3804138107 break;
3804238108 }
38043- case 3222LLU: // return from reportid to assignment
38109+ case 3228LLU: // return from reportid to assignment
3804438110 {
3804538111 // copy mutable arguments back from call to reportid
3804638112 fprintf(stderr, "%s", ": can only assign to u64 but found ");
@@ -38047,7 +38113,7 @@
3804738113 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3804838114 if(!newstack)
3804938115 {
38050- label = 3198LLU; // throw: begin to unroll stack
38116+ label = 3204LLU; // throw: begin to unroll stack
3805138117 break;
3805238118 }
3805338119
@@ -38054,9 +38120,9 @@
3805438120 newstack[10LLU] = 9876543210LLU; // overflow-marker
3805538121 // call reporttype from assignment
3805638122 newstack[0] = (uint64_t)stack; // backup stack location
38057- newstack[1] = 3223LLU;
38123+ newstack[1] = 3229LLU;
3805838124 newstack[2] = base;
38059- newstack[3] = 3224LLU;
38125+ newstack[3] = 3230LLU;
3806038126 // arguments for call to reporttype
3806138127 newstack[4LLU] = stack[base + 7]/*type*/;
3806238128 stack = newstack;
@@ -38065,7 +38131,7 @@
3806538131 label = 330LLU; // reporttype
3806638132 break;
3806738133 }
38068- case 3223LLU: // copy-back deleter (reporttype to assignment)
38134+ case 3229LLU: // copy-back deleter (reporttype to assignment)
3806938135 {
3807038136 uint64_t *oldstack = (uint64_t *)stack[0];
3807138137 // copy mutable arguments back from call to reporttype
@@ -38076,10 +38142,10 @@
3807638142 }
3807738143 Free(10LLU + 1, sizeof(uint64_t), stack);
3807838144 stack = oldstack;
38079- label = 3198LLU; // continue to unroll stack
38145+ label = 3204LLU; // continue to unroll stack
3808038146 break;
3808138147 }
38082- case 3224LLU: // return from reporttype to assignment
38148+ case 3230LLU: // return from reporttype to assignment
3808338149 {
3808438150 uint64_t *oldstack = (uint64_t *)stack[0];
3808538151 // copy mutable arguments back from call to reporttype
@@ -38092,9 +38158,9 @@
3809238158 stack = oldstack;
3809338159 fprintf(stderr, "%s", " ");
3809438160 // call reportid from assignment
38095- stack[base + 15LLU] = 3225LLU/*throw to this address*/;
38161+ stack[base + 15LLU] = 3231LLU/*throw to this address*/;
3809638162 stack[base + 16LLU] = base;
38097- stack[base + 17LLU] = 3226LLU;
38163+ stack[base + 17LLU] = 3232LLU;
3809838164 // arguments for call to reportid
3809938165 stack[base + 18LLU] = stack[base + 8]/*id*/;
3810038166 // set stack-base & callee-address
@@ -38102,41 +38168,41 @@
3810238168 label = 18446744073709551586LLU; // reportid
3810338169 break;
3810438170 }
38105- case 3225LLU: // copy-back deleter (reportid to assignment)
38171+ case 3231LLU: // copy-back deleter (reportid to assignment)
3810638172 {
3810738173 // copy mutable arguments back from call to reportid
38108- label = 3198LLU; // continue to roll stack
38174+ label = 3204LLU; // continue to roll stack
3810938175 break;
3811038176 }
38111- case 3226LLU: // return from reportid to assignment
38177+ case 3232LLU: // return from reportid to assignment
3811238178 {
3811338179 // copy mutable arguments back from call to reportid
3811438180 fprintf(stderr, "%s", " instead - use SWAP\n");
3811538181 {
38116- label = 3198LLU; // throw: begin to unroll stack
38182+ label = 3204LLU; // throw: begin to unroll stack
3811738183 break;
3811838184 }
3811938185
38120- label = 3202LLU; // alternative complete
38186+ label = 3208LLU; // alternative complete
3812138187 break;
3812238188 }
38123- case 3202LLU: // completed if-then-else
38189+ case 3208LLU: // completed if-then-else
3812438190 {
3812538191 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
38126- label = 3196LLU; // case complete
38192+ label = 3202LLU; // case complete
3812738193 break;
3812838194 }
38129- case 3198LLU: // copy-back deleter (switch)
38195+ case 3204LLU: // copy-back deleter (switch)
3813038196 {
3813138197 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
38132- label = 3192LLU; // continue to unroll stack
38198+ label = 3198LLU; // continue to unroll stack
3813338199 break;
3813438200 }
38135- case 3197LLU: // try next case
38201+ case 3203LLU: // try next case
3813638202 {
3813738203 if(/*typelist*/1 != ((uint64_t *)(stack[base + 7]/*type*/))[0])
3813838204 {
38139- label = 3227LLU; // jump to alternative
38205+ label = 3233LLU; // jump to alternative
3814038206 break;
3814138207 }
3814238208
@@ -38145,9 +38211,9 @@
3814538211 // case
3814638212 fprintf(stderr, "%s", "in function ");
3814738213 // call reportid from assignment
38148- stack[base + 15LLU] = 3229LLU/*throw to this address*/;
38214+ stack[base + 15LLU] = 3235LLU/*throw to this address*/;
3814938215 stack[base + 16LLU] = base;
38150- stack[base + 17LLU] = 3230LLU;
38216+ stack[base + 17LLU] = 3236LLU;
3815138217 // arguments for call to reportid
3815238218 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
3815338219 // set stack-base & callee-address
@@ -38155,13 +38221,13 @@
3815538221 label = 18446744073709551586LLU; // reportid
3815638222 break;
3815738223 }
38158- case 3229LLU: // copy-back deleter (reportid to assignment)
38224+ case 3235LLU: // copy-back deleter (reportid to assignment)
3815938225 {
3816038226 // copy mutable arguments back from call to reportid
38161- label = 3228LLU; // continue to roll stack
38227+ label = 3234LLU; // continue to roll stack
3816238228 break;
3816338229 }
38164- case 3230LLU: // return from reportid to assignment
38230+ case 3236LLU: // return from reportid to assignment
3816538231 {
3816638232 // copy mutable arguments back from call to reportid
3816738233 fprintf(stderr, "%s", ": cannot assign to list ");
@@ -38168,7 +38234,7 @@
3816838234 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3816938235 if(!newstack)
3817038236 {
38171- label = 3228LLU; // throw: begin to unroll stack
38237+ label = 3234LLU; // throw: begin to unroll stack
3817238238 break;
3817338239 }
3817438240
@@ -38175,9 +38241,9 @@
3817538241 newstack[10LLU] = 9876543210LLU; // overflow-marker
3817638242 // call reporttype from assignment
3817738243 newstack[0] = (uint64_t)stack; // backup stack location
38178- newstack[1] = 3231LLU;
38244+ newstack[1] = 3237LLU;
3817938245 newstack[2] = base;
38180- newstack[3] = 3232LLU;
38246+ newstack[3] = 3238LLU;
3818138247 // arguments for call to reporttype
3818238248 newstack[4LLU] = stack[base + 7]/*type*/;
3818338249 stack = newstack;
@@ -38186,7 +38252,7 @@
3818638252 label = 330LLU; // reporttype
3818738253 break;
3818838254 }
38189- case 3231LLU: // copy-back deleter (reporttype to assignment)
38255+ case 3237LLU: // copy-back deleter (reporttype to assignment)
3819038256 {
3819138257 uint64_t *oldstack = (uint64_t *)stack[0];
3819238258 // copy mutable arguments back from call to reporttype
@@ -38197,10 +38263,10 @@
3819738263 }
3819838264 Free(10LLU + 1, sizeof(uint64_t), stack);
3819938265 stack = oldstack;
38200- label = 3228LLU; // continue to unroll stack
38266+ label = 3234LLU; // continue to unroll stack
3820138267 break;
3820238268 }
38203- case 3232LLU: // return from reporttype to assignment
38269+ case 3238LLU: // return from reporttype to assignment
3820438270 {
3820538271 uint64_t *oldstack = (uint64_t *)stack[0];
3820638272 // copy mutable arguments back from call to reporttype
@@ -38213,9 +38279,9 @@
3821338279 stack = oldstack;
3821438280 fprintf(stderr, "%s", " ");
3821538281 // call reportid from assignment
38216- stack[base + 15LLU] = 3233LLU/*throw to this address*/;
38282+ stack[base + 15LLU] = 3239LLU/*throw to this address*/;
3821738283 stack[base + 16LLU] = base;
38218- stack[base + 17LLU] = 3234LLU;
38284+ stack[base + 17LLU] = 3240LLU;
3821938285 // arguments for call to reportid
3822038286 stack[base + 18LLU] = stack[base + 8]/*id*/;
3822138287 // set stack-base & callee-address
@@ -38223,37 +38289,37 @@
3822338289 label = 18446744073709551586LLU; // reportid
3822438290 break;
3822538291 }
38226- case 3233LLU: // copy-back deleter (reportid to assignment)
38292+ case 3239LLU: // copy-back deleter (reportid to assignment)
3822738293 {
3822838294 // copy mutable arguments back from call to reportid
38229- label = 3228LLU; // continue to roll stack
38295+ label = 3234LLU; // continue to roll stack
3823038296 break;
3823138297 }
38232- case 3234LLU: // return from reportid to assignment
38298+ case 3240LLU: // return from reportid to assignment
3823338299 {
3823438300 // copy mutable arguments back from call to reportid
3823538301 fprintf(stderr, "%s", " - use SWAP instead\n");
3823638302 {
38237- label = 3228LLU; // throw: begin to unroll stack
38303+ label = 3234LLU; // throw: begin to unroll stack
3823838304 break;
3823938305 }
3824038306
3824138307 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
38242- label = 3196LLU; // case complete
38308+ label = 3202LLU; // case complete
3824338309 break;
3824438310 }
38245- case 3228LLU: // copy-back deleter (switch)
38311+ case 3234LLU: // copy-back deleter (switch)
3824638312 {
3824738313 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
38248- label = 3192LLU; // continue to unroll stack
38314+ label = 3198LLU; // continue to unroll stack
3824938315 break;
3825038316 }
38251- case 3227LLU: // try next case
38317+ case 3233LLU: // try next case
3825238318 {
3825338319 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3825438320 exit(-1);
3825538321 }
38256- case 3196LLU: // completed switch
38322+ case 3202LLU: // completed switch
3825738323 {
3825838324 ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11];
3825938325 ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10];
@@ -38260,10 +38326,10 @@
3826038326 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9];
3826138327 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8];
3826238328 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7];
38263- label = 3181LLU; // case complete
38329+ label = 3187LLU; // case complete
3826438330 break;
3826538331 }
38266- case 3183LLU: // copy-back deleter (switch)
38332+ case 3189LLU: // copy-back deleter (switch)
3826738333 {
3826838334 ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11];
3826938335 ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10];
@@ -38270,15 +38336,15 @@
3827038336 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9];
3827138337 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8];
3827238338 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7];
38273- label = 3179LLU; // continue to unroll stack
38339+ label = 3185LLU; // continue to unroll stack
3827438340 break;
3827538341 }
38276- case 3182LLU: // try next case
38342+ case 3188LLU: // try next case
3827738343 {
3827838344 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3827938345 exit(-1);
3828038346 }
38281- case 3181LLU: // completed switch
38347+ case 3187LLU: // completed switch
3828238348 {
3828338349 // return from assignment
3828438350 label = stack[base - 1];
@@ -38285,13 +38351,13 @@
3828538351 base = stack[base - 2];
3828638352 break;
3828738353 }
38288- case 3236LLU: // function closescope failed
38354+ case 3242LLU: // function closescope failed
3828938355 {
3829038356 label = stack[base - 3];
3829138357 base = stack[base - 2];
3829238358 break;
3829338359 }
38294- case 3235LLU: // closescope
38360+ case 3241LLU: // closescope
3829538361 {
3829638362 //#define arg0 0
3829738363 //#define arg1 1
@@ -38299,7 +38365,7 @@
3829938365 //#define arg3 3
3830038366 if(/*scope*/0 != ((uint64_t *)(stack[base + 2]/*scope*/))[0])
3830138367 {
38302- label = 3238LLU; // jump to alternative
38368+ label = 3244LLU; // jump to alternative
3830338369 break;
3830438370 }
3830538371
@@ -38308,14 +38374,14 @@
3830838374
3830938375 // case
3831038376 flippedassign(stack[base + 5]/*letdefs*/, &stack[base + 6]);
38311- label = 3240LLU; // start to repeat
38377+ label = 3246LLU; // start to repeat
3831238378 break;
3831338379 }
38314- case 3240LLU: // repeat from here
38380+ case 3246LLU: // repeat from here
3831538381 {
3831638382 if(!stack[base + 6])
3831738383 {
38318- label = 3241LLU; // break loop
38384+ label = 3247LLU; // break loop
3831938385 break;
3832038386 }
3832138387
@@ -38325,7 +38391,7 @@
3832538391 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
3832638392 if(/*letdef*/0 != ((uint64_t *)(stack[base + 7]/*letdef*/))[0])
3832738393 {
38328- label = 3244LLU; // jump to alternative
38394+ label = 3250LLU; // jump to alternative
3832938395 break;
3833038396 }
3833138397
@@ -38339,7 +38405,7 @@
3833938405 uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t));
3834038406 if(!newstack)
3834138407 {
38342- label = 3245LLU; // throw: begin to unroll stack
38408+ label = 3251LLU; // throw: begin to unroll stack
3834338409 break;
3834438410 }
3834538411
@@ -38346,9 +38412,9 @@
3834638412 newstack[75LLU] = 9876543210LLU; // overflow-marker
3834738413 // call calldestr from closescope
3834838414 newstack[0] = (uint64_t)stack; // backup stack location
38349- newstack[1] = 3246LLU;
38415+ newstack[1] = 3252LLU;
3835038416 newstack[2] = base;
38351- newstack[3] = 3247LLU;
38417+ newstack[3] = 3253LLU;
3835238418 // arguments for call to calldestr
3835338419 newstack[4LLU] = stack[base + 0]/*fnid*/;
3835438420 newstack[5LLU] = stack[base + 1]/*datadefs*/;
@@ -38362,7 +38428,7 @@
3836238428 label = 1150LLU; // calldestr
3836338429 break;
3836438430 }
38365- case 3246LLU: // copy-back deleter (calldestr to closescope)
38431+ case 3252LLU: // copy-back deleter (calldestr to closescope)
3836638432 {
3836738433 uint64_t *oldstack = (uint64_t *)stack[0];
3836838434 // copy mutable arguments back from call to calldestr
@@ -38374,10 +38440,10 @@
3837438440 }
3837538441 Free(75LLU + 1, sizeof(uint64_t), stack);
3837638442 stack = oldstack;
38377- label = 3245LLU; // continue to unroll stack
38443+ label = 3251LLU; // continue to unroll stack
3837838444 break;
3837938445 }
38380- case 3247LLU: // return from calldestr to closescope
38446+ case 3253LLU: // return from calldestr to closescope
3838138447 {
3838238448 uint64_t *oldstack = (uint64_t *)stack[0];
3838338449 // copy mutable arguments back from call to calldestr
@@ -38394,10 +38460,10 @@
3839438460 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
3839538461 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
3839638462 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
38397- label = 3243LLU; // case complete
38463+ label = 3249LLU; // case complete
3839838464 break;
3839938465 }
38400- case 3245LLU: // copy-back deleter (switch)
38466+ case 3251LLU: // copy-back deleter (switch)
3840138467 {
3840238468 ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 13];
3840338469 ((uint64_t **)(stack[base + 7]))[1][3] = stack[base + 12];
@@ -38404,46 +38470,46 @@
3840438470 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
3840538471 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
3840638472 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
38407- label = 3242LLU; // continue to unroll stack
38473+ label = 3248LLU; // continue to unroll stack
3840838474 break;
3840938475 }
38410- case 3244LLU: // try next case
38476+ case 3250LLU: // try next case
3841138477 {
3841238478 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3841338479 exit(-1);
3841438480 }
38415- case 3243LLU: // completed switch
38481+ case 3249LLU: // completed switch
3841638482 {
3841738483 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
38418- label = 3240LLU; // repeat
38484+ label = 3246LLU; // repeat
3841938485 break;
3842038486 }
38421- case 3242LLU: // copy-back deleter for while next
38487+ case 3248LLU: // copy-back deleter for while next
3842238488 {
3842338489 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
38424- label = 3239LLU; // continue to unroll stack
38490+ label = 3245LLU; // continue to unroll stack
3842538491 break;
3842638492 }
38427- case 3241LLU: // loop finished
38493+ case 3247LLU: // loop finished
3842838494 {
3842938495 ((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5];
3843038496 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
38431- label = 3237LLU; // case complete
38497+ label = 3243LLU; // case complete
3843238498 break;
3843338499 }
38434- case 3239LLU: // copy-back deleter (switch)
38500+ case 3245LLU: // copy-back deleter (switch)
3843538501 {
3843638502 ((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5];
3843738503 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
38438- label = 3236LLU; // continue to unroll stack
38504+ label = 3242LLU; // continue to unroll stack
3843938505 break;
3844038506 }
38441- case 3238LLU: // try next case
38507+ case 3244LLU: // try next case
3844238508 {
3844338509 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3844438510 exit(-1);
3844538511 }
38446- case 3237LLU: // completed switch
38512+ case 3243LLU: // completed switch
3844738513 {
3844838514 // return from closescope
3844938515 label = stack[base - 1];
@@ -38450,13 +38516,13 @@
3845038516 base = stack[base - 2];
3845138517 break;
3845238518 }
38453- case 3249LLU: // function VERBATIM failed
38519+ case 3255LLU: // function VERBATIM failed
3845438520 {
3845538521 label = stack[base - 3];
3845638522 base = stack[base - 2];
3845738523 break;
3845838524 }
38459- case 3248LLU: // VERBATIM
38525+ case 3254LLU: // VERBATIM
3846038526 {
3846138527 //#define arg0 0
3846238528 #define lookahead stack[base + 0]
@@ -38477,38 +38543,38 @@
3847738543
3847838544 #undef lookahead
3847938545 printf("%s", "\n");
38480- label = 3250LLU; // start to repeat
38546+ label = 3256LLU; // start to repeat
3848138547 break;
3848238548 }
38483- case 3250LLU: // repeat from here
38549+ case 3256LLU: // repeat from here
3848438550 {
3848538551 if(stack[base + 0]/*lookahead*/ > 0xFF)
3848638552 {
38487- label = 3251LLU; // break loop
38553+ label = 3257LLU; // break loop
3848838554 break;
3848938555 }
3849038556
3849138557 // loop body
38492- label = 3253LLU; // skip deleter
38558+ label = 3259LLU; // skip deleter
3849338559 break;
3849438560 }
38495- case 3252LLU: // deleter
38561+ case 3258LLU: // deleter
3849638562 {
3849738563 // throw from VERBATIM
3849838564 if(!stack[base + 1])
3849938565 {
38500- label = 3249LLU; // skip, variable already deleted/unscoped
38566+ label = 3255LLU; // skip, variable already deleted/unscoped
3850138567 break;
3850238568 }
38503- label = 3249LLU; // continue unrolling stack, delete next variable
38569+ label = 3255LLU; // continue unrolling stack, delete next variable
3850438570 break;
3850538571 }
38506- case 3253LLU: // skipped deleter
38572+ case 3259LLU: // skipped deleter
3850738573 {
3850838574 // call equ from VERBATIM
38509- stack[base + 2LLU] = 3254LLU/*throw to this address*/;
38575+ stack[base + 2LLU] = 3260LLU/*throw to this address*/;
3851038576 stack[base + 3LLU] = base;
38511- stack[base + 4LLU] = 3255LLU;
38577+ stack[base + 4LLU] = 3261LLU;
3851238578 // arguments for call to equ
3851338579 stack[base + 6LLU] = stack[base + 0]/*lookahead*/;
3851438580 stack[base + 7LLU] = 96LLU;
@@ -38517,13 +38583,13 @@
3851738583 label = 18446744073709551600LLU; // equ
3851838584 break;
3851938585 }
38520- case 3254LLU: // copy-back deleter (equ to VERBATIM)
38586+ case 3260LLU: // copy-back deleter (equ to VERBATIM)
3852138587 {
3852238588 // copy mutable arguments back from call to equ
38523- label = 3249LLU; // continue to roll stack
38589+ label = 3255LLU; // continue to roll stack
3852438590 break;
3852538591 }
38526- case 3255LLU: // return from equ to VERBATIM
38592+ case 3261LLU: // return from equ to VERBATIM
3852738593 {
3852838594 // copy mutable arguments back from call to equ
3852938595 // copy back results provided by call to equ
@@ -38530,15 +38596,15 @@
3853038596 stack[base + 1] = stack[base + 5LLU];
3853138597 if(!stack[base + 1]/*isequal*/)
3853238598 {
38533- label = 3256LLU; // jump to alternative
38599+ label = 3262LLU; // jump to alternative
3853438600 break;
3853538601 }
3853638602
3853738603 // consequent
3853838604 // call EOSbyte from VERBATIM
38539- stack[base + 2LLU] = 3258LLU/*throw to this address*/;
38605+ stack[base + 2LLU] = 3264LLU/*throw to this address*/;
3854038606 stack[base + 3LLU] = base;
38541- stack[base + 4LLU] = 3259LLU;
38607+ stack[base + 4LLU] = 3265LLU;
3854238608 // arguments for call to EOSbyte
3854338609 // set stack-base & callee-address
3854438610 base += 5LLU;
@@ -38545,26 +38611,26 @@
3854538611 label = 77LLU; // EOSbyte
3854638612 break;
3854738613 }
38548- case 3258LLU: // copy-back deleter (EOSbyte to VERBATIM)
38614+ case 3264LLU: // copy-back deleter (EOSbyte to VERBATIM)
3854938615 {
3855038616 // copy mutable arguments back from call to EOSbyte
38551- label = 3252LLU; // continue to roll stack
38617+ label = 3258LLU; // continue to roll stack
3855238618 break;
3855338619 }
38554- case 3259LLU: // return from EOSbyte to VERBATIM
38620+ case 3265LLU: // return from EOSbyte to VERBATIM
3855538621 {
3855638622 // copy mutable arguments back from call to EOSbyte
3855738623 // copy back results provided by call to EOSbyte
3855838624 stack[base + 0] = stack[base + 5LLU];
38559- label = 3257LLU; // consequent complete
38625+ label = 3263LLU; // consequent complete
3856038626 break;
3856138627 }
38562- case 3256LLU: // alternative
38628+ case 3262LLU: // alternative
3856338629 {
3856438630 // call printbyte from VERBATIM
38565- stack[base + 2LLU] = 3260LLU/*throw to this address*/;
38631+ stack[base + 2LLU] = 3266LLU/*throw to this address*/;
3856638632 stack[base + 3LLU] = base;
38567- stack[base + 4LLU] = 3261LLU;
38633+ stack[base + 4LLU] = 3267LLU;
3856838634 // arguments for call to printbyte
3856938635 stack[base + 5LLU] = stack[base + 0]/*lookahead*/;
3857038636 // set stack-base & callee-address
@@ -38572,25 +38638,25 @@
3857238638 label = 18446744073709551592LLU; // printbyte
3857338639 break;
3857438640 }
38575- case 3260LLU: // copy-back deleter (printbyte to VERBATIM)
38641+ case 3266LLU: // copy-back deleter (printbyte to VERBATIM)
3857638642 {
3857738643 // copy mutable arguments back from call to printbyte
38578- label = 3252LLU; // continue to roll stack
38644+ label = 3258LLU; // continue to roll stack
3857938645 break;
3858038646 }
38581- case 3261LLU: // return from printbyte to VERBATIM
38647+ case 3267LLU: // return from printbyte to VERBATIM
3858238648 {
3858338649 // copy mutable arguments back from call to printbyte
38584- label = 3257LLU; // alternative complete
38650+ label = 3263LLU; // alternative complete
3858538651 break;
3858638652 }
38587- case 3257LLU: // completed if-then-else
38653+ case 3263LLU: // completed if-then-else
3858838654 {
3858938655 if(stack[base + 0]/*lookahead*/ <= 0xFF) stack[base + 0]/*lookahead*/ = getchar();
38590- label = 3250LLU; // repeat
38656+ label = 3256LLU; // repeat
3859138657 break;
3859238658 }
38593- case 3251LLU: // loop finished
38659+ case 3257LLU: // loop finished
3859438660 {
3859538661 stack[base + 0]/*lookahead*/ = 32;
3859638662 // return from VERBATIM
@@ -38598,18 +38664,18 @@
3859838664 base = stack[base - 2];
3859938665 break;
3860038666 }
38601- case 3263LLU: // function emitdefine failed
38667+ case 3269LLU: // function emitdefine failed
3860238668 {
3860338669 label = stack[base - 3];
3860438670 base = stack[base - 2];
3860538671 break;
3860638672 }
38607- case 3262LLU: // emitdefine
38673+ case 3268LLU: // emitdefine
3860838674 {
3860938675 //#define arg0 0
3861038676 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
3861138677 {
38612- label = 3265LLU; // jump to alternative
38678+ label = 3271LLU; // jump to alternative
3861338679 break;
3861438680 }
3861538681
@@ -38618,14 +38684,14 @@
3861838684
3861938685 // case
3862038686 flippedassign(stack[base + 2]/*letdefs*/, &stack[base + 3]);
38621- label = 3267LLU; // start to repeat
38687+ label = 3273LLU; // start to repeat
3862238688 break;
3862338689 }
38624- case 3267LLU: // repeat from here
38690+ case 3273LLU: // repeat from here
3862538691 {
3862638692 if(!stack[base + 3])
3862738693 {
38628- label = 3268LLU; // break loop
38694+ label = 3274LLU; // break loop
3862938695 break;
3863038696 }
3863138697
@@ -38635,7 +38701,7 @@
3863538701 stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
3863638702 if(/*letdef*/0 != ((uint64_t *)(stack[base + 4]/*letdef*/))[0])
3863738703 {
38638- label = 3271LLU; // jump to alternative
38704+ label = 3277LLU; // jump to alternative
3863938705 break;
3864038706 }
3864138707
@@ -38648,9 +38714,9 @@
3864838714 // case
3864938715 printf("%s", "\n#define ");
3865038716 // call printid from emitdefine
38651- stack[base + 11LLU] = 3273LLU/*throw to this address*/;
38717+ stack[base + 11LLU] = 3279LLU/*throw to this address*/;
3865238718 stack[base + 12LLU] = base;
38653- stack[base + 13LLU] = 3274LLU;
38719+ stack[base + 13LLU] = 3280LLU;
3865438720 // arguments for call to printid
3865538721 stack[base + 14LLU] = stack[base + 7]/*id*/;
3865638722 // set stack-base & callee-address
@@ -38658,20 +38724,20 @@
3865838724 label = 18446744073709551587LLU; // printid
3865938725 break;
3866038726 }
38661- case 3273LLU: // copy-back deleter (printid to emitdefine)
38727+ case 3279LLU: // copy-back deleter (printid to emitdefine)
3866238728 {
3866338729 // copy mutable arguments back from call to printid
38664- label = 3272LLU; // continue to roll stack
38730+ label = 3278LLU; // continue to roll stack
3866538731 break;
3866638732 }
38667- case 3274LLU: // return from printid to emitdefine
38733+ case 3280LLU: // return from printid to emitdefine
3866838734 {
3866938735 // copy mutable arguments back from call to printid
3867038736 printf("%s", " ");
3867138737 // call emitvaridx from emitdefine
38672- stack[base + 11LLU] = 3275LLU/*throw to this address*/;
38738+ stack[base + 11LLU] = 3281LLU/*throw to this address*/;
3867338739 stack[base + 12LLU] = base;
38674- stack[base + 13LLU] = 3276LLU;
38740+ stack[base + 13LLU] = 3282LLU;
3867538741 // arguments for call to emitvaridx
3867638742 stack[base + 14LLU] = stack[base + 8]/*index*/;
3867738743 // set stack-base & callee-address
@@ -38679,13 +38745,13 @@
3867938745 label = 745LLU; // emitvaridx
3868038746 break;
3868138747 }
38682- case 3275LLU: // copy-back deleter (emitvaridx to emitdefine)
38748+ case 3281LLU: // copy-back deleter (emitvaridx to emitdefine)
3868338749 {
3868438750 // copy mutable arguments back from call to emitvaridx
38685- label = 3272LLU; // continue to roll stack
38751+ label = 3278LLU; // continue to roll stack
3868638752 break;
3868738753 }
38688- case 3276LLU: // return from emitvaridx to emitdefine
38754+ case 3282LLU: // return from emitvaridx to emitdefine
3868938755 {
3869038756 // copy mutable arguments back from call to emitvaridx
3869138757 ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
@@ -38693,10 +38759,10 @@
3869338759 ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
3869438760 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
3869538761 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38696- label = 3270LLU; // case complete
38762+ label = 3276LLU; // case complete
3869738763 break;
3869838764 }
38699- case 3272LLU: // copy-back deleter (switch)
38765+ case 3278LLU: // copy-back deleter (switch)
3870038766 {
3870138767 ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
3870238768 ((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9];
@@ -38703,46 +38769,46 @@
3870338769 ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
3870438770 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
3870538771 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38706- label = 3269LLU; // continue to unroll stack
38772+ label = 3275LLU; // continue to unroll stack
3870738773 break;
3870838774 }
38709- case 3271LLU: // try next case
38775+ case 3277LLU: // try next case
3871038776 {
3871138777 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3871238778 exit(-1);
3871338779 }
38714- case 3270LLU: // completed switch
38780+ case 3276LLU: // completed switch
3871538781 {
3871638782 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38717- label = 3267LLU; // repeat
38783+ label = 3273LLU; // repeat
3871838784 break;
3871938785 }
38720- case 3269LLU: // copy-back deleter for while next
38786+ case 3275LLU: // copy-back deleter for while next
3872138787 {
3872238788 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38723- label = 3266LLU; // continue to unroll stack
38789+ label = 3272LLU; // continue to unroll stack
3872438790 break;
3872538791 }
38726- case 3268LLU: // loop finished
38792+ case 3274LLU: // loop finished
3872738793 {
3872838794 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
3872938795 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38730- label = 3264LLU; // case complete
38796+ label = 3270LLU; // case complete
3873138797 break;
3873238798 }
38733- case 3266LLU: // copy-back deleter (switch)
38799+ case 3272LLU: // copy-back deleter (switch)
3873438800 {
3873538801 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
3873638802 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38737- label = 3263LLU; // continue to unroll stack
38803+ label = 3269LLU; // continue to unroll stack
3873838804 break;
3873938805 }
38740- case 3265LLU: // try next case
38806+ case 3271LLU: // try next case
3874138807 {
3874238808 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3874338809 exit(-1);
3874438810 }
38745- case 3264LLU: // completed switch
38811+ case 3270LLU: // completed switch
3874638812 {
3874738813 // return from emitdefine
3874838814 label = stack[base - 1];
@@ -38749,18 +38815,18 @@
3874938815 base = stack[base - 2];
3875038816 break;
3875138817 }
38752- case 3278LLU: // function emitundef failed
38818+ case 3284LLU: // function emitundef failed
3875338819 {
3875438820 label = stack[base - 3];
3875538821 base = stack[base - 2];
3875638822 break;
3875738823 }
38758- case 3277LLU: // emitundef
38824+ case 3283LLU: // emitundef
3875938825 {
3876038826 //#define arg0 0
3876138827 if(/*scope*/0 != ((uint64_t *)(stack[base + 0]/*scope*/))[0])
3876238828 {
38763- label = 3280LLU; // jump to alternative
38829+ label = 3286LLU; // jump to alternative
3876438830 break;
3876538831 }
3876638832
@@ -38769,14 +38835,14 @@
3876938835
3877038836 // case
3877138837 flippedassign(stack[base + 2]/*letdefs*/, &stack[base + 3]);
38772- label = 3282LLU; // start to repeat
38838+ label = 3288LLU; // start to repeat
3877338839 break;
3877438840 }
38775- case 3282LLU: // repeat from here
38841+ case 3288LLU: // repeat from here
3877638842 {
3877738843 if(!stack[base + 3])
3877838844 {
38779- label = 3283LLU; // break loop
38845+ label = 3289LLU; // break loop
3878038846 break;
3878138847 }
3878238848
@@ -38786,7 +38852,7 @@
3878638852 stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
3878738853 if(/*letdef*/0 != ((uint64_t *)(stack[base + 4]/*letdef*/))[0])
3878838854 {
38789- label = 3286LLU; // jump to alternative
38855+ label = 3292LLU; // jump to alternative
3879038856 break;
3879138857 }
3879238858
@@ -38799,9 +38865,9 @@
3879938865 // case
3880038866 printf("%s", "\n#undef ");
3880138867 // call printid from emitundef
38802- stack[base + 11LLU] = 3288LLU/*throw to this address*/;
38868+ stack[base + 11LLU] = 3294LLU/*throw to this address*/;
3880338869 stack[base + 12LLU] = base;
38804- stack[base + 13LLU] = 3289LLU;
38870+ stack[base + 13LLU] = 3295LLU;
3880538871 // arguments for call to printid
3880638872 stack[base + 14LLU] = stack[base + 7]/*id*/;
3880738873 // set stack-base & callee-address
@@ -38809,13 +38875,13 @@
3880938875 label = 18446744073709551587LLU; // printid
3881038876 break;
3881138877 }
38812- case 3288LLU: // copy-back deleter (printid to emitundef)
38878+ case 3294LLU: // copy-back deleter (printid to emitundef)
3881338879 {
3881438880 // copy mutable arguments back from call to printid
38815- label = 3287LLU; // continue to roll stack
38881+ label = 3293LLU; // continue to roll stack
3881638882 break;
3881738883 }
38818- case 3289LLU: // return from printid to emitundef
38884+ case 3295LLU: // return from printid to emitundef
3881938885 {
3882038886 // copy mutable arguments back from call to printid
3882138887 ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
@@ -38823,10 +38889,10 @@
3882338889 ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
3882438890 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
3882538891 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38826- label = 3285LLU; // case complete
38892+ label = 3291LLU; // case complete
3882738893 break;
3882838894 }
38829- case 3287LLU: // copy-back deleter (switch)
38895+ case 3293LLU: // copy-back deleter (switch)
3883038896 {
3883138897 ((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
3883238898 ((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9];
@@ -38833,46 +38899,46 @@
3883338899 ((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
3883438900 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
3883538901 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38836- label = 3284LLU; // continue to unroll stack
38902+ label = 3290LLU; // continue to unroll stack
3883738903 break;
3883838904 }
38839- case 3286LLU: // try next case
38905+ case 3292LLU: // try next case
3884038906 {
3884138907 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3884238908 exit(-1);
3884338909 }
38844- case 3285LLU: // completed switch
38910+ case 3291LLU: // completed switch
3884538911 {
3884638912 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38847- label = 3282LLU; // repeat
38913+ label = 3288LLU; // repeat
3884838914 break;
3884938915 }
38850- case 3284LLU: // copy-back deleter for while next
38916+ case 3290LLU: // copy-back deleter for while next
3885138917 {
3885238918 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38853- label = 3281LLU; // continue to unroll stack
38919+ label = 3287LLU; // continue to unroll stack
3885438920 break;
3885538921 }
38856- case 3283LLU: // loop finished
38922+ case 3289LLU: // loop finished
3885738923 {
3885838924 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
3885938925 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38860- label = 3279LLU; // case complete
38926+ label = 3285LLU; // case complete
3886138927 break;
3886238928 }
38863- case 3281LLU: // copy-back deleter (switch)
38929+ case 3287LLU: // copy-back deleter (switch)
3886438930 {
3886538931 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
3886638932 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38867- label = 3278LLU; // continue to unroll stack
38933+ label = 3284LLU; // continue to unroll stack
3886838934 break;
3886938935 }
38870- case 3280LLU: // try next case
38936+ case 3286LLU: // try next case
3887138937 {
3887238938 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3887338939 exit(-1);
3887438940 }
38875- case 3279LLU: // completed switch
38941+ case 3285LLU: // completed switch
3887638942 {
3887738943 // return from emitundef
3887838944 label = stack[base - 1];
@@ -38879,26 +38945,26 @@
3887938945 base = stack[base - 2];
3888038946 break;
3888138947 }
38882- case 3291LLU: // function verbatim failed
38948+ case 3297LLU: // function verbatim failed
3888338949 {
3888438950 label = stack[base - 3];
3888538951 base = stack[base - 2];
3888638952 break;
3888738953 }
38888- case 3290LLU: // verbatim
38954+ case 3296LLU: // verbatim
3888938955 {
3889038956 //#define arg0 0
3889138957 //#define arg1 1
3889238958 //#define arg2 2
3889338959 flippedassign(stack[base + 0]/*scopes*/, &stack[base + 3]);
38894- label = 3292LLU; // start to repeat
38960+ label = 3298LLU; // start to repeat
3889538961 break;
3889638962 }
38897- case 3292LLU: // repeat from here
38963+ case 3298LLU: // repeat from here
3889838964 {
3889938965 if(!stack[base + 3])
3890038966 {
38901- label = 3293LLU; // break loop
38967+ label = 3299LLU; // break loop
3890238968 break;
3890338969 }
3890438970
@@ -38907,88 +38973,88 @@
3890738973 stack[base + 5]/*previous*/ = stack[base + 3];
3890838974 stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
3890938975 // call emitdefine from verbatim
38910- stack[base + 6LLU] = 3295LLU/*throw to this address*/;
38976+ stack[base + 6LLU] = 3301LLU/*throw to this address*/;
3891138977 stack[base + 7LLU] = base;
38912- stack[base + 8LLU] = 3296LLU;
38978+ stack[base + 8LLU] = 3302LLU;
3891338979 // arguments for call to emitdefine
3891438980 stack[base + 9LLU] = stack[base + 4]/*scope*/;
3891538981 // set stack-base & callee-address
3891638982 base += 9LLU;
38917- label = 3262LLU; // emitdefine
38983+ label = 3268LLU; // emitdefine
3891838984 break;
3891938985 }
38920- case 3295LLU: // copy-back deleter (emitdefine to verbatim)
38986+ case 3301LLU: // copy-back deleter (emitdefine to verbatim)
3892138987 {
3892238988 // copy mutable arguments back from call to emitdefine
38923- label = 3294LLU; // continue to roll stack
38989+ label = 3300LLU; // continue to roll stack
3892438990 break;
3892538991 }
38926- case 3296LLU: // return from emitdefine to verbatim
38992+ case 3302LLU: // return from emitdefine to verbatim
3892738993 {
3892838994 // copy mutable arguments back from call to emitdefine
3892938995 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38930- label = 3292LLU; // repeat
38996+ label = 3298LLU; // repeat
3893138997 break;
3893238998 }
38933- case 3294LLU: // copy-back deleter for while next
38999+ case 3300LLU: // copy-back deleter for while next
3893439000 {
3893539001 ((struct listnode *)(stack[base + 5]/*previous*/))->data = stack[base + 4];
38936- label = 3291LLU; // continue to unroll stack
39002+ label = 3297LLU; // continue to unroll stack
3893739003 break;
3893839004 }
38939- case 3293LLU: // loop finished
39005+ case 3299LLU: // loop finished
3894039006 {
3894139007 // call emitdefine from verbatim
38942- stack[base + 6LLU] = 3297LLU/*throw to this address*/;
39008+ stack[base + 6LLU] = 3303LLU/*throw to this address*/;
3894339009 stack[base + 7LLU] = base;
38944- stack[base + 8LLU] = 3298LLU;
39010+ stack[base + 8LLU] = 3304LLU;
3894539011 // arguments for call to emitdefine
3894639012 stack[base + 9LLU] = stack[base + 1]/*scope*/;
3894739013 // set stack-base & callee-address
3894839014 base += 9LLU;
38949- label = 3262LLU; // emitdefine
39015+ label = 3268LLU; // emitdefine
3895039016 break;
3895139017 }
38952- case 3297LLU: // copy-back deleter (emitdefine to verbatim)
39018+ case 3303LLU: // copy-back deleter (emitdefine to verbatim)
3895339019 {
3895439020 // copy mutable arguments back from call to emitdefine
38955- label = 3291LLU; // continue to roll stack
39021+ label = 3297LLU; // continue to roll stack
3895639022 break;
3895739023 }
38958- case 3298LLU: // return from emitdefine to verbatim
39024+ case 3304LLU: // return from emitdefine to verbatim
3895939025 {
3896039026 // copy mutable arguments back from call to emitdefine
3896139027 // call VERBATIM from verbatim
38962- stack[base + 6LLU] = 3299LLU/*throw to this address*/;
39028+ stack[base + 6LLU] = 3305LLU/*throw to this address*/;
3896339029 stack[base + 7LLU] = base;
38964- stack[base + 8LLU] = 3300LLU;
39030+ stack[base + 8LLU] = 3306LLU;
3896539031 // arguments for call to VERBATIM
3896639032 stack[base + 9LLU] = stack[base + 2]/*lookahead*/;
3896739033 // set stack-base & callee-address
3896839034 base += 9LLU;
38969- label = 3248LLU; // VERBATIM
39035+ label = 3254LLU; // VERBATIM
3897039036 break;
3897139037 }
38972- case 3299LLU: // copy-back deleter (VERBATIM to verbatim)
39038+ case 3305LLU: // copy-back deleter (VERBATIM to verbatim)
3897339039 {
3897439040 // copy mutable arguments back from call to VERBATIM
3897539041 stack[base + 2]/*lookahead*/ = stack[base + 9LLU];
38976- label = 3291LLU; // continue to roll stack
39042+ label = 3297LLU; // continue to roll stack
3897739043 break;
3897839044 }
38979- case 3300LLU: // return from VERBATIM to verbatim
39045+ case 3306LLU: // return from VERBATIM to verbatim
3898039046 {
3898139047 // copy mutable arguments back from call to VERBATIM
3898239048 stack[base + 2]/*lookahead*/ = stack[base + 9LLU];
3898339049 flippedassign(stack[base + 0]/*scopes*/, &stack[base + 6]);
38984- label = 3301LLU; // start to repeat
39050+ label = 3307LLU; // start to repeat
3898539051 break;
3898639052 }
38987- case 3301LLU: // repeat from here
39053+ case 3307LLU: // repeat from here
3898839054 {
3898939055 if(!stack[base + 6])
3899039056 {
38991- label = 3302LLU; // break loop
39057+ label = 3308LLU; // break loop
3899239058 break;
3899339059 }
3899439060
@@ -38997,55 +39063,55 @@
3899739063 stack[base + 8]/*previous*/ = stack[base + 6];
3899839064 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
3899939065 // call emitundef from verbatim
39000- stack[base + 9LLU] = 3304LLU/*throw to this address*/;
39066+ stack[base + 9LLU] = 3310LLU/*throw to this address*/;
3900139067 stack[base + 10LLU] = base;
39002- stack[base + 11LLU] = 3305LLU;
39068+ stack[base + 11LLU] = 3311LLU;
3900339069 // arguments for call to emitundef
3900439070 stack[base + 12LLU] = stack[base + 7]/*scope*/;
3900539071 // set stack-base & callee-address
3900639072 base += 12LLU;
39007- label = 3277LLU; // emitundef
39073+ label = 3283LLU; // emitundef
3900839074 break;
3900939075 }
39010- case 3304LLU: // copy-back deleter (emitundef to verbatim)
39076+ case 3310LLU: // copy-back deleter (emitundef to verbatim)
3901139077 {
3901239078 // copy mutable arguments back from call to emitundef
39013- label = 3303LLU; // continue to roll stack
39079+ label = 3309LLU; // continue to roll stack
3901439080 break;
3901539081 }
39016- case 3305LLU: // return from emitundef to verbatim
39082+ case 3311LLU: // return from emitundef to verbatim
3901739083 {
3901839084 // copy mutable arguments back from call to emitundef
3901939085 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
39020- label = 3301LLU; // repeat
39086+ label = 3307LLU; // repeat
3902139087 break;
3902239088 }
39023- case 3303LLU: // copy-back deleter for while next
39089+ case 3309LLU: // copy-back deleter for while next
3902439090 {
3902539091 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
39026- label = 3291LLU; // continue to unroll stack
39092+ label = 3297LLU; // continue to unroll stack
3902739093 break;
3902839094 }
39029- case 3302LLU: // loop finished
39095+ case 3308LLU: // loop finished
3903039096 {
3903139097 // call emitundef from verbatim
39032- stack[base + 9LLU] = 3306LLU/*throw to this address*/;
39098+ stack[base + 9LLU] = 3312LLU/*throw to this address*/;
3903339099 stack[base + 10LLU] = base;
39034- stack[base + 11LLU] = 3307LLU;
39100+ stack[base + 11LLU] = 3313LLU;
3903539101 // arguments for call to emitundef
3903639102 stack[base + 12LLU] = stack[base + 1]/*scope*/;
3903739103 // set stack-base & callee-address
3903839104 base += 12LLU;
39039- label = 3277LLU; // emitundef
39105+ label = 3283LLU; // emitundef
3904039106 break;
3904139107 }
39042- case 3306LLU: // copy-back deleter (emitundef to verbatim)
39108+ case 3312LLU: // copy-back deleter (emitundef to verbatim)
3904339109 {
3904439110 // copy mutable arguments back from call to emitundef
39045- label = 3291LLU; // continue to roll stack
39111+ label = 3297LLU; // continue to roll stack
3904639112 break;
3904739113 }
39048- case 3307LLU: // return from emitundef to verbatim
39114+ case 3313LLU: // return from emitundef to verbatim
3904939115 {
3905039116 // copy mutable arguments back from call to emitundef
3905139117 // return from verbatim
@@ -39053,39 +39119,39 @@
3905339119 base = stack[base - 2];
3905439120 break;
3905539121 }
39056- case 3309LLU: // function listtoelem failed
39122+ case 3315LLU: // function listtoelem failed
3905739123 {
3905839124 label = stack[base - 3];
3905939125 base = stack[base - 2];
3906039126 break;
3906139127 }
39062- case 3308LLU: // listtoelem
39128+ case 3314LLU: // listtoelem
3906339129 {
3906439130 //#define res0 0
3906539131 //#define res1 1
3906639132 //#define arg0 2
3906739133 //#define arg1 3
39068- label = 3311LLU; // skip deleter
39134+ label = 3317LLU; // skip deleter
3906939135 break;
3907039136 }
39071- case 3310LLU: // deleter
39137+ case 3316LLU: // deleter
3907239138 {
3907339139 // throw from listtoelem
3907439140 if(!stack[base + 4])
3907539141 {
39076- label = 3309LLU; // skip, variable already deleted/unscoped
39142+ label = 3315LLU; // skip, variable already deleted/unscoped
3907739143 break;
3907839144 }
39079- label = 3309LLU; // continue unrolling stack, delete next variable
39145+ label = 3315LLU; // continue unrolling stack, delete next variable
3908039146 break;
3908139147 }
39082- case 3311LLU: // skipped deleter
39148+ case 3317LLU: // skipped deleter
3908339149 {
3908439150 stack[base + 4] = 0;
3908539151 // call matchsym from listtoelem
39086- stack[base + 5LLU] = 3312LLU/*throw to this address*/;
39152+ stack[base + 5LLU] = 3318LLU/*throw to this address*/;
3908739153 stack[base + 6LLU] = base;
39088- stack[base + 7LLU] = 3313LLU;
39154+ stack[base + 7LLU] = 3319LLU;
3908939155 // arguments for call to matchsym
3909039156 stack[base + 8LLU] = stack[base + 2]/*fnid*/;
3909139157 stack[base + 9LLU] = 40LLU;
@@ -39095,53 +39161,53 @@
3909539161 label = 246LLU; // matchsym
3909639162 break;
3909739163 }
39098- case 3312LLU: // copy-back deleter (matchsym to listtoelem)
39164+ case 3318LLU: // copy-back deleter (matchsym to listtoelem)
3909939165 {
3910039166 // copy mutable arguments back from call to matchsym
3910139167 stack[base + 3]/*lookahead*/ = stack[base + 10LLU];
39102- label = 3310LLU; // continue to roll stack
39168+ label = 3316LLU; // continue to roll stack
3910339169 break;
3910439170 }
39105- case 3313LLU: // return from matchsym to listtoelem
39171+ case 3319LLU: // return from matchsym to listtoelem
3910639172 {
3910739173 // copy mutable arguments back from call to matchsym
3910839174 stack[base + 3]/*lookahead*/ = stack[base + 10LLU];
39109- label = 3315LLU; // skip deleter
39175+ label = 3321LLU; // skip deleter
3911039176 break;
3911139177 }
39112- case 3314LLU: // deleter
39178+ case 3320LLU: // deleter
3911339179 {
3911439180 // throw from listtoelem
3911539181 if(!stack[base + 5])
3911639182 {
39117- label = 3310LLU; // skip, variable already deleted/unscoped
39183+ label = 3316LLU; // skip, variable already deleted/unscoped
3911839184 break;
3911939185 }
39120- label = 3310LLU; // continue unrolling stack, delete next variable
39186+ label = 3316LLU; // continue unrolling stack, delete next variable
3912139187 break;
3912239188 }
39123- case 3315LLU: // skipped deleter
39189+ case 3321LLU: // skipped deleter
3912439190 {
39125- label = 3317LLU; // skip deleter
39191+ label = 3323LLU; // skip deleter
3912639192 break;
3912739193 }
39128- case 3316LLU: // deleter
39194+ case 3322LLU: // deleter
3912939195 {
3913039196 // throw from listtoelem
3913139197 if(!stack[base + 6])
3913239198 {
39133- label = 3314LLU; // skip, variable already deleted/unscoped
39199+ label = 3320LLU; // skip, variable already deleted/unscoped
3913439200 break;
3913539201 }
39136- label = 3314LLU; // continue unrolling stack, delete next variable
39202+ label = 3320LLU; // continue unrolling stack, delete next variable
3913739203 break;
3913839204 }
39139- case 3317LLU: // skipped deleter
39205+ case 3323LLU: // skipped deleter
3914039206 {
3914139207 // call ParseToken from listtoelem
39142- stack[base + 7LLU] = 3318LLU/*throw to this address*/;
39208+ stack[base + 7LLU] = 3324LLU/*throw to this address*/;
3914339209 stack[base + 8LLU] = base;
39144- stack[base + 9LLU] = 3319LLU;
39210+ stack[base + 9LLU] = 3325LLU;
3914539211 // arguments for call to ParseToken
3914639212 stack[base + 12LLU] = stack[base + 3]/*lookahead*/;
3914739213 // set stack-base & callee-address
@@ -39149,14 +39215,14 @@
3914939215 label = 3LLU; // ParseToken
3915039216 break;
3915139217 }
39152- case 3318LLU: // copy-back deleter (ParseToken to listtoelem)
39218+ case 3324LLU: // copy-back deleter (ParseToken to listtoelem)
3915339219 {
3915439220 // copy mutable arguments back from call to ParseToken
3915539221 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39156- label = 3310LLU; // continue to roll stack
39222+ label = 3316LLU; // continue to roll stack
3915739223 break;
3915839224 }
39159- case 3319LLU: // return from ParseToken to listtoelem
39225+ case 3325LLU: // return from ParseToken to listtoelem
3916039226 {
3916139227 // copy mutable arguments back from call to ParseToken
3916239228 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
@@ -39164,9 +39230,9 @@
3916439230 stack[base + 5] = stack[base + 10LLU];
3916539231 stack[base + 6] = stack[base + 11LLU];
3916639232 // call equ from listtoelem
39167- stack[base + 7LLU] = 3320LLU/*throw to this address*/;
39233+ stack[base + 7LLU] = 3326LLU/*throw to this address*/;
3916839234 stack[base + 8LLU] = base;
39169- stack[base + 9LLU] = 3321LLU;
39235+ stack[base + 9LLU] = 3327LLU;
3917039236 // arguments for call to equ
3917139237 stack[base + 11LLU] = stack[base + 5]/*variant*/;
3917239238 stack[base + 12LLU] = 4LLU;
@@ -39175,13 +39241,13 @@
3917539241 label = 18446744073709551600LLU; // equ
3917639242 break;
3917739243 }
39178- case 3320LLU: // copy-back deleter (equ to listtoelem)
39244+ case 3326LLU: // copy-back deleter (equ to listtoelem)
3917939245 {
3918039246 // copy mutable arguments back from call to equ
39181- label = 3316LLU; // continue to roll stack
39247+ label = 3322LLU; // continue to roll stack
3918239248 break;
3918339249 }
39184- case 3321LLU: // return from equ to listtoelem
39250+ case 3327LLU: // return from equ to listtoelem
3918539251 {
3918639252 // copy mutable arguments back from call to equ
3918739253 // copy back results provided by call to equ
@@ -39188,21 +39254,21 @@
3918839254 stack[base + 4] = stack[base + 10LLU];
3918939255 if(!stack[base + 4]/*isequal*/)
3919039256 {
39191- label = 3322LLU; // jump to alternative
39257+ label = 3328LLU; // jump to alternative
3919239258 break;
3919339259 }
3919439260
3919539261 // consequent
39196- label = 3323LLU; // consequent complete
39262+ label = 3329LLU; // consequent complete
3919739263 break;
3919839264 }
39199- case 3322LLU: // alternative
39265+ case 3328LLU: // alternative
3920039266 {
3920139267 fprintf(stderr, "%s", "expected identifier in while next but found ");
3920239268 // call reporttok from listtoelem
39203- stack[base + 7LLU] = 3324LLU/*throw to this address*/;
39269+ stack[base + 7LLU] = 3330LLU/*throw to this address*/;
3920439270 stack[base + 8LLU] = base;
39205- stack[base + 9LLU] = 3325LLU;
39271+ stack[base + 9LLU] = 3331LLU;
3920639272 // arguments for call to reporttok
3920739273 stack[base + 10LLU] = stack[base + 5]/*variant*/;
3920839274 stack[base + 11LLU] = stack[base + 6]/*listid*/;
@@ -39211,30 +39277,30 @@
3921139277 label = 18446744073709551582LLU; // reporttok
3921239278 break;
3921339279 }
39214- case 3324LLU: // copy-back deleter (reporttok to listtoelem)
39280+ case 3330LLU: // copy-back deleter (reporttok to listtoelem)
3921539281 {
3921639282 // copy mutable arguments back from call to reporttok
39217- label = 3316LLU; // continue to roll stack
39283+ label = 3322LLU; // continue to roll stack
3921839284 break;
3921939285 }
39220- case 3325LLU: // return from reporttok to listtoelem
39286+ case 3331LLU: // return from reporttok to listtoelem
3922139287 {
3922239288 // copy mutable arguments back from call to reporttok
3922339289 fprintf(stderr, "%s", "\n");
3922439290 {
39225- label = 3316LLU; // throw: begin to unroll stack
39291+ label = 3322LLU; // throw: begin to unroll stack
3922639292 break;
3922739293 }
3922839294
39229- label = 3323LLU; // alternative complete
39295+ label = 3329LLU; // alternative complete
3923039296 break;
3923139297 }
39232- case 3323LLU: // completed if-then-else
39298+ case 3329LLU: // completed if-then-else
3923339299 {
3923439300 // call matchsym from listtoelem
39235- stack[base + 7LLU] = 3326LLU/*throw to this address*/;
39301+ stack[base + 7LLU] = 3332LLU/*throw to this address*/;
3923639302 stack[base + 8LLU] = base;
39237- stack[base + 9LLU] = 3327LLU;
39303+ stack[base + 9LLU] = 3333LLU;
3923839304 // arguments for call to matchsym
3923939305 stack[base + 10LLU] = stack[base + 2]/*fnid*/;
3924039306 stack[base + 11LLU] = 41LLU;
@@ -39244,21 +39310,21 @@
3924439310 label = 246LLU; // matchsym
3924539311 break;
3924639312 }
39247- case 3326LLU: // copy-back deleter (matchsym to listtoelem)
39313+ case 3332LLU: // copy-back deleter (matchsym to listtoelem)
3924839314 {
3924939315 // copy mutable arguments back from call to matchsym
3925039316 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39251- label = 3316LLU; // continue to roll stack
39317+ label = 3322LLU; // continue to roll stack
3925239318 break;
3925339319 }
39254- case 3327LLU: // return from matchsym to listtoelem
39320+ case 3333LLU: // return from matchsym to listtoelem
3925539321 {
3925639322 // copy mutable arguments back from call to matchsym
3925739323 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
3925839324 // call matchsym from listtoelem
39259- stack[base + 7LLU] = 3328LLU/*throw to this address*/;
39325+ stack[base + 7LLU] = 3334LLU/*throw to this address*/;
3926039326 stack[base + 8LLU] = base;
39261- stack[base + 9LLU] = 3329LLU;
39327+ stack[base + 9LLU] = 3335LLU;
3926239328 // arguments for call to matchsym
3926339329 stack[base + 10LLU] = stack[base + 2]/*fnid*/;
3926439330 stack[base + 11LLU] = 45LLU;
@@ -39268,21 +39334,21 @@
3926839334 label = 246LLU; // matchsym
3926939335 break;
3927039336 }
39271- case 3328LLU: // copy-back deleter (matchsym to listtoelem)
39337+ case 3334LLU: // copy-back deleter (matchsym to listtoelem)
3927239338 {
3927339339 // copy mutable arguments back from call to matchsym
3927439340 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39275- label = 3316LLU; // continue to roll stack
39341+ label = 3322LLU; // continue to roll stack
3927639342 break;
3927739343 }
39278- case 3329LLU: // return from matchsym to listtoelem
39344+ case 3335LLU: // return from matchsym to listtoelem
3927939345 {
3928039346 // copy mutable arguments back from call to matchsym
3928139347 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
3928239348 // call matchsym from listtoelem
39283- stack[base + 7LLU] = 3330LLU/*throw to this address*/;
39349+ stack[base + 7LLU] = 3336LLU/*throw to this address*/;
3928439350 stack[base + 8LLU] = base;
39285- stack[base + 9LLU] = 3331LLU;
39351+ stack[base + 9LLU] = 3337LLU;
3928639352 // arguments for call to matchsym
3928739353 stack[base + 10LLU] = stack[base + 2]/*fnid*/;
3928839354 stack[base + 11LLU] = 62LLU;
@@ -39292,21 +39358,21 @@
3929239358 label = 246LLU; // matchsym
3929339359 break;
3929439360 }
39295- case 3330LLU: // copy-back deleter (matchsym to listtoelem)
39361+ case 3336LLU: // copy-back deleter (matchsym to listtoelem)
3929639362 {
3929739363 // copy mutable arguments back from call to matchsym
3929839364 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39299- label = 3316LLU; // continue to roll stack
39365+ label = 3322LLU; // continue to roll stack
3930039366 break;
3930139367 }
39302- case 3331LLU: // return from matchsym to listtoelem
39368+ case 3337LLU: // return from matchsym to listtoelem
3930339369 {
3930439370 // copy mutable arguments back from call to matchsym
3930539371 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
3930639372 // call matchsym from listtoelem
39307- stack[base + 7LLU] = 3332LLU/*throw to this address*/;
39373+ stack[base + 7LLU] = 3338LLU/*throw to this address*/;
3930839374 stack[base + 8LLU] = base;
39309- stack[base + 9LLU] = 3333LLU;
39375+ stack[base + 9LLU] = 3339LLU;
3931039376 // arguments for call to matchsym
3931139377 stack[base + 10LLU] = stack[base + 2]/*fnid*/;
3931239378 stack[base + 11LLU] = 40LLU;
@@ -39316,53 +39382,53 @@
3931639382 label = 246LLU; // matchsym
3931739383 break;
3931839384 }
39319- case 3332LLU: // copy-back deleter (matchsym to listtoelem)
39385+ case 3338LLU: // copy-back deleter (matchsym to listtoelem)
3932039386 {
3932139387 // copy mutable arguments back from call to matchsym
3932239388 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39323- label = 3316LLU; // continue to roll stack
39389+ label = 3322LLU; // continue to roll stack
3932439390 break;
3932539391 }
39326- case 3333LLU: // return from matchsym to listtoelem
39392+ case 3339LLU: // return from matchsym to listtoelem
3932739393 {
3932839394 // copy mutable arguments back from call to matchsym
3932939395 stack[base + 3]/*lookahead*/ = stack[base + 12LLU];
39330- label = 3335LLU; // skip deleter
39396+ label = 3341LLU; // skip deleter
3933139397 break;
3933239398 }
39333- case 3334LLU: // deleter
39399+ case 3340LLU: // deleter
3933439400 {
3933539401 // throw from listtoelem
3933639402 if(!stack[base + 7])
3933739403 {
39338- label = 3316LLU; // skip, variable already deleted/unscoped
39404+ label = 3322LLU; // skip, variable already deleted/unscoped
3933939405 break;
3934039406 }
39341- label = 3316LLU; // continue unrolling stack, delete next variable
39407+ label = 3322LLU; // continue unrolling stack, delete next variable
3934239408 break;
3934339409 }
39344- case 3335LLU: // skipped deleter
39410+ case 3341LLU: // skipped deleter
3934539411 {
39346- label = 3337LLU; // skip deleter
39412+ label = 3343LLU; // skip deleter
3934739413 break;
3934839414 }
39349- case 3336LLU: // deleter
39415+ case 3342LLU: // deleter
3935039416 {
3935139417 // throw from listtoelem
3935239418 if(!stack[base + 8])
3935339419 {
39354- label = 3334LLU; // skip, variable already deleted/unscoped
39420+ label = 3340LLU; // skip, variable already deleted/unscoped
3935539421 break;
3935639422 }
39357- label = 3334LLU; // continue unrolling stack, delete next variable
39423+ label = 3340LLU; // continue unrolling stack, delete next variable
3935839424 break;
3935939425 }
39360- case 3337LLU: // skipped deleter
39426+ case 3343LLU: // skipped deleter
3936139427 {
3936239428 // call ParseToken from listtoelem
39363- stack[base + 9LLU] = 3338LLU/*throw to this address*/;
39429+ stack[base + 9LLU] = 3344LLU/*throw to this address*/;
3936439430 stack[base + 10LLU] = base;
39365- stack[base + 11LLU] = 3339LLU;
39431+ stack[base + 11LLU] = 3345LLU;
3936639432 // arguments for call to ParseToken
3936739433 stack[base + 14LLU] = stack[base + 3]/*lookahead*/;
3936839434 // set stack-base & callee-address
@@ -39370,14 +39436,14 @@
3937039436 label = 3LLU; // ParseToken
3937139437 break;
3937239438 }
39373- case 3338LLU: // copy-back deleter (ParseToken to listtoelem)
39439+ case 3344LLU: // copy-back deleter (ParseToken to listtoelem)
3937439440 {
3937539441 // copy mutable arguments back from call to ParseToken
3937639442 stack[base + 3]/*lookahead*/ = stack[base + 14LLU];
39377- label = 3316LLU; // continue to roll stack
39443+ label = 3322LLU; // continue to roll stack
3937839444 break;
3937939445 }
39380- case 3339LLU: // return from ParseToken to listtoelem
39446+ case 3345LLU: // return from ParseToken to listtoelem
3938139447 {
3938239448 // copy mutable arguments back from call to ParseToken
3938339449 stack[base + 3]/*lookahead*/ = stack[base + 14LLU];
@@ -39385,9 +39451,9 @@
3938539451 stack[base + 7] = stack[base + 12LLU];
3938639452 stack[base + 8] = stack[base + 13LLU];
3938739453 // call equ from listtoelem
39388- stack[base + 9LLU] = 3340LLU/*throw to this address*/;
39454+ stack[base + 9LLU] = 3346LLU/*throw to this address*/;
3938939455 stack[base + 10LLU] = base;
39390- stack[base + 11LLU] = 3341LLU;
39456+ stack[base + 11LLU] = 3347LLU;
3939139457 // arguments for call to equ
3939239458 stack[base + 13LLU] = stack[base + 7]/*variant*/;
3939339459 stack[base + 14LLU] = 4LLU;
@@ -39396,13 +39462,13 @@
3939639462 label = 18446744073709551600LLU; // equ
3939739463 break;
3939839464 }
39399- case 3340LLU: // copy-back deleter (equ to listtoelem)
39465+ case 3346LLU: // copy-back deleter (equ to listtoelem)
3940039466 {
3940139467 // copy mutable arguments back from call to equ
39402- label = 3336LLU; // continue to roll stack
39468+ label = 3342LLU; // continue to roll stack
3940339469 break;
3940439470 }
39405- case 3341LLU: // return from equ to listtoelem
39471+ case 3347LLU: // return from equ to listtoelem
3940639472 {
3940739473 // copy mutable arguments back from call to equ
3940839474 // copy back results provided by call to equ
@@ -39409,21 +39475,21 @@
3940939475 stack[base + 4] = stack[base + 12LLU];
3941039476 if(!stack[base + 4]/*isequal*/)
3941139477 {
39412- label = 3342LLU; // jump to alternative
39478+ label = 3348LLU; // jump to alternative
3941339479 break;
3941439480 }
3941539481
3941639482 // consequent
39417- label = 3343LLU; // consequent complete
39483+ label = 3349LLU; // consequent complete
3941839484 break;
3941939485 }
39420- case 3342LLU: // alternative
39486+ case 3348LLU: // alternative
3942139487 {
3942239488 fprintf(stderr, "%s", "expected identifier in while next but found ");
3942339489 // call reporttok from listtoelem
39424- stack[base + 9LLU] = 3344LLU/*throw to this address*/;
39490+ stack[base + 9LLU] = 3350LLU/*throw to this address*/;
3942539491 stack[base + 10LLU] = base;
39426- stack[base + 11LLU] = 3345LLU;
39492+ stack[base + 11LLU] = 3351LLU;
3942739493 // arguments for call to reporttok
3942839494 stack[base + 12LLU] = stack[base + 7]/*variant*/;
3942939495 stack[base + 13LLU] = stack[base + 8]/*elemid*/;
@@ -39432,30 +39498,30 @@
3943239498 label = 18446744073709551582LLU; // reporttok
3943339499 break;
3943439500 }
39435- case 3344LLU: // copy-back deleter (reporttok to listtoelem)
39501+ case 3350LLU: // copy-back deleter (reporttok to listtoelem)
3943639502 {
3943739503 // copy mutable arguments back from call to reporttok
39438- label = 3336LLU; // continue to roll stack
39504+ label = 3342LLU; // continue to roll stack
3943939505 break;
3944039506 }
39441- case 3345LLU: // return from reporttok to listtoelem
39507+ case 3351LLU: // return from reporttok to listtoelem
3944239508 {
3944339509 // copy mutable arguments back from call to reporttok
3944439510 fprintf(stderr, "%s", "\n");
3944539511 {
39446- label = 3336LLU; // throw: begin to unroll stack
39512+ label = 3342LLU; // throw: begin to unroll stack
3944739513 break;
3944839514 }
3944939515
39450- label = 3343LLU; // alternative complete
39516+ label = 3349LLU; // alternative complete
3945139517 break;
3945239518 }
39453- case 3343LLU: // completed if-then-else
39519+ case 3349LLU: // completed if-then-else
3945439520 {
3945539521 // call matchsym from listtoelem
39456- stack[base + 9LLU] = 3346LLU/*throw to this address*/;
39522+ stack[base + 9LLU] = 3352LLU/*throw to this address*/;
3945739523 stack[base + 10LLU] = base;
39458- stack[base + 11LLU] = 3347LLU;
39524+ stack[base + 11LLU] = 3353LLU;
3945939525 // arguments for call to matchsym
3946039526 stack[base + 12LLU] = stack[base + 2]/*fnid*/;
3946139527 stack[base + 13LLU] = 41LLU;
@@ -39465,49 +39531,49 @@
3946539531 label = 246LLU; // matchsym
3946639532 break;
3946739533 }
39468- case 3346LLU: // copy-back deleter (matchsym to listtoelem)
39534+ case 3352LLU: // copy-back deleter (matchsym to listtoelem)
3946939535 {
3947039536 // copy mutable arguments back from call to matchsym
3947139537 stack[base + 3]/*lookahead*/ = stack[base + 14LLU];
39472- label = 3336LLU; // continue to roll stack
39538+ label = 3342LLU; // continue to roll stack
3947339539 break;
3947439540 }
39475- case 3347LLU: // return from matchsym to listtoelem
39541+ case 3353LLU: // return from matchsym to listtoelem
3947639542 {
3947739543 // copy mutable arguments back from call to matchsym
3947839544 stack[base + 3]/*lookahead*/ = stack[base + 14LLU];
39479- label = 3349LLU; // skip deleter
39545+ label = 3355LLU; // skip deleter
3948039546 break;
3948139547 }
39482- case 3348LLU: // deleter
39548+ case 3354LLU: // deleter
3948339549 {
3948439550 // throw from listtoelem
3948539551 if(!stack[base + 0])
3948639552 {
39487- label = 3336LLU; // skip, variable already deleted/unscoped
39553+ label = 3342LLU; // skip, variable already deleted/unscoped
3948839554 break;
3948939555 }
39490- label = 3336LLU; // continue unrolling stack, delete next variable
39556+ label = 3342LLU; // continue unrolling stack, delete next variable
3949139557 break;
3949239558 }
39493- case 3349LLU: // skipped deleter
39559+ case 3355LLU: // skipped deleter
3949439560 {
3949539561 stack[base + 0] = stack[base + 6]/*listid*/;
39496- label = 3351LLU; // skip deleter
39562+ label = 3357LLU; // skip deleter
3949739563 break;
3949839564 }
39499- case 3350LLU: // deleter
39565+ case 3356LLU: // deleter
3950039566 {
3950139567 // throw from listtoelem
3950239568 if(!stack[base + 1])
3950339569 {
39504- label = 3348LLU; // skip, variable already deleted/unscoped
39570+ label = 3354LLU; // skip, variable already deleted/unscoped
3950539571 break;
3950639572 }
39507- label = 3348LLU; // continue unrolling stack, delete next variable
39573+ label = 3354LLU; // continue unrolling stack, delete next variable
3950839574 break;
3950939575 }
39510- case 3351LLU: // skipped deleter
39576+ case 3357LLU: // skipped deleter
3951139577 {
3951239578 stack[base + 1] = stack[base + 8]/*elemid*/;
3951339579 // return from listtoelem
@@ -39515,7 +39581,7 @@
3951539581 base = stack[base - 2];
3951639582 break;
3951739583 }
39518- case 3352LLU: // ~popnext
39584+ case 3358LLU: // ~popnext
3951939585 {
3952039586 if(stack[base + 0]/*variant-nr*/ >= 2)
3952139587 {
@@ -39522,10 +39588,10 @@
3952239588 fprintf(stderr, "in ~popnext: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
3952339589 exit(-1);
3952439590 }
39525- label = 3352LLU + 1LLU + stack[base + 0]/*variant-nr*/;
39591+ label = 3358LLU + 1LLU + stack[base + 0]/*variant-nr*/;
3952639592 break;
3952739593 }
39528- case 3352LLU + 1LLU + 0LLU: // ~popnext.pop
39594+ case 3358LLU + 1LLU + 0LLU: // ~popnext.pop
3952939595 {
3953039596 // release variant container
3953139597 Free(0, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
@@ -39533,7 +39599,7 @@
3953339599 base = stack[base - 2];
3953439600 break;
3953539601 }
39536- case 3352LLU + 1LLU + 1LLU: // ~popnext.next
39602+ case 3358LLU + 1LLU + 1LLU: // ~popnext.next
3953739603 {
3953839604 // release element previdx
3953939605 // release variant container
@@ -39542,7 +39608,7 @@
3954239608 base = stack[base - 2];
3954339609 break;
3954439610 }
39545- case 3355LLU: // ~listtoelem
39611+ case 3361LLU: // ~listtoelem
3954639612 {
3954739613 if(stack[base + 0]/*variant-nr*/ >= 1)
3954839614 {
@@ -39549,10 +39615,10 @@
3954939615 fprintf(stderr, "in ~listtoelem: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
3955039616 exit(-1);
3955139617 }
39552- label = 3355LLU + 1LLU + stack[base + 0]/*variant-nr*/;
39618+ label = 3361LLU + 1LLU + stack[base + 0]/*variant-nr*/;
3955339619 break;
3955439620 }
39555- case 3355LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem
39621+ case 3361LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem
3955639622 {
3955739623 // release element listindex
3955839624 // release element popnext
@@ -39563,14 +39629,14 @@
3956339629 newstack[0] = (uint64_t)stack; // backup stack location
3956439630 newstack[1] = 1234567890;
3956539631 newstack[2] = base;
39566- newstack[3] = 3357LLU;
39632+ newstack[3] = 3363LLU;
3956739633 stack = newstack;
3956839634 // set stack-base & callee-address
3956939635 base = 4/*deloffset*/;
39570- label = 3352LLU; // ~popnext
39636+ label = 3358LLU; // ~popnext
3957139637 break;
3957239638 }
39573- case 3357LLU: // return from ~popnext to listtoelem
39639+ case 3363LLU: // return from ~popnext to listtoelem
3957439640 {
3957539641 stack = (uint64_t *)stack[0];
3957639642 // releasing toplevel container
@@ -39584,7 +39650,7 @@
3958439650 newstack[0] = (uint64_t)stack; // backup stack location
3958539651 newstack[1] = 1234567890;
3958639652 newstack[2] = base;
39587- newstack[3] = 3358LLU;
39653+ newstack[3] = 3364LLU;
3958839654 stack = newstack;
3958939655 // set stack-base & callee-address
3959039656 base = 4/*deloffset*/;
@@ -39591,7 +39657,7 @@
3959139657 label = 310LLU; // ~type
3959239658 break;
3959339659 }
39594- case 3358LLU: // return from ~type to listtoelem
39660+ case 3364LLU: // return from ~type to listtoelem
3959539661 {
3959639662 stack = (uint64_t *)stack[0];
3959739663 // releasing toplevel container
@@ -39604,13 +39670,13 @@
3960439670 base = stack[base - 2];
3960539671 break;
3960639672 }
39607- case 3360LLU: // function shadowlock failed
39673+ case 3366LLU: // function shadowlock failed
3960839674 {
3960939675 label = stack[base - 3];
3961039676 base = stack[base - 2];
3961139677 break;
3961239678 }
39613- case 3359LLU: // shadowlock
39679+ case 3365LLU: // shadowlock
3961439680 {
3961539681 //#define res0 0
3961639682 //#define arg0 1
@@ -39624,15 +39690,15 @@
3962439690 //#define arg8 9
3962539691 //#define arg9 10
3962639692 //#define arg10 11
39627- label = 3362LLU; // skip deleter
39693+ label = 3368LLU; // skip deleter
3962839694 break;
3962939695 }
39630- case 3361LLU: // deleter
39696+ case 3367LLU: // deleter
3963139697 {
3963239698 // throw from shadowlock
3963339699 if(!stack[base + 12])
3963439700 {
39635- label = 3360LLU; // skip, variable already deleted/unscoped
39701+ label = 3366LLU; // skip, variable already deleted/unscoped
3963639702 break;
3963739703 }
3963839704
@@ -39641,7 +39707,7 @@
3964139707 newstack[0] = (uint64_t)stack; // backup stack location
3964239708 newstack[1] = 1234567890;
3964339709 newstack[2] = base;
39644- newstack[3] = 3363LLU;
39710+ newstack[3] = 3369LLU;
3964539711 stack = newstack;
3964639712 // set stack-base & callee-address
3964739713 base = 4/*deloffset*/;
@@ -39648,21 +39714,21 @@
3964839714 label = 486LLU; // ~letdef
3964939715 break;
3965039716 }
39651- case 3363LLU: // return from ~letdef to shadowlock
39717+ case 3369LLU: // return from ~letdef to shadowlock
3965239718 {
3965339719 stack = (uint64_t *)stack[0];
3965439720 // releasing toplevel container
3965539721 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4));
3965639722
39657- label = 3360LLU; // continue unrolling stack, delete next variable
39723+ label = 3366LLU; // continue unrolling stack, delete next variable
3965839724 break;
3965939725 }
39660- case 3362LLU: // skipped deleter
39726+ case 3368LLU: // skipped deleter
3966139727 {
3966239728 // call FindLet from shadowlock
39663- stack[base + 13LLU] = 3364LLU/*throw to this address*/;
39729+ stack[base + 13LLU] = 3370LLU/*throw to this address*/;
3966439730 stack[base + 14LLU] = base;
39665- stack[base + 15LLU] = 3365LLU;
39731+ stack[base + 15LLU] = 3371LLU;
3966639732 // arguments for call to FindLet
3966739733 stack[base + 17LLU] = stack[base + 1]/*fnid*/;
3966839734 stack[base + 18LLU] = stack[base + 9]/*listid*/;
@@ -39673,13 +39739,13 @@
3967339739 label = 619LLU; // FindLet
3967439740 break;
3967539741 }
39676- case 3364LLU: // copy-back deleter (FindLet to shadowlock)
39742+ case 3370LLU: // copy-back deleter (FindLet to shadowlock)
3967739743 {
3967839744 // copy mutable arguments back from call to FindLet
39679- label = 3360LLU; // continue to roll stack
39745+ label = 3366LLU; // continue to roll stack
3968039746 break;
3968139747 }
39682- case 3365LLU: // return from FindLet to shadowlock
39748+ case 3371LLU: // return from FindLet to shadowlock
3968339749 {
3968439750 // copy mutable arguments back from call to FindLet
3968539751 // copy back results provided by call to FindLet
@@ -39686,7 +39752,7 @@
3968639752 stack[base + 12] = stack[base + 16LLU];
3968739753 if(/*letdef*/0 != ((uint64_t *)(stack[base + 12]/*letdef*/))[0])
3968839754 {
39689- label = 3367LLU; // jump to alternative
39755+ label = 3373LLU; // jump to alternative
3969039756 break;
3969139757 }
3969239758
@@ -39697,15 +39763,15 @@
3969739763 /*substruct*/stack[base + 17] = ((uint64_t **)(stack[base + 12]/*letdef*/))[1][4]/*substruct*/;
3969839764
3969939765 // case
39700- label = 3370LLU; // skip deleter
39766+ label = 3376LLU; // skip deleter
3970139767 break;
3970239768 }
39703- case 3369LLU: // deleter
39769+ case 3375LLU: // deleter
3970439770 {
3970539771 // throw from shadowlock
3970639772 if(!stack[base + 18])
3970739773 {
39708- label = 3368LLU; // skip, variable already deleted/unscoped
39774+ label = 3374LLU; // skip, variable already deleted/unscoped
3970939775 break;
3971039776 }
3971139777
@@ -39714,7 +39780,7 @@
3971439780 newstack[0] = (uint64_t)stack; // backup stack location
3971539781 newstack[1] = 1234567890;
3971639782 newstack[2] = base;
39717- newstack[3] = 3371LLU;
39783+ newstack[3] = 3377LLU;
3971839784 stack = newstack;
3971939785 // set stack-base & callee-address
3972039786 base = 4/*deloffset*/;
@@ -39721,20 +39787,20 @@
3972139787 label = 310LLU; // ~type
3972239788 break;
3972339789 }
39724- case 3371LLU: // return from ~type to shadowlock
39790+ case 3377LLU: // return from ~type to shadowlock
3972539791 {
3972639792 stack = (uint64_t *)stack[0];
3972739793 // releasing toplevel container
3972839794 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
3972939795
39730- label = 3368LLU; // continue unrolling stack, delete next variable
39796+ label = 3374LLU; // continue unrolling stack, delete next variable
3973139797 break;
3973239798 }
39733- case 3370LLU: // skipped deleter
39799+ case 3376LLU: // skipped deleter
3973439800 {
3973539801 if(/*typelist*/1 != ((uint64_t *)(stack[base + 13]/*listtype*/))[0])
3973639802 {
39737- label = 3373LLU; // jump to alternative
39803+ label = 3379LLU; // jump to alternative
3973839804 break;
3973939805 }
3974039806
@@ -39744,7 +39810,7 @@
3974439810 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
3974539811 if(!newstack)
3974639812 {
39747- label = 3374LLU; // throw: begin to unroll stack
39813+ label = 3380LLU; // throw: begin to unroll stack
3974839814 break;
3974939815 }
3975039816
@@ -39751,9 +39817,9 @@
3975139817 newstack[15LLU] = 9876543210LLU; // overflow-marker
3975239818 // call copytype from shadowlock
3975339819 newstack[0] = (uint64_t)stack; // backup stack location
39754- newstack[1] = 3375LLU;
39820+ newstack[1] = 3381LLU;
3975539821 newstack[2] = base;
39756- newstack[3] = 3376LLU;
39822+ newstack[3] = 3382LLU;
3975739823 // arguments for call to copytype
3975839824 newstack[5LLU] = stack[base + 19]/*elemtype*/;
3975939825 stack = newstack;
@@ -39762,7 +39828,7 @@
3976239828 label = 341LLU; // copytype
3976339829 break;
3976439830 }
39765- case 3375LLU: // copy-back deleter (copytype to shadowlock)
39831+ case 3381LLU: // copy-back deleter (copytype to shadowlock)
3976639832 {
3976739833 uint64_t *oldstack = (uint64_t *)stack[0];
3976839834 // copy mutable arguments back from call to copytype
@@ -39773,10 +39839,10 @@
3977339839 }
3977439840 Free(15LLU + 1, sizeof(uint64_t), stack);
3977539841 stack = oldstack;
39776- label = 3374LLU; // continue to unroll stack
39842+ label = 3380LLU; // continue to unroll stack
3977739843 break;
3977839844 }
39779- case 3376LLU: // return from copytype to shadowlock
39845+ case 3382LLU: // return from copytype to shadowlock
3978039846 {
3978139847 uint64_t *oldstack = (uint64_t *)stack[0];
3978239848 // copy mutable arguments back from call to copytype
@@ -39790,23 +39856,23 @@
3979039856 Free(15LLU + 1, sizeof(uint64_t), stack);
3979139857 stack = oldstack;
3979239858 ((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19];
39793- label = 3372LLU; // case complete
39859+ label = 3378LLU; // case complete
3979439860 break;
3979539861 }
39796- case 3374LLU: // copy-back deleter (switch)
39862+ case 3380LLU: // copy-back deleter (switch)
3979739863 {
3979839864 ((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19];
39799- label = 3368LLU; // continue to unroll stack
39865+ label = 3374LLU; // continue to unroll stack
3980039866 break;
3980139867 }
39802- case 3373LLU: // try next case
39868+ case 3379LLU: // try next case
3980339869 {
3980439870 // default
3980539871 fprintf(stderr, "%s", "in function ");
3980639872 // call reportid from shadowlock
39807- stack[base + 19LLU] = 3377LLU/*throw to this address*/;
39873+ stack[base + 19LLU] = 3383LLU/*throw to this address*/;
3980839874 stack[base + 20LLU] = base;
39809- stack[base + 21LLU] = 3378LLU;
39875+ stack[base + 21LLU] = 3384LLU;
3981039876 // arguments for call to reportid
3981139877 stack[base + 22LLU] = stack[base + 1]/*fnid*/;
3981239878 // set stack-base & callee-address
@@ -39814,13 +39880,13 @@
3981439880 label = 18446744073709551586LLU; // reportid
3981539881 break;
3981639882 }
39817- case 3377LLU: // copy-back deleter (reportid to shadowlock)
39883+ case 3383LLU: // copy-back deleter (reportid to shadowlock)
3981839884 {
3981939885 // copy mutable arguments back from call to reportid
39820- label = 3368LLU; // continue to roll stack
39886+ label = 3374LLU; // continue to roll stack
3982139887 break;
3982239888 }
39823- case 3378LLU: // return from reportid to shadowlock
39889+ case 3384LLU: // return from reportid to shadowlock
3982439890 {
3982539891 // copy mutable arguments back from call to reportid
3982639892 fprintf(stderr, "%s", ": ");
@@ -39828,7 +39894,7 @@
3982839894 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3982939895 if(!newstack)
3983039896 {
39831- label = 3368LLU; // throw: begin to unroll stack
39897+ label = 3374LLU; // throw: begin to unroll stack
3983239898 break;
3983339899 }
3983439900
@@ -39835,9 +39901,9 @@
3983539901 newstack[10LLU] = 9876543210LLU; // overflow-marker
3983639902 // call reporttype from shadowlock
3983739903 newstack[0] = (uint64_t)stack; // backup stack location
39838- newstack[1] = 3379LLU;
39904+ newstack[1] = 3385LLU;
3983939905 newstack[2] = base;
39840- newstack[3] = 3380LLU;
39906+ newstack[3] = 3386LLU;
3984139907 // arguments for call to reporttype
3984239908 newstack[4LLU] = stack[base + 13]/*listtype*/;
3984339909 stack = newstack;
@@ -39846,7 +39912,7 @@
3984639912 label = 330LLU; // reporttype
3984739913 break;
3984839914 }
39849- case 3379LLU: // copy-back deleter (reporttype to shadowlock)
39915+ case 3385LLU: // copy-back deleter (reporttype to shadowlock)
3985039916 {
3985139917 uint64_t *oldstack = (uint64_t *)stack[0];
3985239918 // copy mutable arguments back from call to reporttype
@@ -39857,10 +39923,10 @@
3985739923 }
3985839924 Free(10LLU + 1, sizeof(uint64_t), stack);
3985939925 stack = oldstack;
39860- label = 3368LLU; // continue to unroll stack
39926+ label = 3374LLU; // continue to unroll stack
3986139927 break;
3986239928 }
39863- case 3380LLU: // return from reporttype to shadowlock
39929+ case 3386LLU: // return from reporttype to shadowlock
3986439930 {
3986539931 uint64_t *oldstack = (uint64_t *)stack[0];
3986639932 // copy mutable arguments back from call to reporttype
@@ -39873,80 +39939,80 @@
3987339939 stack = oldstack;
3987439940 fprintf(stderr, "%s", "\n");
3987539941 {
39876- label = 3368LLU; // throw: begin to unroll stack
39942+ label = 3374LLU; // throw: begin to unroll stack
3987739943 break;
3987839944 }
3987939945
39880- label = 3372LLU; // default complete
39946+ label = 3378LLU; // default complete
3988139947 break;
3988239948 }
39883- case 3372LLU: // completed switch
39949+ case 3378LLU: // completed switch
3988439950 {
39885- label = 3382LLU; // skip deleter
39951+ label = 3388LLU; // skip deleter
3988639952 break;
3988739953 }
39888- case 3381LLU: // deleter
39954+ case 3387LLU: // deleter
3988939955 {
3989039956 // throw from shadowlock
3989139957 if(!stack[base + 19])
3989239958 {
39893- label = 3369LLU; // skip, variable already deleted/unscoped
39959+ label = 3375LLU; // skip, variable already deleted/unscoped
3989439960 break;
3989539961 }
39896- label = 3369LLU; // continue unrolling stack, delete next variable
39962+ label = 3375LLU; // continue unrolling stack, delete next variable
3989739963 break;
3989839964 }
39899- case 3382LLU: // skipped deleter
39965+ case 3388LLU: // skipped deleter
3990039966 {
3990139967 if(!stack[base + 16]/*mutable*/)
3990239968 {
39903- label = 3383LLU; // jump to alternative
39969+ label = 3389LLU; // jump to alternative
3990439970 break;
3990539971 }
3990639972
3990739973 // consequent
39908- label = 3386LLU; // skip deleter
39974+ label = 3392LLU; // skip deleter
3990939975 break;
3991039976 }
39911- case 3385LLU: // deleter
39977+ case 3391LLU: // deleter
3991239978 {
3991339979 // throw from shadowlock
3991439980 if(!stack[base + 19])
3991539981 {
39916- label = 3369LLU; // skip, variable already deleted/unscoped
39982+ label = 3375LLU; // skip, variable already deleted/unscoped
3991739983 break;
3991839984 }
39919- label = 3369LLU; // continue unrolling stack, delete next variable
39985+ label = 3375LLU; // continue unrolling stack, delete next variable
3992039986 break;
3992139987 }
39922- case 3386LLU: // skipped deleter
39988+ case 3392LLU: // skipped deleter
3992339989 {
3992439990 stack[base + 19] = 0;
39925- label = 3384LLU; // consequent complete
39991+ label = 3390LLU; // consequent complete
3992639992 break;
3992739993 }
39928- case 3383LLU: // alternative
39994+ case 3389LLU: // alternative
3992939995 {
39930- label = 3388LLU; // skip deleter
39996+ label = 3394LLU; // skip deleter
3993139997 break;
3993239998 }
39933- case 3387LLU: // deleter
39999+ case 3393LLU: // deleter
3993440000 {
3993540001 // throw from shadowlock
3993640002 if(!stack[base + 20])
3993740003 {
39938- label = 3369LLU; // skip, variable already deleted/unscoped
40004+ label = 3375LLU; // skip, variable already deleted/unscoped
3993940005 break;
3994040006 }
39941- label = 3369LLU; // continue unrolling stack, delete next variable
40007+ label = 3375LLU; // continue unrolling stack, delete next variable
3994240008 break;
3994340009 }
39944- case 3388LLU: // skipped deleter
40010+ case 3394LLU: // skipped deleter
3994540011 {
3994640012 // call isparam from shadowlock
39947- stack[base + 21LLU] = 3389LLU/*throw to this address*/;
40013+ stack[base + 21LLU] = 3395LLU/*throw to this address*/;
3994840014 stack[base + 22LLU] = base;
39949- stack[base + 23LLU] = 3390LLU;
40015+ stack[base + 23LLU] = 3396LLU;
3995040016 // arguments for call to isparam
3995140017 stack[base + 25LLU] = stack[base + 4]/*fnrescount*/;
3995240018 stack[base + 26LLU] = stack[base + 5]/*fnargcount*/;
@@ -39956,21 +40022,21 @@
3995640022 label = 1671LLU; // isparam
3995740023 break;
3995840024 }
39959- case 3389LLU: // copy-back deleter (isparam to shadowlock)
40025+ case 3395LLU: // copy-back deleter (isparam to shadowlock)
3996040026 {
3996140027 // copy mutable arguments back from call to isparam
39962- label = 3369LLU; // continue to roll stack
40028+ label = 3375LLU; // continue to roll stack
3996340029 break;
3996440030 }
39965- case 3390LLU: // return from isparam to shadowlock
40031+ case 3396LLU: // return from isparam to shadowlock
3996640032 {
3996740033 // copy mutable arguments back from call to isparam
3996840034 // copy back results provided by call to isparam
3996940035 stack[base + 20] = stack[base + 24LLU];
3997040036 // call or from shadowlock
39971- stack[base + 21LLU] = 3391LLU/*throw to this address*/;
40037+ stack[base + 21LLU] = 3397LLU/*throw to this address*/;
3997240038 stack[base + 22LLU] = base;
39973- stack[base + 23LLU] = 3392LLU;
40039+ stack[base + 23LLU] = 3398LLU;
3997440040 // arguments for call to or
3997540041 stack[base + 25LLU] = stack[base + 17]/*substruct*/;
3997640042 stack[base + 26LLU] = stack[base + 20]/*param*/;
@@ -39979,41 +40045,41 @@
3997940045 label = 18446744073709551611LLU; // or
3998040046 break;
3998140047 }
39982- case 3391LLU: // copy-back deleter (or to shadowlock)
40048+ case 3397LLU: // copy-back deleter (or to shadowlock)
3998340049 {
3998440050 // copy mutable arguments back from call to or
39985- label = 3387LLU; // continue to roll stack
40051+ label = 3393LLU; // continue to roll stack
3998640052 break;
3998740053 }
39988- case 3392LLU: // return from or to shadowlock
40054+ case 3398LLU: // return from or to shadowlock
3998940055 {
3999040056 // copy mutable arguments back from call to or
3999140057 // copy back results provided by call to or
3999240058 stack[base + 19] = stack[base + 24LLU];
39993- label = 3384LLU; // alternative complete
40059+ label = 3390LLU; // alternative complete
3999440060 break;
3999540061 }
39996- case 3384LLU: // completed if-then-else
40062+ case 3390LLU: // completed if-then-else
3999740063 {
39998- label = 3394LLU; // skip deleter
40064+ label = 3400LLU; // skip deleter
3999940065 break;
4000040066 }
40001- case 3393LLU: // deleter
40067+ case 3399LLU: // deleter
4000240068 {
4000340069 // throw from shadowlock
4000440070 if(!stack[base + 20])
4000540071 {
40006- label = 3381LLU; // skip, variable already deleted/unscoped
40072+ label = 3387LLU; // skip, variable already deleted/unscoped
4000740073 break;
4000840074 }
40009- label = 3381LLU; // continue unrolling stack, delete next variable
40075+ label = 3387LLU; // continue unrolling stack, delete next variable
4001040076 break;
4001140077 }
40012- case 3394LLU: // skipped deleter
40078+ case 3400LLU: // skipped deleter
4001340079 {
4001440080 if(!stack[base + 11]/*consume*/)
4001540081 {
40016- label = 3395LLU; // jump to alternative
40082+ label = 3401LLU; // jump to alternative
4001740083 break;
4001840084 }
4001940085
@@ -40020,21 +40086,21 @@
4002040086 // consequent
4002140087 if(!stack[base + 16]/*mutable*/)
4002240088 {
40023- label = 3397LLU; // jump to alternative
40089+ label = 3403LLU; // jump to alternative
4002440090 break;
4002540091 }
4002640092
4002740093 // consequent
40028- label = 3398LLU; // consequent complete
40094+ label = 3404LLU; // consequent complete
4002940095 break;
4003040096 }
40031- case 3397LLU: // alternative
40097+ case 3403LLU: // alternative
4003240098 {
4003340099 fprintf(stderr, "%s", "in function ");
4003440100 // call reportid from shadowlock
40035- stack[base + 21LLU] = 3399LLU/*throw to this address*/;
40101+ stack[base + 21LLU] = 3405LLU/*throw to this address*/;
4003640102 stack[base + 22LLU] = base;
40037- stack[base + 23LLU] = 3400LLU;
40103+ stack[base + 23LLU] = 3406LLU;
4003840104 // arguments for call to reportid
4003940105 stack[base + 24LLU] = stack[base + 1]/*fnid*/;
4004040106 // set stack-base & callee-address
@@ -40042,13 +40108,13 @@
4004240108 label = 18446744073709551586LLU; // reportid
4004340109 break;
4004440110 }
40045- case 3399LLU: // copy-back deleter (reportid to shadowlock)
40111+ case 3405LLU: // copy-back deleter (reportid to shadowlock)
4004640112 {
4004740113 // copy mutable arguments back from call to reportid
40048- label = 3381LLU; // continue to roll stack
40114+ label = 3387LLU; // continue to roll stack
4004940115 break;
4005040116 }
40051- case 3400LLU: // return from reportid to shadowlock
40117+ case 3406LLU: // return from reportid to shadowlock
4005240118 {
4005340119 // copy mutable arguments back from call to reportid
4005440120 fprintf(stderr, "%s", ": ");
@@ -40056,7 +40122,7 @@
4005640122 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
4005740123 if(!newstack)
4005840124 {
40059- label = 3381LLU; // throw: begin to unroll stack
40125+ label = 3387LLU; // throw: begin to unroll stack
4006040126 break;
4006140127 }
4006240128
@@ -40063,9 +40129,9 @@
4006340129 newstack[10LLU] = 9876543210LLU; // overflow-marker
4006440130 // call reporttype from shadowlock
4006540131 newstack[0] = (uint64_t)stack; // backup stack location
40066- newstack[1] = 3401LLU;
40132+ newstack[1] = 3407LLU;
4006740133 newstack[2] = base;
40068- newstack[3] = 3402LLU;
40134+ newstack[3] = 3408LLU;
4006940135 // arguments for call to reporttype
4007040136 newstack[4LLU] = stack[base + 13]/*listtype*/;
4007140137 stack = newstack;
@@ -40074,7 +40140,7 @@
4007440140 label = 330LLU; // reporttype
4007540141 break;
4007640142 }
40077- case 3401LLU: // copy-back deleter (reporttype to shadowlock)
40143+ case 3407LLU: // copy-back deleter (reporttype to shadowlock)
4007840144 {
4007940145 uint64_t *oldstack = (uint64_t *)stack[0];
4008040146 // copy mutable arguments back from call to reporttype
@@ -40085,10 +40151,10 @@
4008540151 }
4008640152 Free(10LLU + 1, sizeof(uint64_t), stack);
4008740153 stack = oldstack;
40088- label = 3381LLU; // continue to unroll stack
40154+ label = 3387LLU; // continue to unroll stack
4008940155 break;
4009040156 }
40091- case 3402LLU: // return from reporttype to shadowlock
40157+ case 3408LLU: // return from reporttype to shadowlock
4009240158 {
4009340159 uint64_t *oldstack = (uint64_t *)stack[0];
4009440160 // copy mutable arguments back from call to reporttype
@@ -40101,18 +40167,18 @@
4010140167 stack = oldstack;
4010240168 fprintf(stderr, "%s", "\n");
4010340169 {
40104- label = 3381LLU; // throw: begin to unroll stack
40170+ label = 3387LLU; // throw: begin to unroll stack
4010540171 break;
4010640172 }
4010740173
40108- label = 3398LLU; // alternative complete
40174+ label = 3404LLU; // alternative complete
4010940175 break;
4011040176 }
40111- case 3398LLU: // completed if-then-else
40177+ case 3404LLU: // completed if-then-else
4011240178 {
4011340179 if(/*scope*/0 != ((uint64_t *)(stack[base + 3]/*scope*/))[0])
4011440180 {
40115- label = 3404LLU; // jump to alternative
40181+ label = 3410LLU; // jump to alternative
4011640182 break;
4011740183 }
4011840184
@@ -40120,15 +40186,15 @@
4012040186 /*letdefs*/stack[base + 22] = ((uint64_t **)(stack[base + 3]/*scope*/))[1][1]/*letdefs*/;
4012140187
4012240188 // case
40123- label = 3407LLU; // skip deleter
40189+ label = 3413LLU; // skip deleter
4012440190 break;
4012540191 }
40126- case 3406LLU: // deleter
40192+ case 3412LLU: // deleter
4012740193 {
4012840194 // throw from shadowlock
4012940195 if(!stack[base + 23])
4013040196 {
40131- label = 3405LLU; // skip, variable already deleted/unscoped
40197+ label = 3411LLU; // skip, variable already deleted/unscoped
4013240198 break;
4013340199 }
4013440200
@@ -40137,7 +40203,7 @@
4013740203 newstack[0] = (uint64_t)stack; // backup stack location
4013840204 newstack[1] = 1234567890;
4013940205 newstack[2] = base;
40140- newstack[3] = 3408LLU;
40206+ newstack[3] = 3414LLU;
4014140207 stack = newstack;
4014240208 // set stack-base & callee-address
4014340209 base = 4/*deloffset*/;
@@ -40144,21 +40210,21 @@
4014440210 label = 310LLU; // ~type
4014540211 break;
4014640212 }
40147- case 3408LLU: // return from ~type to shadowlock
40213+ case 3414LLU: // return from ~type to shadowlock
4014840214 {
4014940215 stack = (uint64_t *)stack[0];
4015040216 // releasing toplevel container
4015140217 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4));
4015240218
40153- label = 3405LLU; // continue unrolling stack, delete next variable
40219+ label = 3411LLU; // continue unrolling stack, delete next variable
4015440220 break;
4015540221 }
40156- case 3407LLU: // skipped deleter
40222+ case 3413LLU: // skipped deleter
4015740223 {
4015840224 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
4015940225 if(!newstack)
4016040226 {
40161- label = 3405LLU; // throw: begin to unroll stack
40227+ label = 3411LLU; // throw: begin to unroll stack
4016240228 break;
4016340229 }
4016440230
@@ -40165,9 +40231,9 @@
4016540231 newstack[15LLU] = 9876543210LLU; // overflow-marker
4016640232 // call copytype from shadowlock
4016740233 newstack[0] = (uint64_t)stack; // backup stack location
40168- newstack[1] = 3409LLU;
40234+ newstack[1] = 3415LLU;
4016940235 newstack[2] = base;
40170- newstack[3] = 3410LLU;
40236+ newstack[3] = 3416LLU;
4017140237 // arguments for call to copytype
4017240238 newstack[5LLU] = stack[base + 13]/*listtype*/;
4017340239 stack = newstack;
@@ -40176,7 +40242,7 @@
4017640242 label = 341LLU; // copytype
4017740243 break;
4017840244 }
40179- case 3409LLU: // copy-back deleter (copytype to shadowlock)
40245+ case 3415LLU: // copy-back deleter (copytype to shadowlock)
4018040246 {
4018140247 uint64_t *oldstack = (uint64_t *)stack[0];
4018240248 // copy mutable arguments back from call to copytype
@@ -40187,10 +40253,10 @@
4018740253 }
4018840254 Free(15LLU + 1, sizeof(uint64_t), stack);
4018940255 stack = oldstack;
40190- label = 3405LLU; // continue to unroll stack
40256+ label = 3411LLU; // continue to unroll stack
4019140257 break;
4019240258 }
40193- case 3410LLU: // return from copytype to shadowlock
40259+ case 3416LLU: // return from copytype to shadowlock
4019440260 {
4019540261 uint64_t *oldstack = (uint64_t *)stack[0];
4019640262 // copy mutable arguments back from call to copytype
@@ -40203,49 +40269,49 @@
4020340269 }
4020440270 Free(15LLU + 1, sizeof(uint64_t), stack);
4020540271 stack = oldstack;
40206- label = 3412LLU; // skip deleter
40272+ label = 3418LLU; // skip deleter
4020740273 break;
4020840274 }
40209- case 3411LLU: // deleter
40275+ case 3417LLU: // deleter
4021040276 {
4021140277 // throw from shadowlock
4021240278 if(!stack[base + 24])
4021340279 {
40214- label = 3406LLU; // skip, variable already deleted/unscoped
40280+ label = 3412LLU; // skip, variable already deleted/unscoped
4021540281 break;
4021640282 }
40217- label = 3406LLU; // continue unrolling stack, delete next variable
40283+ label = 3412LLU; // continue unrolling stack, delete next variable
4021840284 break;
4021940285 }
40220- case 3412LLU: // skipped deleter
40286+ case 3418LLU: // skipped deleter
4022140287 {
4022240288 stack[base + 24] = 0;
40223- label = 3414LLU; // skip deleter
40289+ label = 3420LLU; // skip deleter
4022440290 break;
4022540291 }
40226- case 3413LLU: // deleter
40292+ case 3419LLU: // deleter
4022740293 {
4022840294 // throw from shadowlock
4022940295 if(!stack[base + 25])
4023040296 {
40231- label = 3411LLU; // skip, variable already deleted/unscoped
40297+ label = 3417LLU; // skip, variable already deleted/unscoped
4023240298 break;
4023340299 }
40234- label = 3411LLU; // continue unrolling stack, delete next variable
40300+ label = 3417LLU; // continue unrolling stack, delete next variable
4023540301 break;
4023640302 }
40237- case 3414LLU: // skipped deleter
40303+ case 3420LLU: // skipped deleter
4023840304 {
4023940305 stack[base + 25] = 0;
40240- label = 3416LLU; // skip deleter
40306+ label = 3422LLU; // skip deleter
4024140307 break;
4024240308 }
40243- case 3415LLU: // deleter
40309+ case 3421LLU: // deleter
4024440310 {
4024540311 // throw from shadowlock
4024640312 if(!stack[base + 26])
4024740313 {
40248- label = 3413LLU; // skip, variable already deleted/unscoped
40314+ label = 3419LLU; // skip, variable already deleted/unscoped
4024940315 break;
4025040316 }
4025140317
@@ -40254,7 +40320,7 @@
4025440320 newstack[0] = (uint64_t)stack; // backup stack location
4025540321 newstack[1] = 1234567890;
4025640322 newstack[2] = base;
40257- newstack[3] = 3417LLU;
40323+ newstack[3] = 3423LLU;
4025840324 stack = newstack;
4025940325 // set stack-base & callee-address
4026040326 base = 4/*deloffset*/;
@@ -40261,21 +40327,21 @@
4026140327 label = 486LLU; // ~letdef
4026240328 break;
4026340329 }
40264- case 3417LLU: // return from ~letdef to shadowlock
40330+ case 3423LLU: // return from ~letdef to shadowlock
4026540331 {
4026640332 stack = (uint64_t *)stack[0];
4026740333 // releasing toplevel container
4026840334 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 26] - sizeof(uint64_t) * 4));
4026940335
40270- label = 3413LLU; // continue unrolling stack, delete next variable
40336+ label = 3419LLU; // continue unrolling stack, delete next variable
4027140337 break;
4027240338 }
40273- case 3416LLU: // skipped deleter
40339+ case 3422LLU: // skipped deleter
4027440340 {
4027540341 // construct letdef.letdef
4027640342 if(!(stack[base + 26] = construct(5)))
4027740343 {
40278- label = 3413LLU; // throw: begin to unroll stack
40344+ label = 3419LLU; // throw: begin to unroll stack
4027940345 break;
4028040346 }
4028140347
@@ -40301,50 +40367,50 @@
4030140367 }
4030240368 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22];
4030340369 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21];
40304- label = 3403LLU; // case complete
40370+ label = 3409LLU; // case complete
4030540371 break;
4030640372 }
40307- case 3405LLU: // copy-back deleter (switch)
40373+ case 3411LLU: // copy-back deleter (switch)
4030840374 {
4030940375 ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22];
4031040376 ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21];
40311- label = 3381LLU; // continue to unroll stack
40377+ label = 3387LLU; // continue to unroll stack
4031240378 break;
4031340379 }
40314- case 3404LLU: // try next case
40380+ case 3410LLU: // try next case
4031540381 {
4031640382 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4031740383 exit(-1);
4031840384 }
40319- case 3403LLU: // completed switch
40385+ case 3409LLU: // completed switch
4032040386 {
40321- label = 3419LLU; // skip deleter
40387+ label = 3425LLU; // skip deleter
4032240388 break;
4032340389 }
40324- case 3418LLU: // deleter
40390+ case 3424LLU: // deleter
4032540391 {
4032640392 // throw from shadowlock
4032740393 if(!stack[base + 20])
4032840394 {
40329- label = 3381LLU; // skip, variable already deleted/unscoped
40395+ label = 3387LLU; // skip, variable already deleted/unscoped
4033040396 break;
4033140397 }
40332- label = 3381LLU; // continue unrolling stack, delete next variable
40398+ label = 3387LLU; // continue unrolling stack, delete next variable
4033340399 break;
4033440400 }
40335- case 3419LLU: // skipped deleter
40401+ case 3425LLU: // skipped deleter
4033640402 {
4033740403 stack[base + 20] = stack[base + 15]/*listindex*/;
40338- label = 3396LLU; // consequent complete
40404+ label = 3402LLU; // consequent complete
4033940405 break;
4034040406 }
40341- case 3395LLU: // alternative
40407+ case 3401LLU: // alternative
4034240408 {
4034340409 printf("%s", "\n flippedassign(");
4034440410 // call emitvar from shadowlock
40345- stack[base + 21LLU] = 3420LLU/*throw to this address*/;
40411+ stack[base + 21LLU] = 3426LLU/*throw to this address*/;
4034640412 stack[base + 22LLU] = base;
40347- stack[base + 23LLU] = 3421LLU;
40413+ stack[base + 23LLU] = 3427LLU;
4034840414 // arguments for call to emitvar
4034940415 stack[base + 24LLU] = stack[base + 1]/*fnid*/;
4035040416 stack[base + 25LLU] = stack[base + 14]/*listid*/;
@@ -40355,53 +40421,53 @@
4035540421 label = 749LLU; // emitvar
4035640422 break;
4035740423 }
40358- case 3420LLU: // copy-back deleter (emitvar to shadowlock)
40424+ case 3426LLU: // copy-back deleter (emitvar to shadowlock)
4035940425 {
4036040426 // copy mutable arguments back from call to emitvar
40361- label = 3381LLU; // continue to roll stack
40427+ label = 3387LLU; // continue to roll stack
4036240428 break;
4036340429 }
40364- case 3421LLU: // return from emitvar to shadowlock
40430+ case 3427LLU: // return from emitvar to shadowlock
4036540431 {
4036640432 // copy mutable arguments back from call to emitvar
4036740433 printf("%s", ", &");
40368- label = 3423LLU; // skip deleter
40434+ label = 3429LLU; // skip deleter
4036940435 break;
4037040436 }
40371- case 3422LLU: // deleter
40437+ case 3428LLU: // deleter
4037240438 {
4037340439 // throw from shadowlock
4037440440 if(!stack[base + 21])
4037540441 {
40376- label = 3381LLU; // skip, variable already deleted/unscoped
40442+ label = 3387LLU; // skip, variable already deleted/unscoped
4037740443 break;
4037840444 }
40379- label = 3381LLU; // continue unrolling stack, delete next variable
40445+ label = 3387LLU; // continue unrolling stack, delete next variable
4038040446 break;
4038140447 }
40382- case 3423LLU: // skipped deleter
40448+ case 3429LLU: // skipped deleter
4038340449 {
4038440450 stack[base + 21] = 0;
40385- label = 3425LLU; // skip deleter
40451+ label = 3431LLU; // skip deleter
4038640452 break;
4038740453 }
40388- case 3424LLU: // deleter
40454+ case 3430LLU: // deleter
4038940455 {
4039040456 // throw from shadowlock
4039140457 if(!stack[base + 22])
4039240458 {
40393- label = 3422LLU; // skip, variable already deleted/unscoped
40459+ label = 3428LLU; // skip, variable already deleted/unscoped
4039440460 break;
4039540461 }
40396- label = 3422LLU; // continue unrolling stack, delete next variable
40462+ label = 3428LLU; // continue unrolling stack, delete next variable
4039740463 break;
4039840464 }
40399- case 3425LLU: // skipped deleter
40465+ case 3431LLU: // skipped deleter
4040040466 {
4040140467 // call newvarraw from shadowlock
40402- stack[base + 23LLU] = 3426LLU/*throw to this address*/;
40468+ stack[base + 23LLU] = 3432LLU/*throw to this address*/;
4040340469 stack[base + 24LLU] = base;
40404- stack[base + 25LLU] = 3427LLU;
40470+ stack[base + 25LLU] = 3433LLU;
4040540471 // arguments for call to newvarraw
4040640472 stack[base + 27LLU] = stack[base + 13]/*listtype*/;
4040740473 stack[base + 28LLU] = stack[base + 14]/*listid*/;
@@ -40417,16 +40483,16 @@
4041740483 label = 759LLU; // newvarraw
4041840484 break;
4041940485 }
40420- case 3426LLU: // copy-back deleter (newvarraw to shadowlock)
40486+ case 3432LLU: // copy-back deleter (newvarraw to shadowlock)
4042140487 {
4042240488 // copy mutable arguments back from call to newvarraw
4042340489 stack[base + 3]/*scope*/ = stack[base + 34LLU];
4042440490 stack[base + 7]/*varcount*/ = stack[base + 33LLU];
4042540491 stack[base + 6]/*fnmaxcount*/ = stack[base + 32LLU];
40426- label = 3422LLU; // continue to roll stack
40492+ label = 3428LLU; // continue to roll stack
4042740493 break;
4042840494 }
40429- case 3427LLU: // return from newvarraw to shadowlock
40495+ case 3433LLU: // return from newvarraw to shadowlock
4043040496 {
4043140497 // copy mutable arguments back from call to newvarraw
4043240498 stack[base + 3]/*scope*/ = stack[base + 34LLU];
@@ -40435,9 +40501,9 @@
4043540501 // copy back results provided by call to newvarraw
4043640502 stack[base + 22] = stack[base + 26LLU];
4043740503 // call emitvaridx from shadowlock
40438- stack[base + 23LLU] = 3428LLU/*throw to this address*/;
40504+ stack[base + 23LLU] = 3434LLU/*throw to this address*/;
4043940505 stack[base + 24LLU] = base;
40440- stack[base + 25LLU] = 3429LLU;
40506+ stack[base + 25LLU] = 3435LLU;
4044140507 // arguments for call to emitvaridx
4044240508 stack[base + 26LLU] = stack[base + 22]/*shadowidx*/;
4044340509 // set stack-base & callee-address
@@ -40445,58 +40511,58 @@
4044540511 label = 745LLU; // emitvaridx
4044640512 break;
4044740513 }
40448- case 3428LLU: // copy-back deleter (emitvaridx to shadowlock)
40514+ case 3434LLU: // copy-back deleter (emitvaridx to shadowlock)
4044940515 {
4045040516 // copy mutable arguments back from call to emitvaridx
40451- label = 3424LLU; // continue to roll stack
40517+ label = 3430LLU; // continue to roll stack
4045240518 break;
4045340519 }
40454- case 3429LLU: // return from emitvaridx to shadowlock
40520+ case 3435LLU: // return from emitvaridx to shadowlock
4045540521 {
4045640522 // copy mutable arguments back from call to emitvaridx
4045740523 printf("%s", ");");
40458- label = 3431LLU; // skip deleter
40524+ label = 3437LLU; // skip deleter
4045940525 break;
4046040526 }
40461- case 3430LLU: // deleter
40527+ case 3436LLU: // deleter
4046240528 {
4046340529 // throw from shadowlock
4046440530 if(!stack[base + 20])
4046540531 {
40466- label = 3424LLU; // skip, variable already deleted/unscoped
40532+ label = 3430LLU; // skip, variable already deleted/unscoped
4046740533 break;
4046840534 }
40469- label = 3424LLU; // continue unrolling stack, delete next variable
40535+ label = 3430LLU; // continue unrolling stack, delete next variable
4047040536 break;
4047140537 }
40472- case 3431LLU: // skipped deleter
40538+ case 3437LLU: // skipped deleter
4047340539 {
4047440540 stack[base + 20] = stack[base + 22]/*shadowidx*/;
40475- label = 3396LLU; // alternative complete
40541+ label = 3402LLU; // alternative complete
4047640542 break;
4047740543 }
40478- case 3396LLU: // completed if-then-else
40544+ case 3402LLU: // completed if-then-else
4047940545 {
40480- label = 3433LLU; // skip deleter
40546+ label = 3439LLU; // skip deleter
4048140547 break;
4048240548 }
40483- case 3432LLU: // deleter
40549+ case 3438LLU: // deleter
4048440550 {
4048540551 // throw from shadowlock
4048640552 if(!stack[base + 21])
4048740553 {
40488- label = 3393LLU; // skip, variable already deleted/unscoped
40554+ label = 3399LLU; // skip, variable already deleted/unscoped
4048940555 break;
4049040556 }
40491- label = 3393LLU; // continue unrolling stack, delete next variable
40557+ label = 3399LLU; // continue unrolling stack, delete next variable
4049240558 break;
4049340559 }
40494- case 3433LLU: // skipped deleter
40560+ case 3439LLU: // skipped deleter
4049540561 {
4049640562 // call newvarraw from shadowlock
40497- stack[base + 22LLU] = 3434LLU/*throw to this address*/;
40563+ stack[base + 22LLU] = 3440LLU/*throw to this address*/;
4049840564 stack[base + 23LLU] = base;
40499- stack[base + 24LLU] = 3435LLU;
40565+ stack[base + 24LLU] = 3441LLU;
4050040566 // arguments for call to newvarraw
4050140567 stack[base + 26LLU] = stack[base + 18]/*elemtype*/;
4050240568 stack[base + 27LLU] = stack[base + 10]/*elemid*/;
@@ -40512,16 +40578,16 @@
4051240578 label = 759LLU; // newvarraw
4051340579 break;
4051440580 }
40515- case 3434LLU: // copy-back deleter (newvarraw to shadowlock)
40581+ case 3440LLU: // copy-back deleter (newvarraw to shadowlock)
4051640582 {
4051740583 // copy mutable arguments back from call to newvarraw
4051840584 stack[base + 3]/*scope*/ = stack[base + 33LLU];
4051940585 stack[base + 7]/*varcount*/ = stack[base + 32LLU];
4052040586 stack[base + 6]/*fnmaxcount*/ = stack[base + 31LLU];
40521- label = 3393LLU; // continue to roll stack
40587+ label = 3399LLU; // continue to roll stack
4052240588 break;
4052340589 }
40524- case 3435LLU: // return from newvarraw to shadowlock
40590+ case 3441LLU: // return from newvarraw to shadowlock
4052540591 {
4052640592 // copy mutable arguments back from call to newvarraw
4052740593 stack[base + 3]/*scope*/ = stack[base + 33LLU];
@@ -40529,15 +40595,15 @@
4052940595 stack[base + 6]/*fnmaxcount*/ = stack[base + 31LLU];
4053040596 // copy back results provided by call to newvarraw
4053140597 stack[base + 21] = stack[base + 25LLU];
40532- label = 3437LLU; // skip deleter
40598+ label = 3443LLU; // skip deleter
4053340599 break;
4053440600 }
40535- case 3436LLU: // deleter
40601+ case 3442LLU: // deleter
4053640602 {
4053740603 // throw from shadowlock
4053840604 if(!stack[base + 22])
4053940605 {
40540- label = 3432LLU; // skip, variable already deleted/unscoped
40606+ label = 3438LLU; // skip, variable already deleted/unscoped
4054140607 break;
4054240608 }
4054340609
@@ -40546,40 +40612,40 @@
4054640612 newstack[0] = (uint64_t)stack; // backup stack location
4054740613 newstack[1] = 1234567890;
4054840614 newstack[2] = base;
40549- newstack[3] = 3438LLU;
40615+ newstack[3] = 3444LLU;
4055040616 stack = newstack;
4055140617 // set stack-base & callee-address
4055240618 base = 4/*deloffset*/;
40553- label = 3352LLU; // ~popnext
40619+ label = 3358LLU; // ~popnext
4055440620 break;
4055540621 }
40556- case 3438LLU: // return from ~popnext to shadowlock
40622+ case 3444LLU: // return from ~popnext to shadowlock
4055740623 {
4055840624 stack = (uint64_t *)stack[0];
4055940625 // releasing toplevel container
4056040626 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
4056140627
40562- label = 3432LLU; // continue unrolling stack, delete next variable
40628+ label = 3438LLU; // continue unrolling stack, delete next variable
4056340629 break;
4056440630 }
40565- case 3437LLU: // skipped deleter
40631+ case 3443LLU: // skipped deleter
4056640632 {
4056740633 if(!stack[base + 11]/*consume*/)
4056840634 {
40569- label = 3439LLU; // jump to alternative
40635+ label = 3445LLU; // jump to alternative
4057040636 break;
4057140637 }
4057240638
4057340639 // consequent
40574- label = 3442LLU; // skip deleter
40640+ label = 3448LLU; // skip deleter
4057540641 break;
4057640642 }
40577- case 3441LLU: // deleter
40643+ case 3447LLU: // deleter
4057840644 {
4057940645 // throw from shadowlock
4058040646 if(!stack[base + 22])
4058140647 {
40582- label = 3432LLU; // skip, variable already deleted/unscoped
40648+ label = 3438LLU; // skip, variable already deleted/unscoped
4058340649 break;
4058440650 }
4058540651
@@ -40588,58 +40654,58 @@
4058840654 newstack[0] = (uint64_t)stack; // backup stack location
4058940655 newstack[1] = 1234567890;
4059040656 newstack[2] = base;
40591- newstack[3] = 3443LLU;
40657+ newstack[3] = 3449LLU;
4059240658 stack = newstack;
4059340659 // set stack-base & callee-address
4059440660 base = 4/*deloffset*/;
40595- label = 3352LLU; // ~popnext
40661+ label = 3358LLU; // ~popnext
4059640662 break;
4059740663 }
40598- case 3443LLU: // return from ~popnext to shadowlock
40664+ case 3449LLU: // return from ~popnext to shadowlock
4059940665 {
4060040666 stack = (uint64_t *)stack[0];
4060140667 // releasing toplevel container
4060240668 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
4060340669
40604- label = 3432LLU; // continue unrolling stack, delete next variable
40670+ label = 3438LLU; // continue unrolling stack, delete next variable
4060540671 break;
4060640672 }
40607- case 3442LLU: // skipped deleter
40673+ case 3448LLU: // skipped deleter
4060840674 {
4060940675 // construct popnext.pop
4061040676 if(!(stack[base + 22] = construct(0)))
4061140677 {
40612- label = 3432LLU; // throw: begin to unroll stack
40678+ label = 3438LLU; // throw: begin to unroll stack
4061340679 break;
4061440680 }
4061540681
4061640682 // consequent
4061740683 ((uint64_t *)stack[base + 22])[0] = 0;
40618- label = 3440LLU; // consequent complete
40684+ label = 3446LLU; // consequent complete
4061940685 break;
4062040686 }
40621- case 3439LLU: // alternative
40687+ case 3445LLU: // alternative
4062240688 {
40623- label = 3445LLU; // skip deleter
40689+ label = 3451LLU; // skip deleter
4062440690 break;
4062540691 }
40626- case 3444LLU: // deleter
40692+ case 3450LLU: // deleter
4062740693 {
4062840694 // throw from shadowlock
4062940695 if(!stack[base + 23])
4063040696 {
40631- label = 3432LLU; // skip, variable already deleted/unscoped
40697+ label = 3438LLU; // skip, variable already deleted/unscoped
4063240698 break;
4063340699 }
40634- label = 3432LLU; // continue unrolling stack, delete next variable
40700+ label = 3438LLU; // continue unrolling stack, delete next variable
4063540701 break;
4063640702 }
40637- case 3445LLU: // skipped deleter
40703+ case 3451LLU: // skipped deleter
4063840704 {
4063940705 // call newvarraw from shadowlock
40640- stack[base + 24LLU] = 3446LLU/*throw to this address*/;
40706+ stack[base + 24LLU] = 3452LLU/*throw to this address*/;
4064140707 stack[base + 25LLU] = base;
40642- stack[base + 26LLU] = 3447LLU;
40708+ stack[base + 26LLU] = 3453LLU;
4064340709 // arguments for call to newvarraw
4064440710 stack[base + 28LLU] = stack[base + 13]/*listtype*/;
4064540711 stack[base + 29LLU] = 0LLU;
@@ -40655,16 +40721,16 @@
4065540721 label = 759LLU; // newvarraw
4065640722 break;
4065740723 }
40658- case 3446LLU: // copy-back deleter (newvarraw to shadowlock)
40724+ case 3452LLU: // copy-back deleter (newvarraw to shadowlock)
4065940725 {
4066040726 // copy mutable arguments back from call to newvarraw
4066140727 stack[base + 3]/*scope*/ = stack[base + 35LLU];
4066240728 stack[base + 7]/*varcount*/ = stack[base + 34LLU];
4066340729 stack[base + 6]/*fnmaxcount*/ = stack[base + 33LLU];
40664- label = 3432LLU; // continue to roll stack
40730+ label = 3438LLU; // continue to roll stack
4066540731 break;
4066640732 }
40667- case 3447LLU: // return from newvarraw to shadowlock
40733+ case 3453LLU: // return from newvarraw to shadowlock
4066840734 {
4066940735 // copy mutable arguments back from call to newvarraw
4067040736 stack[base + 3]/*scope*/ = stack[base + 35LLU];
@@ -40672,15 +40738,15 @@
4067240738 stack[base + 6]/*fnmaxcount*/ = stack[base + 33LLU];
4067340739 // copy back results provided by call to newvarraw
4067440740 stack[base + 23] = stack[base + 27LLU];
40675- label = 3449LLU; // skip deleter
40741+ label = 3455LLU; // skip deleter
4067640742 break;
4067740743 }
40678- case 3448LLU: // deleter
40744+ case 3454LLU: // deleter
4067940745 {
4068040746 // throw from shadowlock
4068140747 if(!stack[base + 22])
4068240748 {
40683- label = 3444LLU; // skip, variable already deleted/unscoped
40749+ label = 3450LLU; // skip, variable already deleted/unscoped
4068440750 break;
4068540751 }
4068640752
@@ -40689,28 +40755,28 @@
4068940755 newstack[0] = (uint64_t)stack; // backup stack location
4069040756 newstack[1] = 1234567890;
4069140757 newstack[2] = base;
40692- newstack[3] = 3450LLU;
40758+ newstack[3] = 3456LLU;
4069340759 stack = newstack;
4069440760 // set stack-base & callee-address
4069540761 base = 4/*deloffset*/;
40696- label = 3352LLU; // ~popnext
40762+ label = 3358LLU; // ~popnext
4069740763 break;
4069840764 }
40699- case 3450LLU: // return from ~popnext to shadowlock
40765+ case 3456LLU: // return from ~popnext to shadowlock
4070040766 {
4070140767 stack = (uint64_t *)stack[0];
4070240768 // releasing toplevel container
4070340769 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
4070440770
40705- label = 3444LLU; // continue unrolling stack, delete next variable
40771+ label = 3450LLU; // continue unrolling stack, delete next variable
4070640772 break;
4070740773 }
40708- case 3449LLU: // skipped deleter
40774+ case 3455LLU: // skipped deleter
4070940775 {
4071040776 // construct popnext.next
4071140777 if(!(stack[base + 22] = construct(1)))
4071240778 {
40713- label = 3444LLU; // throw: begin to unroll stack
40779+ label = 3450LLU; // throw: begin to unroll stack
4071440780 break;
4071540781 }
4071640782
@@ -40717,20 +40783,20 @@
4071740783 // consequent
4071840784 ((uint64_t *)stack[base + 22])[0] = 1;
4071940785 (((uint64_t **)(stack[base + 22]))[1][0]) = stack[base + 23]/*previdx*/;
40720- label = 3440LLU; // alternative complete
40786+ label = 3446LLU; // alternative complete
4072140787 break;
4072240788 }
40723- case 3440LLU: // completed if-then-else
40789+ case 3446LLU: // completed if-then-else
4072440790 {
40725- label = 3452LLU; // skip deleter
40791+ label = 3458LLU; // skip deleter
4072640792 break;
4072740793 }
40728- case 3451LLU: // deleter
40794+ case 3457LLU: // deleter
4072940795 {
4073040796 // throw from shadowlock
4073140797 if(!stack[base + 0])
4073240798 {
40733- label = 3436LLU; // skip, variable already deleted/unscoped
40799+ label = 3442LLU; // skip, variable already deleted/unscoped
4073440800 break;
4073540801 }
4073640802
@@ -40739,28 +40805,28 @@
4073940805 newstack[0] = (uint64_t)stack; // backup stack location
4074040806 newstack[1] = 1234567890;
4074140807 newstack[2] = base;
40742- newstack[3] = 3453LLU;
40808+ newstack[3] = 3459LLU;
4074340809 stack = newstack;
4074440810 // set stack-base & callee-address
4074540811 base = 4/*deloffset*/;
40746- label = 3355LLU; // ~listtoelem
40812+ label = 3361LLU; // ~listtoelem
4074740813 break;
4074840814 }
40749- case 3453LLU: // return from ~listtoelem to shadowlock
40815+ case 3459LLU: // return from ~listtoelem to shadowlock
4075040816 {
4075140817 stack = (uint64_t *)stack[0];
4075240818 // releasing toplevel container
4075340819 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
4075440820
40755- label = 3436LLU; // continue unrolling stack, delete next variable
40821+ label = 3442LLU; // continue unrolling stack, delete next variable
4075640822 break;
4075740823 }
40758- case 3452LLU: // skipped deleter
40824+ case 3458LLU: // skipped deleter
4075940825 {
4076040826 // construct listtoelem.listtoelem
4076140827 if(!(stack[base + 0] = construct(4)))
4076240828 {
40763- label = 3436LLU; // throw: begin to unroll stack
40829+ label = 3442LLU; // throw: begin to unroll stack
4076440830 break;
4076540831 }
4076640832
@@ -40775,10 +40841,10 @@
4077540841 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15];
4077640842 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14];
4077740843 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13];
40778- label = 3366LLU; // case complete
40844+ label = 3372LLU; // case complete
4077940845 break;
4078040846 }
40781- case 3368LLU: // copy-back deleter (switch)
40847+ case 3374LLU: // copy-back deleter (switch)
4078240848 {
4078340849 ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 17];
4078440850 ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 16];
@@ -40785,15 +40851,15 @@
4078540851 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15];
4078640852 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14];
4078740853 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13];
40788- label = 3361LLU; // continue to unroll stack
40854+ label = 3367LLU; // continue to unroll stack
4078940855 break;
4079040856 }
40791- case 3367LLU: // try next case
40857+ case 3373LLU: // try next case
4079240858 {
4079340859 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4079440860 exit(-1);
4079540861 }
40796- case 3366LLU: // completed switch
40862+ case 3372LLU: // completed switch
4079740863 {
4079840864
4079940865 uint64_t *newstack = (uint64_t *)(stack[base + 12] - sizeof(uint64_t) * 4);
@@ -40801,7 +40867,7 @@
4080140867 newstack[0] = (uint64_t)stack; // backup stack location
4080240868 newstack[1] = 1234567890;
4080340869 newstack[2] = base;
40804- newstack[3] = 3454LLU;
40870+ newstack[3] = 3460LLU;
4080540871 stack = newstack;
4080640872 // set stack-base & callee-address
4080740873 base = 4/*deloffset*/;
@@ -40808,7 +40874,7 @@
4080840874 label = 486LLU; // ~letdef
4080940875 break;
4081040876 }
40811- case 3454LLU: // return from ~letdef to shadowlock
40877+ case 3460LLU: // return from ~letdef to shadowlock
4081240878 {
4081340879 stack = (uint64_t *)stack[0];
4081440880 // releasing toplevel container
@@ -40819,13 +40885,13 @@
4081940885 base = stack[base - 2];
4082040886 break;
4082140887 }
40822- case 3456LLU: // function popnextdel failed
40888+ case 3462LLU: // function popnextdel failed
4082340889 {
4082440890 label = stack[base - 3];
4082540891 base = stack[base - 2];
4082640892 break;
4082740893 }
40828- case 3455LLU: // popnextdel
40894+ case 3461LLU: // popnextdel
4082940895 {
4083040896 //#define arg0 0
4083140897 //#define arg1 1
@@ -40832,14 +40898,14 @@
4083240898 //#define arg2 2
4083340899 //#define arg3 3
4083440900 flippedassign(stack[base + 2]/*states*/, &stack[base + 4]);
40835- label = 3457LLU; // start to repeat
40901+ label = 3463LLU; // start to repeat
4083640902 break;
4083740903 }
40838- case 3457LLU: // repeat from here
40904+ case 3463LLU: // repeat from here
4083940905 {
4084040906 if(!stack[base + 4])
4084140907 {
40842- label = 3458LLU; // break loop
40908+ label = 3464LLU; // break loop
4084340909 break;
4084440910 }
4084540911
@@ -40849,7 +40915,7 @@
4084940915 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
4085040916 if(/*listtoelem*/0 != ((uint64_t *)(stack[base + 5]/*state*/))[0])
4085140917 {
40852- label = 3461LLU; // jump to alternative
40918+ label = 3467LLU; // jump to alternative
4085340919 break;
4085440920 }
4085540921
@@ -40861,7 +40927,7 @@
4086140927 // case
4086240928 if(/*pop*/0 != ((uint64_t *)(stack[base + 8]/*popnext*/))[0])
4086340929 {
40864- label = 3464LLU; // jump to alternative
40930+ label = 3470LLU; // jump to alternative
4086540931 break;
4086640932 }
4086740933
@@ -40870,7 +40936,7 @@
4087040936 uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t));
4087140937 if(!newstack)
4087240938 {
40873- label = 3465LLU; // throw: begin to unroll stack
40939+ label = 3471LLU; // throw: begin to unroll stack
4087440940 break;
4087540941 }
4087640942
@@ -40877,9 +40943,9 @@
4087740943 newstack[75LLU] = 9876543210LLU; // overflow-marker
4087840944 // call calldestr from popnextdel
4087940945 newstack[0] = (uint64_t)stack; // backup stack location
40880- newstack[1] = 3466LLU;
40946+ newstack[1] = 3472LLU;
4088140947 newstack[2] = base;
40882- newstack[3] = 3467LLU;
40948+ newstack[3] = 3473LLU;
4088340949 // arguments for call to calldestr
4088440950 newstack[4LLU] = stack[base + 0]/*fnid*/;
4088540951 newstack[5LLU] = stack[base + 1]/*datadefs*/;
@@ -40893,7 +40959,7 @@
4089340959 label = 1150LLU; // calldestr
4089440960 break;
4089540961 }
40896- case 3466LLU: // copy-back deleter (calldestr to popnextdel)
40962+ case 3472LLU: // copy-back deleter (calldestr to popnextdel)
4089740963 {
4089840964 uint64_t *oldstack = (uint64_t *)stack[0];
4089940965 // copy mutable arguments back from call to calldestr
@@ -40905,10 +40971,10 @@
4090540971 }
4090640972 Free(75LLU + 1, sizeof(uint64_t), stack);
4090740973 stack = oldstack;
40908- label = 3465LLU; // continue to unroll stack
40974+ label = 3471LLU; // continue to unroll stack
4090940975 break;
4091040976 }
40911- case 3467LLU: // return from calldestr to popnextdel
40977+ case 3473LLU: // return from calldestr to popnextdel
4091240978 {
4091340979 uint64_t *oldstack = (uint64_t *)stack[0];
4091440980 // copy mutable arguments back from call to calldestr
@@ -40920,19 +40986,19 @@
4092040986 }
4092140987 Free(75LLU + 1, sizeof(uint64_t), stack);
4092240988 stack = oldstack;
40923- label = 3463LLU; // case complete
40989+ label = 3469LLU; // case complete
4092440990 break;
4092540991 }
40926- case 3465LLU: // copy-back deleter (switch)
40992+ case 3471LLU: // copy-back deleter (switch)
4092740993 {
40928- label = 3462LLU; // continue to unroll stack
40994+ label = 3468LLU; // continue to unroll stack
4092940995 break;
4093040996 }
40931- case 3464LLU: // try next case
40997+ case 3470LLU: // try next case
4093240998 {
4093340999 if(/*next*/1 != ((uint64_t *)(stack[base + 8]/*popnext*/))[0])
4093441000 {
40935- label = 3468LLU; // jump to alternative
41001+ label = 3474LLU; // jump to alternative
4093641002 break;
4093741003 }
4093841004
@@ -40941,9 +41007,9 @@
4094141007 // case
4094241008 printf("%s", "\n ((struct listnode *)(");
4094341009 // call emitvaridx from popnextdel
40944- stack[base + 12LLU] = 3470LLU/*throw to this address*/;
41010+ stack[base + 12LLU] = 3476LLU/*throw to this address*/;
4094541011 stack[base + 13LLU] = base;
40946- stack[base + 14LLU] = 3471LLU;
41012+ stack[base + 14LLU] = 3477LLU;
4094741013 // arguments for call to emitvaridx
4094841014 stack[base + 15LLU] = stack[base + 11]/*previdx*/;
4094941015 // set stack-base & callee-address
@@ -40951,20 +41017,20 @@
4095141017 label = 745LLU; // emitvaridx
4095241018 break;
4095341019 }
40954- case 3470LLU: // copy-back deleter (emitvaridx to popnextdel)
41020+ case 3476LLU: // copy-back deleter (emitvaridx to popnextdel)
4095541021 {
4095641022 // copy mutable arguments back from call to emitvaridx
40957- label = 3469LLU; // continue to roll stack
41023+ label = 3475LLU; // continue to roll stack
4095841024 break;
4095941025 }
40960- case 3471LLU: // return from emitvaridx to popnextdel
41026+ case 3477LLU: // return from emitvaridx to popnextdel
4096141027 {
4096241028 // copy mutable arguments back from call to emitvaridx
4096341029 printf("%s", "/*previous*/))->data = ");
4096441030 // call emitvaridx from popnextdel
40965- stack[base + 12LLU] = 3472LLU/*throw to this address*/;
41031+ stack[base + 12LLU] = 3478LLU/*throw to this address*/;
4096641032 stack[base + 13LLU] = base;
40967- stack[base + 14LLU] = 3473LLU;
41033+ stack[base + 14LLU] = 3479LLU;
4096841034 // arguments for call to emitvaridx
4096941035 stack[base + 15LLU] = stack[base + 10]/*elemindex*/;
4097041036 // set stack-base & callee-address
@@ -40972,67 +41038,67 @@
4097241038 label = 745LLU; // emitvaridx
4097341039 break;
4097441040 }
40975- case 3472LLU: // copy-back deleter (emitvaridx to popnextdel)
41041+ case 3478LLU: // copy-back deleter (emitvaridx to popnextdel)
4097641042 {
4097741043 // copy mutable arguments back from call to emitvaridx
40978- label = 3469LLU; // continue to roll stack
41044+ label = 3475LLU; // continue to roll stack
4097941045 break;
4098041046 }
40981- case 3473LLU: // return from emitvaridx to popnextdel
41047+ case 3479LLU: // return from emitvaridx to popnextdel
4098241048 {
4098341049 // copy mutable arguments back from call to emitvaridx
4098441050 printf("%s", ";");
4098541051 ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
40986- label = 3463LLU; // case complete
41052+ label = 3469LLU; // case complete
4098741053 break;
4098841054 }
40989- case 3469LLU: // copy-back deleter (switch)
41055+ case 3475LLU: // copy-back deleter (switch)
4099041056 {
4099141057 ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
40992- label = 3462LLU; // continue to unroll stack
41058+ label = 3468LLU; // continue to unroll stack
4099341059 break;
4099441060 }
40995- case 3468LLU: // try next case
41061+ case 3474LLU: // try next case
4099641062 {
4099741063 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4099841064 exit(-1);
4099941065 }
41000- case 3463LLU: // completed switch
41066+ case 3469LLU: // completed switch
4100141067 {
4100241068 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
4100341069 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
4100441070 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
4100541071 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
41006- label = 3460LLU; // case complete
41072+ label = 3466LLU; // case complete
4100741073 break;
4100841074 }
41009- case 3462LLU: // copy-back deleter (switch)
41075+ case 3468LLU: // copy-back deleter (switch)
4101041076 {
4101141077 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
4101241078 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
4101341079 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
4101441080 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
41015- label = 3459LLU; // continue to unroll stack
41081+ label = 3465LLU; // continue to unroll stack
4101641082 break;
4101741083 }
41018- case 3461LLU: // try next case
41084+ case 3467LLU: // try next case
4101941085 {
4102041086 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4102141087 exit(-1);
4102241088 }
41023- case 3460LLU: // completed switch
41089+ case 3466LLU: // completed switch
4102441090 {
4102541091 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
41026- label = 3457LLU; // repeat
41092+ label = 3463LLU; // repeat
4102741093 break;
4102841094 }
41029- case 3459LLU: // copy-back deleter for while next
41095+ case 3465LLU: // copy-back deleter for while next
4103041096 {
4103141097 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
41032- label = 3456LLU; // continue to unroll stack
41098+ label = 3462LLU; // continue to unroll stack
4103341099 break;
4103441100 }
41035- case 3458LLU: // loop finished
41101+ case 3464LLU: // loop finished
4103641102 {
4103741103 // return from popnextdel
4103841104 label = stack[base - 1];
@@ -41039,13 +41105,13 @@
4103941105 base = stack[base - 2];
4104041106 break;
4104141107 }
41042- case 3475LLU: // function procblock failed
41108+ case 3481LLU: // function procblock failed
4104341109 {
4104441110 label = stack[base - 3];
4104541111 base = stack[base - 2];
4104641112 break;
4104741113 }
41048- case 3474LLU: // procblock
41114+ case 3480LLU: // procblock
4104941115 {
4105041116 //#define arg0 0
4105141117 //#define arg1 1
@@ -41065,49 +41131,49 @@
4106541131 //#define arg15 15
4106641132 //#define arg16 16
4106741133 //#define arg17 17
41068- label = 3477LLU; // skip deleter
41134+ label = 3483LLU; // skip deleter
4106941135 break;
4107041136 }
41071- case 3476LLU: // deleter
41137+ case 3482LLU: // deleter
4107241138 {
4107341139 // throw from procblock
4107441140 if(!stack[base + 18])
4107541141 {
41076- label = 3475LLU; // skip, variable already deleted/unscoped
41142+ label = 3481LLU; // skip, variable already deleted/unscoped
4107741143 break;
4107841144 }
41079- label = 3475LLU; // continue unrolling stack, delete next variable
41145+ label = 3481LLU; // continue unrolling stack, delete next variable
4108041146 break;
4108141147 }
41082- case 3477LLU: // skipped deleter
41148+ case 3483LLU: // skipped deleter
4108341149 {
4108441150 stack[base + 18] = stack[base + 13]/*varcount*/;
41085- label = 3479LLU; // skip deleter
41151+ label = 3485LLU; // skip deleter
4108641152 break;
4108741153 }
41088- case 3478LLU: // deleter
41154+ case 3484LLU: // deleter
4108941155 {
4109041156 // throw from procblock
4109141157 if(!stack[base + 19])
4109241158 {
41093- label = 3476LLU; // skip, variable already deleted/unscoped
41159+ label = 3482LLU; // skip, variable already deleted/unscoped
4109441160 break;
4109541161 }
41096- label = 3476LLU; // continue unrolling stack, delete next variable
41162+ label = 3482LLU; // continue unrolling stack, delete next variable
4109741163 break;
4109841164 }
41099- case 3479LLU: // skipped deleter
41165+ case 3485LLU: // skipped deleter
4110041166 {
4110141167 stack[base + 19] = stack[base + 14]/*lookahead*/;
41102- label = 3481LLU; // skip deleter
41168+ label = 3487LLU; // skip deleter
4110341169 break;
4110441170 }
41105- case 3480LLU: // deleter
41171+ case 3486LLU: // deleter
4110641172 {
4110741173 // throw from procblock
4110841174 if(!stack[base + 20])
4110941175 {
41110- label = 3478LLU; // skip, variable already deleted/unscoped
41176+ label = 3484LLU; // skip, variable already deleted/unscoped
4111141177 break;
4111241178 }
4111341179
@@ -41116,7 +41182,7 @@
4111641182 newstack[0] = (uint64_t)stack; // backup stack location
4111741183 newstack[1] = 1234567890;
4111841184 newstack[2] = base;
41119- newstack[3] = 3482LLU;
41185+ newstack[3] = 3488LLU;
4112041186 stack = newstack;
4112141187 // set stack-base & callee-address
4112241188 base = 4/*deloffset*/;
@@ -41123,21 +41189,21 @@
4112341189 label = 562LLU; // ~scope
4112441190 break;
4112541191 }
41126- case 3482LLU: // return from ~scope to procblock
41192+ case 3488LLU: // return from ~scope to procblock
4112741193 {
4112841194 stack = (uint64_t *)stack[0];
4112941195 // releasing toplevel container
4113041196 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 20] - sizeof(uint64_t) * 4));
4113141197
41132- label = 3478LLU; // continue unrolling stack, delete next variable
41198+ label = 3484LLU; // continue unrolling stack, delete next variable
4113341199 break;
4113441200 }
41135- case 3481LLU: // skipped deleter
41201+ case 3487LLU: // skipped deleter
4113641202 {
4113741203 // call linkscope from procblock
41138- stack[base + 21LLU] = 3483LLU/*throw to this address*/;
41204+ stack[base + 21LLU] = 3489LLU/*throw to this address*/;
4113941205 stack[base + 22LLU] = base;
41140- stack[base + 23LLU] = 3484LLU;
41206+ stack[base + 23LLU] = 3490LLU;
4114141207 // arguments for call to linkscope
4114241208 stack[base + 25LLU] = stack[base + 3]/*scope*/;
4114341209 // set stack-base & callee-address
@@ -41145,13 +41211,13 @@
4114541211 label = 589LLU; // linkscope
4114641212 break;
4114741213 }
41148- case 3483LLU: // copy-back deleter (linkscope to procblock)
41214+ case 3489LLU: // copy-back deleter (linkscope to procblock)
4114941215 {
4115041216 // copy mutable arguments back from call to linkscope
41151- label = 3478LLU; // continue to roll stack
41217+ label = 3484LLU; // continue to roll stack
4115241218 break;
4115341219 }
41154- case 3484LLU: // return from linkscope to procblock
41220+ case 3490LLU: // return from linkscope to procblock
4115541221 {
4115641222 // copy mutable arguments back from call to linkscope
4115741223 // copy back results provided by call to linkscope
@@ -41170,22 +41236,22 @@
4117041236 /*scopes*/stack[base + 2] = (uint64_t)list;
4117141237 MOVE(&list->data, &stack[base + 20]/*newscope*/);
4117241238 }
41173- label = 3485LLU; // start to repeat
41239+ label = 3491LLU; // start to repeat
4117441240 break;
4117541241 }
41176- case 3485LLU: // repeat from here
41242+ case 3491LLU: // repeat from here
4117741243 {
4117841244 if(stack[base + 19]/*lookahead*/ > 0xFF)
4117941245 {
41180- label = 3486LLU; // break loop
41246+ label = 3492LLU; // break loop
4118141247 break;
4118241248 }
4118341249
4118441250 // loop body
4118541251 // call skipwscmnt from procblock
41186- stack[base + 20LLU] = 3487LLU/*throw to this address*/;
41252+ stack[base + 20LLU] = 3493LLU/*throw to this address*/;
4118741253 stack[base + 21LLU] = base;
41188- stack[base + 22LLU] = 3488LLU;
41254+ stack[base + 22LLU] = 3494LLU;
4118941255 // arguments for call to skipwscmnt
4119041256 stack[base + 24LLU] = stack[base + 19]/*lookahead*/;
4119141257 // set stack-base & callee-address
@@ -41193,38 +41259,38 @@
4119341259 label = 18446744073709551580LLU; // skipwscmnt
4119441260 break;
4119541261 }
41196- case 3487LLU: // copy-back deleter (skipwscmnt to procblock)
41262+ case 3493LLU: // copy-back deleter (skipwscmnt to procblock)
4119741263 {
4119841264 // copy mutable arguments back from call to skipwscmnt
41199- label = 3478LLU; // continue to roll stack
41265+ label = 3484LLU; // continue to roll stack
4120041266 break;
4120141267 }
41202- case 3488LLU: // return from skipwscmnt to procblock
41268+ case 3494LLU: // return from skipwscmnt to procblock
4120341269 {
4120441270 // copy mutable arguments back from call to skipwscmnt
4120541271 // copy back results provided by call to skipwscmnt
4120641272 stack[base + 19] = stack[base + 23LLU];
41207- label = 3490LLU; // skip deleter
41273+ label = 3496LLU; // skip deleter
4120841274 break;
4120941275 }
41210- case 3489LLU: // deleter
41276+ case 3495LLU: // deleter
4121141277 {
4121241278 // throw from procblock
4121341279 if(!stack[base + 20])
4121441280 {
41215- label = 3478LLU; // skip, variable already deleted/unscoped
41281+ label = 3484LLU; // skip, variable already deleted/unscoped
4121641282 break;
4121741283 }
41218- label = 3478LLU; // continue unrolling stack, delete next variable
41284+ label = 3484LLU; // continue unrolling stack, delete next variable
4121941285 break;
4122041286 }
41221- case 3490LLU: // skipped deleter
41287+ case 3496LLU: // skipped deleter
4122241288 {
4122341289 stack[base + 20] = 0;
4122441290 // call equ from procblock
41225- stack[base + 21LLU] = 3491LLU/*throw to this address*/;
41291+ stack[base + 21LLU] = 3497LLU/*throw to this address*/;
4122641292 stack[base + 22LLU] = base;
41227- stack[base + 23LLU] = 3492LLU;
41293+ stack[base + 23LLU] = 3498LLU;
4122841294 // arguments for call to equ
4122941295 stack[base + 25LLU] = stack[base + 19]/*lookahead*/;
4123041296 stack[base + 26LLU] = 125LLU;
@@ -41233,13 +41299,13 @@
4123341299 label = 18446744073709551600LLU; // equ
4123441300 break;
4123541301 }
41236- case 3491LLU: // copy-back deleter (equ to procblock)
41302+ case 3497LLU: // copy-back deleter (equ to procblock)
4123741303 {
4123841304 // copy mutable arguments back from call to equ
41239- label = 3489LLU; // continue to roll stack
41305+ label = 3495LLU; // continue to roll stack
4124041306 break;
4124141307 }
41242- case 3492LLU: // return from equ to procblock
41308+ case 3498LLU: // return from equ to procblock
4124341309 {
4124441310 // copy mutable arguments back from call to equ
4124541311 // copy back results provided by call to equ
@@ -41246,7 +41312,7 @@
4124641312 stack[base + 20] = stack[base + 24LLU];
4124741313 if(!stack[base + 20]/*isequal*/)
4124841314 {
41249- label = 3493LLU; // jump to alternative
41315+ label = 3499LLU; // jump to alternative
4125041316 break;
4125141317 }
4125241318
@@ -41253,7 +41319,7 @@
4125341319 // consequent
4125441320 if(!stack[base + 4]/*blkresults*/)
4125541321 {
41256- label = 3495LLU; // jump to alternative
41322+ label = 3501LLU; // jump to alternative
4125741323 break;
4125841324 }
4125941325
@@ -41260,9 +41326,9 @@
4126041326 // consequent
4126141327 fprintf(stderr, "%s", "in function ");
4126241328 // call reportid from procblock
41263- stack[base + 21LLU] = 3497LLU/*throw to this address*/;
41329+ stack[base + 21LLU] = 3503LLU/*throw to this address*/;
4126441330 stack[base + 22LLU] = base;
41265- stack[base + 23LLU] = 3498LLU;
41331+ stack[base + 23LLU] = 3504LLU;
4126641332 // arguments for call to reportid
4126741333 stack[base + 24LLU] = stack[base + 8]/*fnid*/;
4126841334 // set stack-base & callee-address
@@ -41270,35 +41336,35 @@
4127041336 label = 18446744073709551586LLU; // reportid
4127141337 break;
4127241338 }
41273- case 3497LLU: // copy-back deleter (reportid to procblock)
41339+ case 3503LLU: // copy-back deleter (reportid to procblock)
4127441340 {
4127541341 // copy mutable arguments back from call to reportid
41276- label = 3489LLU; // continue to roll stack
41342+ label = 3495LLU; // continue to roll stack
4127741343 break;
4127841344 }
41279- case 3498LLU: // return from reportid to procblock
41345+ case 3504LLU: // return from reportid to procblock
4128041346 {
4128141347 // copy mutable arguments back from call to reportid
4128241348 fprintf(stderr, "%s", ": missing return\n");
4128341349 {
41284- label = 3489LLU; // throw: begin to unroll stack
41350+ label = 3495LLU; // throw: begin to unroll stack
4128541351 break;
4128641352 }
4128741353
41288- label = 3496LLU; // consequent complete
41354+ label = 3502LLU; // consequent complete
4128941355 break;
4129041356 }
41291- case 3495LLU: // alternative
41357+ case 3501LLU: // alternative
4129241358 {
41293- label = 3496LLU; // alternative complete
41359+ label = 3502LLU; // alternative complete
4129441360 break;
4129541361 }
41296- case 3496LLU: // completed if-then-else
41362+ case 3502LLU: // completed if-then-else
4129741363 {
4129841364 // call EOSbyte from procblock
41299- stack[base + 21LLU] = 3499LLU/*throw to this address*/;
41365+ stack[base + 21LLU] = 3505LLU/*throw to this address*/;
4130041366 stack[base + 22LLU] = base;
41301- stack[base + 23LLU] = 3500LLU;
41367+ stack[base + 23LLU] = 3506LLU;
4130241368 // arguments for call to EOSbyte
4130341369 // set stack-base & callee-address
4130441370 base += 24LLU;
@@ -41305,26 +41371,26 @@
4130541371 label = 77LLU; // EOSbyte
4130641372 break;
4130741373 }
41308- case 3499LLU: // copy-back deleter (EOSbyte to procblock)
41374+ case 3505LLU: // copy-back deleter (EOSbyte to procblock)
4130941375 {
4131041376 // copy mutable arguments back from call to EOSbyte
41311- label = 3489LLU; // continue to roll stack
41377+ label = 3495LLU; // continue to roll stack
4131241378 break;
4131341379 }
41314- case 3500LLU: // return from EOSbyte to procblock
41380+ case 3506LLU: // return from EOSbyte to procblock
4131541381 {
4131641382 // copy mutable arguments back from call to EOSbyte
4131741383 // copy back results provided by call to EOSbyte
4131841384 stack[base + 19] = stack[base + 24LLU];
41319- label = 3494LLU; // consequent complete
41385+ label = 3500LLU; // consequent complete
4132041386 break;
4132141387 }
41322- case 3493LLU: // alternative
41388+ case 3499LLU: // alternative
4132341389 {
4132441390 // call ParseToken from procblock
41325- stack[base + 21LLU] = 3501LLU/*throw to this address*/;
41391+ stack[base + 21LLU] = 3507LLU/*throw to this address*/;
4132641392 stack[base + 22LLU] = base;
41327- stack[base + 23LLU] = 3502LLU;
41393+ stack[base + 23LLU] = 3508LLU;
4132841394 // arguments for call to ParseToken
4132941395 stack[base + 26LLU] = stack[base + 19]/*lookahead*/;
4133041396 // set stack-base & callee-address
@@ -41332,14 +41398,14 @@
4133241398 label = 3LLU; // ParseToken
4133341399 break;
4133441400 }
41335- case 3501LLU: // copy-back deleter (ParseToken to procblock)
41401+ case 3507LLU: // copy-back deleter (ParseToken to procblock)
4133641402 {
4133741403 // copy mutable arguments back from call to ParseToken
4133841404 stack[base + 19]/*lookahead*/ = stack[base + 26LLU];
41339- label = 3489LLU; // continue to roll stack
41405+ label = 3495LLU; // continue to roll stack
4134041406 break;
4134141407 }
41342- case 3502LLU: // return from ParseToken to procblock
41408+ case 3508LLU: // return from ParseToken to procblock
4134341409 {
4134441410 // copy mutable arguments back from call to ParseToken
4134541411 stack[base + 19]/*lookahead*/ = stack[base + 26LLU];
@@ -41347,9 +41413,9 @@
4134741413 stack[base + 15] = stack[base + 24LLU];
4134841414 stack[base + 16] = stack[base + 25LLU];
4134941415 // call equ from procblock
41350- stack[base + 21LLU] = 3503LLU/*throw to this address*/;
41416+ stack[base + 21LLU] = 3509LLU/*throw to this address*/;
4135141417 stack[base + 22LLU] = base;
41352- stack[base + 23LLU] = 3504LLU;
41418+ stack[base + 23LLU] = 3510LLU;
4135341419 // arguments for call to equ
4135441420 stack[base + 25LLU] = stack[base + 15]/*variant*/;
4135541421 stack[base + 26LLU] = 0LLU;
@@ -41358,13 +41424,13 @@
4135841424 label = 18446744073709551600LLU; // equ
4135941425 break;
4136041426 }
41361- case 3503LLU: // copy-back deleter (equ to procblock)
41427+ case 3509LLU: // copy-back deleter (equ to procblock)
4136241428 {
4136341429 // copy mutable arguments back from call to equ
41364- label = 3489LLU; // continue to roll stack
41430+ label = 3495LLU; // continue to roll stack
4136541431 break;
4136641432 }
41367- case 3504LLU: // return from equ to procblock
41433+ case 3510LLU: // return from equ to procblock
4136841434 {
4136941435 // copy mutable arguments back from call to equ
4137041436 // copy back results provided by call to equ
@@ -41371,15 +41437,15 @@
4137141437 stack[base + 20] = stack[base + 24LLU];
4137241438 if(!stack[base + 20]/*isequal*/)
4137341439 {
41374- label = 3505LLU; // jump to alternative
41440+ label = 3511LLU; // jump to alternative
4137541441 break;
4137641442 }
4137741443
4137841444 // consequent
4137941445 // call equ from procblock
41380- stack[base + 21LLU] = 3507LLU/*throw to this address*/;
41446+ stack[base + 21LLU] = 3513LLU/*throw to this address*/;
4138141447 stack[base + 22LLU] = base;
41382- stack[base + 23LLU] = 3508LLU;
41448+ stack[base + 23LLU] = 3514LLU;
4138341449 // arguments for call to equ
4138441450 stack[base + 25LLU] = stack[base + 16]/*content*/;
4138541451 stack[base + 26LLU] = 123LLU;
@@ -41388,13 +41454,13 @@
4138841454 label = 18446744073709551600LLU; // equ
4138941455 break;
4139041456 }
41391- case 3507LLU: // copy-back deleter (equ to procblock)
41457+ case 3513LLU: // copy-back deleter (equ to procblock)
4139241458 {
4139341459 // copy mutable arguments back from call to equ
41394- label = 3489LLU; // continue to roll stack
41460+ label = 3495LLU; // continue to roll stack
4139541461 break;
4139641462 }
41397- case 3508LLU: // return from equ to procblock
41463+ case 3514LLU: // return from equ to procblock
4139841464 {
4139941465 // copy mutable arguments back from call to equ
4140041466 // copy back results provided by call to equ
@@ -41401,31 +41467,31 @@
4140141467 stack[base + 20] = stack[base + 24LLU];
4140241468 if(!stack[base + 20]/*isequal*/)
4140341469 {
41404- label = 3509LLU; // jump to alternative
41470+ label = 3515LLU; // jump to alternative
4140541471 break;
4140641472 }
4140741473
4140841474 // consequent
41409- label = 3512LLU; // skip deleter
41475+ label = 3518LLU; // skip deleter
4141041476 break;
4141141477 }
41412- case 3511LLU: // deleter
41478+ case 3517LLU: // deleter
4141341479 {
4141441480 // throw from procblock
4141541481 if(!stack[base + 21])
4141641482 {
41417- label = 3489LLU; // skip, variable already deleted/unscoped
41483+ label = 3495LLU; // skip, variable already deleted/unscoped
4141841484 break;
4141941485 }
4142041486 // delete list
41421- label = 3513LLU; // start to repeat
41487+ label = 3519LLU; // start to repeat
4142241488 break;
4142341489 }
41424- case 3513LLU: // repeat from here
41490+ case 3519LLU: // repeat from here
4142541491 {
4142641492 if(!stack[base + 21])
4142741493 {
41428- label = 3514LLU; // break loop
41494+ label = 3520LLU; // break loop
4142941495 break;
4143041496 }
4143141497
@@ -41436,7 +41502,7 @@
4143641502 newstack[0] = (uint64_t)stack; // backup stack location
4143741503 newstack[1] = 1234567890;
4143841504 newstack[2] = base;
41439- newstack[3] = 3515LLU;
41505+ newstack[3] = 3521LLU;
4144041506 stack = newstack;
4144141507 // set stack-base & callee-address
4144241508 base = 4/*deloffset*/;
@@ -41443,7 +41509,7 @@
4144341509 label = 399LLU; // ~typeidx
4144441510 break;
4144541511 }
41446- case 3515LLU: // return from ~typeidx to procblock
41512+ case 3521LLU: // return from ~typeidx to procblock
4144741513 {
4144841514 stack = (uint64_t *)stack[0];
4144941515 // releasing toplevel container
@@ -41454,21 +41520,21 @@
4145441520 stack[base + 21] = (uint64_t)list->next;
4145541521 Free(1, sizeof(struct listnode), list);
4145641522 }
41457- label = 3513LLU; // repeat
41523+ label = 3519LLU; // repeat
4145841524 break;
4145941525 }
41460- case 3514LLU: // loop finished
41526+ case 3520LLU: // loop finished
4146141527 {
41462- label = 3489LLU; // continue unrolling stack, delete next variable
41528+ label = 3495LLU; // continue unrolling stack, delete next variable
4146341529 break;
4146441530 }
41465- case 3512LLU: // skipped deleter
41531+ case 3518LLU: // skipped deleter
4146641532 {
4146741533 stack[base + 21] = 0;
4146841534 uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t));
4146941535 if(!newstack)
4147041536 {
41471- label = 3511LLU; // throw: begin to unroll stack
41537+ label = 3517LLU; // throw: begin to unroll stack
4147241538 break;
4147341539 }
4147441540
@@ -41475,9 +41541,9 @@
4147541541 newstack[160LLU] = 9876543210LLU; // overflow-marker
4147641542 // call procblock from procblock
4147741543 newstack[0] = (uint64_t)stack; // backup stack location
41478- newstack[1] = 3516LLU;
41544+ newstack[1] = 3522LLU;
4147941545 newstack[2] = base;
41480- newstack[3] = 3517LLU;
41546+ newstack[3] = 3523LLU;
4148141547 // arguments for call to procblock
4148241548 newstack[4LLU] = stack[base + 0]/*fndefs*/;
4148341549 newstack[5LLU] = stack[base + 1]/*datadefs*/;
@@ -41500,10 +41566,10 @@
4150041566 stack = newstack;
4150141567 // set stack-base & callee-address
4150241568 base = 4/*deloffset*/;
41503- label = 3474LLU; // procblock
41569+ label = 3480LLU; // procblock
4150441570 break;
4150541571 }
41506- case 3516LLU: // copy-back deleter (procblock to procblock)
41572+ case 3522LLU: // copy-back deleter (procblock to procblock)
4150741573 {
4150841574 uint64_t *oldstack = (uint64_t *)stack[0];
4150941575 // copy mutable arguments back from call to procblock
@@ -41520,10 +41586,10 @@
4152041586 }
4152141587 Free(160LLU + 1, sizeof(uint64_t), stack);
4152241588 stack = oldstack;
41523- label = 3511LLU; // continue to unroll stack
41589+ label = 3517LLU; // continue to unroll stack
4152441590 break;
4152541591 }
41526- case 3517LLU: // return from procblock to procblock
41592+ case 3523LLU: // return from procblock to procblock
4152741593 {
4152841594 uint64_t *oldstack = (uint64_t *)stack[0];
4152941595 // copy mutable arguments back from call to procblock
@@ -41541,14 +41607,14 @@
4154141607 Free(160LLU + 1, sizeof(uint64_t), stack);
4154241608 stack = oldstack;
4154341609 // delete list
41544- label = 3518LLU; // start to repeat
41610+ label = 3524LLU; // start to repeat
4154541611 break;
4154641612 }
41547- case 3518LLU: // repeat from here
41613+ case 3524LLU: // repeat from here
4154841614 {
4154941615 if(!stack[base + 21])
4155041616 {
41551- label = 3519LLU; // break loop
41617+ label = 3525LLU; // break loop
4155241618 break;
4155341619 }
4155441620
@@ -41559,7 +41625,7 @@
4155941625 newstack[0] = (uint64_t)stack; // backup stack location
4156041626 newstack[1] = 1234567890;
4156141627 newstack[2] = base;
41562- newstack[3] = 3520LLU;
41628+ newstack[3] = 3526LLU;
4156341629 stack = newstack;
4156441630 // set stack-base & callee-address
4156541631 base = 4/*deloffset*/;
@@ -41566,7 +41632,7 @@
4156641632 label = 399LLU; // ~typeidx
4156741633 break;
4156841634 }
41569- case 3520LLU: // return from ~typeidx to procblock
41635+ case 3526LLU: // return from ~typeidx to procblock
4157041636 {
4157141637 stack = (uint64_t *)stack[0];
4157241638 // releasing toplevel container
@@ -41577,20 +41643,20 @@
4157741643 stack[base + 21] = (uint64_t)list->next;
4157841644 Free(1, sizeof(struct listnode), list);
4157941645 }
41580- label = 3518LLU; // repeat
41646+ label = 3524LLU; // repeat
4158141647 break;
4158241648 }
41583- case 3519LLU: // loop finished
41649+ case 3525LLU: // loop finished
4158441650 {
41585- label = 3510LLU; // consequent complete
41651+ label = 3516LLU; // consequent complete
4158641652 break;
4158741653 }
41588- case 3509LLU: // alternative
41654+ case 3515LLU: // alternative
4158941655 {
4159041656 // call equ from procblock
41591- stack[base + 21LLU] = 3521LLU/*throw to this address*/;
41657+ stack[base + 21LLU] = 3527LLU/*throw to this address*/;
4159241658 stack[base + 22LLU] = base;
41593- stack[base + 23LLU] = 3522LLU;
41659+ stack[base + 23LLU] = 3528LLU;
4159441660 // arguments for call to equ
4159541661 stack[base + 25LLU] = stack[base + 16]/*content*/;
4159641662 stack[base + 26LLU] = 96LLU;
@@ -41599,13 +41665,13 @@
4159941665 label = 18446744073709551600LLU; // equ
4160041666 break;
4160141667 }
41602- case 3521LLU: // copy-back deleter (equ to procblock)
41668+ case 3527LLU: // copy-back deleter (equ to procblock)
4160341669 {
4160441670 // copy mutable arguments back from call to equ
41605- label = 3489LLU; // continue to roll stack
41671+ label = 3495LLU; // continue to roll stack
4160641672 break;
4160741673 }
41608- case 3522LLU: // return from equ to procblock
41674+ case 3528LLU: // return from equ to procblock
4160941675 {
4161041676 // copy mutable arguments back from call to equ
4161141677 // copy back results provided by call to equ
@@ -41612,15 +41678,15 @@
4161241678 stack[base + 20] = stack[base + 24LLU];
4161341679 if(!stack[base + 20]/*isequal*/)
4161441680 {
41615- label = 3523LLU; // jump to alternative
41681+ label = 3529LLU; // jump to alternative
4161641682 break;
4161741683 }
4161841684
4161941685 // consequent
4162041686 // call verbatim from procblock
41621- stack[base + 21LLU] = 3525LLU/*throw to this address*/;
41687+ stack[base + 21LLU] = 3531LLU/*throw to this address*/;
4162241688 stack[base + 22LLU] = base;
41623- stack[base + 23LLU] = 3526LLU;
41689+ stack[base + 23LLU] = 3532LLU;
4162441690 // arguments for call to verbatim
4162541691 stack[base + 24LLU] = stack[base + 2]/*scopes*/;
4162641692 stack[base + 25LLU] = stack[base + 3]/*scope*/;
@@ -41627,29 +41693,29 @@
4162741693 stack[base + 26LLU] = stack[base + 19]/*lookahead*/;
4162841694 // set stack-base & callee-address
4162941695 base += 24LLU;
41630- label = 3290LLU; // verbatim
41696+ label = 3296LLU; // verbatim
4163141697 break;
4163241698 }
41633- case 3525LLU: // copy-back deleter (verbatim to procblock)
41699+ case 3531LLU: // copy-back deleter (verbatim to procblock)
4163441700 {
4163541701 // copy mutable arguments back from call to verbatim
4163641702 stack[base + 19]/*lookahead*/ = stack[base + 26LLU];
41637- label = 3489LLU; // continue to roll stack
41703+ label = 3495LLU; // continue to roll stack
4163841704 break;
4163941705 }
41640- case 3526LLU: // return from verbatim to procblock
41706+ case 3532LLU: // return from verbatim to procblock
4164141707 {
4164241708 // copy mutable arguments back from call to verbatim
4164341709 stack[base + 19]/*lookahead*/ = stack[base + 26LLU];
41644- label = 3524LLU; // consequent complete
41710+ label = 3530LLU; // consequent complete
4164541711 break;
4164641712 }
41647- case 3523LLU: // alternative
41713+ case 3529LLU: // alternative
4164841714 {
4164941715 // call equ from procblock
41650- stack[base + 21LLU] = 3527LLU/*throw to this address*/;
41716+ stack[base + 21LLU] = 3533LLU/*throw to this address*/;
4165141717 stack[base + 22LLU] = base;
41652- stack[base + 23LLU] = 3528LLU;
41718+ stack[base + 23LLU] = 3534LLU;
4165341719 // arguments for call to equ
4165441720 stack[base + 25LLU] = stack[base + 16]/*content*/;
4165541721 stack[base + 26LLU] = 40LLU;
@@ -41658,13 +41724,13 @@
4165841724 label = 18446744073709551600LLU; // equ
4165941725 break;
4166041726 }
41661- case 3527LLU: // copy-back deleter (equ to procblock)
41727+ case 3533LLU: // copy-back deleter (equ to procblock)
4166241728 {
4166341729 // copy mutable arguments back from call to equ
41664- label = 3489LLU; // continue to roll stack
41730+ label = 3495LLU; // continue to roll stack
4166541731 break;
4166641732 }
41667- case 3528LLU: // return from equ to procblock
41733+ case 3534LLU: // return from equ to procblock
4166841734 {
4166941735 // copy mutable arguments back from call to equ
4167041736 // copy back results provided by call to equ
@@ -41671,15 +41737,15 @@
4167141737 stack[base + 20] = stack[base + 24LLU];
4167241738 if(!stack[base + 20]/*isequal*/)
4167341739 {
41674- label = 3529LLU; // jump to alternative
41740+ label = 3535LLU; // jump to alternative
4167541741 break;
4167641742 }
4167741743
4167841744 // consequent
4167941745 // call PROCCALL from procblock
41680- stack[base + 21LLU] = 3531LLU/*throw to this address*/;
41746+ stack[base + 21LLU] = 3537LLU/*throw to this address*/;
4168141747 stack[base + 22LLU] = base;
41682- stack[base + 23LLU] = 3532LLU;
41748+ stack[base + 23LLU] = 3538LLU;
4168341749 // arguments for call to PROCCALL
4168441750 stack[base + 24LLU] = stack[base + 0]/*fndefs*/;
4168541751 stack[base + 25LLU] = stack[base + 2]/*scopes*/;
@@ -41702,7 +41768,7 @@
4170241768 label = 2966LLU; // PROCCALL
4170341769 break;
4170441770 }
41705- case 3531LLU: // copy-back deleter (PROCCALL to procblock)
41771+ case 3537LLU: // copy-back deleter (PROCCALL to procblock)
4170641772 {
4170741773 // copy mutable arguments back from call to PROCCALL
4170841774 stack[base + 17]/*label*/ = stack[base + 39LLU];
@@ -41710,10 +41776,10 @@
4171041776 stack[base + 15]/*variant*/ = stack[base + 37LLU];
4171141777 stack[base + 19]/*lookahead*/ = stack[base + 36LLU];
4171241778 stack[base + 12]/*fnmaxcount*/ = stack[base + 35LLU];
41713- label = 3489LLU; // continue to roll stack
41779+ label = 3495LLU; // continue to roll stack
4171441780 break;
4171541781 }
41716- case 3532LLU: // return from PROCCALL to procblock
41782+ case 3538LLU: // return from PROCCALL to procblock
4171741783 {
4171841784 // copy mutable arguments back from call to PROCCALL
4171941785 stack[base + 17]/*label*/ = stack[base + 39LLU];
@@ -41722,9 +41788,9 @@
4172241788 stack[base + 19]/*lookahead*/ = stack[base + 36LLU];
4172341789 stack[base + 12]/*fnmaxcount*/ = stack[base + 35LLU];
4172441790 // call DELIMITER from procblock
41725- stack[base + 21LLU] = 3533LLU/*throw to this address*/;
41791+ stack[base + 21LLU] = 3539LLU/*throw to this address*/;
4172641792 stack[base + 22LLU] = base;
41727- stack[base + 23LLU] = 3534LLU;
41793+ stack[base + 23LLU] = 3540LLU;
4172841794 // arguments for call to DELIMITER
4172941795 stack[base + 24LLU] = stack[base + 8]/*fnid*/;
4173041796 stack[base + 25LLU] = stack[base + 19]/*lookahead*/;
@@ -41733,27 +41799,27 @@
4173341799 label = 17LLU; // DELIMITER
4173441800 break;
4173541801 }
41736- case 3533LLU: // copy-back deleter (DELIMITER to procblock)
41802+ case 3539LLU: // copy-back deleter (DELIMITER to procblock)
4173741803 {
4173841804 // copy mutable arguments back from call to DELIMITER
4173941805 stack[base + 19]/*lookahead*/ = stack[base + 25LLU];
41740- label = 3489LLU; // continue to roll stack
41806+ label = 3495LLU; // continue to roll stack
4174141807 break;
4174241808 }
41743- case 3534LLU: // return from DELIMITER to procblock
41809+ case 3540LLU: // return from DELIMITER to procblock
4174441810 {
4174541811 // copy mutable arguments back from call to DELIMITER
4174641812 stack[base + 19]/*lookahead*/ = stack[base + 25LLU];
41747- label = 3530LLU; // consequent complete
41813+ label = 3536LLU; // consequent complete
4174841814 break;
4174941815 }
41750- case 3529LLU: // alternative
41816+ case 3535LLU: // alternative
4175141817 {
4175241818 fprintf(stderr, "%s", "parsing block unexpected token ");
4175341819 // call reporttok from procblock
41754- stack[base + 21LLU] = 3535LLU/*throw to this address*/;
41820+ stack[base + 21LLU] = 3541LLU/*throw to this address*/;
4175541821 stack[base + 22LLU] = base;
41756- stack[base + 23LLU] = 3536LLU;
41822+ stack[base + 23LLU] = 3542LLU;
4175741823 // arguments for call to reporttok
4175841824 stack[base + 24LLU] = stack[base + 15]/*variant*/;
4175941825 stack[base + 25LLU] = stack[base + 16]/*content*/;
@@ -41762,45 +41828,45 @@
4176241828 label = 18446744073709551582LLU; // reporttok
4176341829 break;
4176441830 }
41765- case 3535LLU: // copy-back deleter (reporttok to procblock)
41831+ case 3541LLU: // copy-back deleter (reporttok to procblock)
4176641832 {
4176741833 // copy mutable arguments back from call to reporttok
41768- label = 3489LLU; // continue to roll stack
41834+ label = 3495LLU; // continue to roll stack
4176941835 break;
4177041836 }
41771- case 3536LLU: // return from reporttok to procblock
41837+ case 3542LLU: // return from reporttok to procblock
4177241838 {
4177341839 // copy mutable arguments back from call to reporttok
4177441840 fprintf(stderr, "%s", "\n");
4177541841 {
41776- label = 3489LLU; // throw: begin to unroll stack
41842+ label = 3495LLU; // throw: begin to unroll stack
4177741843 break;
4177841844 }
4177941845
41780- label = 3530LLU; // alternative complete
41846+ label = 3536LLU; // alternative complete
4178141847 break;
4178241848 }
41783- case 3530LLU: // completed if-then-else
41849+ case 3536LLU: // completed if-then-else
4178441850 {
41785- label = 3524LLU; // alternative complete
41851+ label = 3530LLU; // alternative complete
4178641852 break;
4178741853 }
41788- case 3524LLU: // completed if-then-else
41854+ case 3530LLU: // completed if-then-else
4178941855 {
41790- label = 3510LLU; // alternative complete
41856+ label = 3516LLU; // alternative complete
4179141857 break;
4179241858 }
41793- case 3510LLU: // completed if-then-else
41859+ case 3516LLU: // completed if-then-else
4179441860 {
41795- label = 3506LLU; // consequent complete
41861+ label = 3512LLU; // consequent complete
4179641862 break;
4179741863 }
41798- case 3505LLU: // alternative
41864+ case 3511LLU: // alternative
4179941865 {
4180041866 // call equ from procblock
41801- stack[base + 21LLU] = 3537LLU/*throw to this address*/;
41867+ stack[base + 21LLU] = 3543LLU/*throw to this address*/;
4180241868 stack[base + 22LLU] = base;
41803- stack[base + 23LLU] = 3538LLU;
41869+ stack[base + 23LLU] = 3544LLU;
4180441870 // arguments for call to equ
4180541871 stack[base + 25LLU] = stack[base + 15]/*variant*/;
4180641872 stack[base + 26LLU] = 4LLU;
@@ -41809,13 +41875,13 @@
4180941875 label = 18446744073709551600LLU; // equ
4181041876 break;
4181141877 }
41812- case 3537LLU: // copy-back deleter (equ to procblock)
41878+ case 3543LLU: // copy-back deleter (equ to procblock)
4181341879 {
4181441880 // copy mutable arguments back from call to equ
41815- label = 3489LLU; // continue to roll stack
41881+ label = 3495LLU; // continue to roll stack
4181641882 break;
4181741883 }
41818- case 3538LLU: // return from equ to procblock
41884+ case 3544LLU: // return from equ to procblock
4181941885 {
4182041886 // copy mutable arguments back from call to equ
4182141887 // copy back results provided by call to equ
@@ -41822,31 +41888,31 @@
4182241888 stack[base + 20] = stack[base + 24LLU];
4182341889 if(!stack[base + 20]/*isequal*/)
4182441890 {
41825- label = 3539LLU; // jump to alternative
41891+ label = 3545LLU; // jump to alternative
4182641892 break;
4182741893 }
4182841894
4182941895 // consequent
41830- label = 3542LLU; // skip deleter
41896+ label = 3548LLU; // skip deleter
4183141897 break;
4183241898 }
41833- case 3541LLU: // deleter
41899+ case 3547LLU: // deleter
4183441900 {
4183541901 // throw from procblock
4183641902 if(!stack[base + 21])
4183741903 {
41838- label = 3489LLU; // skip, variable already deleted/unscoped
41904+ label = 3495LLU; // skip, variable already deleted/unscoped
4183941905 break;
4184041906 }
41841- label = 3489LLU; // continue unrolling stack, delete next variable
41907+ label = 3495LLU; // continue unrolling stack, delete next variable
4184241908 break;
4184341909 }
41844- case 3542LLU: // skipped deleter
41910+ case 3548LLU: // skipped deleter
4184541911 {
4184641912 // call equ from procblock
41847- stack[base + 22LLU] = 3543LLU/*throw to this address*/;
41913+ stack[base + 22LLU] = 3549LLU/*throw to this address*/;
4184841914 stack[base + 23LLU] = base;
41849- stack[base + 24LLU] = 3544LLU;
41915+ stack[base + 24LLU] = 3550LLU;
4185041916 // arguments for call to equ
4185141917 stack[base + 26LLU] = stack[base + 16]/*content*/;
4185241918 stack[base + 27LLU] = 819865187908583424LLU;
@@ -41855,13 +41921,13 @@
4185541921 label = 18446744073709551600LLU; // equ
4185641922 break;
4185741923 }
41858- case 3543LLU: // copy-back deleter (equ to procblock)
41924+ case 3549LLU: // copy-back deleter (equ to procblock)
4185941925 {
4186041926 // copy mutable arguments back from call to equ
41861- label = 3489LLU; // continue to roll stack
41927+ label = 3495LLU; // continue to roll stack
4186241928 break;
4186341929 }
41864- case 3544LLU: // return from equ to procblock
41930+ case 3550LLU: // return from equ to procblock
4186541931 {
4186641932 // copy mutable arguments back from call to equ
4186741933 // copy back results provided by call to equ
@@ -41868,15 +41934,15 @@
4186841934 stack[base + 21] = stack[base + 25LLU];
4186941935 if(!stack[base + 21]/*returnflag*/)
4187041936 {
41871- label = 3545LLU; // jump to alternative
41937+ label = 3551LLU; // jump to alternative
4187241938 break;
4187341939 }
4187441940
4187541941 // consequent
4187641942 // call ParseToken from procblock
41877- stack[base + 22LLU] = 3547LLU/*throw to this address*/;
41943+ stack[base + 22LLU] = 3553LLU/*throw to this address*/;
4187841944 stack[base + 23LLU] = base;
41879- stack[base + 24LLU] = 3548LLU;
41945+ stack[base + 24LLU] = 3554LLU;
4188041946 // arguments for call to ParseToken
4188141947 stack[base + 27LLU] = stack[base + 19]/*lookahead*/;
4188241948 // set stack-base & callee-address
@@ -41884,14 +41950,14 @@
4188441950 label = 3LLU; // ParseToken
4188541951 break;
4188641952 }
41887- case 3547LLU: // copy-back deleter (ParseToken to procblock)
41953+ case 3553LLU: // copy-back deleter (ParseToken to procblock)
4188841954 {
4188941955 // copy mutable arguments back from call to ParseToken
4189041956 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
41891- label = 3541LLU; // continue to roll stack
41957+ label = 3547LLU; // continue to roll stack
4189241958 break;
4189341959 }
41894- case 3548LLU: // return from ParseToken to procblock
41960+ case 3554LLU: // return from ParseToken to procblock
4189541961 {
4189641962 // copy mutable arguments back from call to ParseToken
4189741963 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
@@ -41899,9 +41965,9 @@
4189941965 stack[base + 15] = stack[base + 25LLU];
4190041966 stack[base + 16] = stack[base + 26LLU];
4190141967 // call neq from procblock
41902- stack[base + 22LLU] = 3549LLU/*throw to this address*/;
41968+ stack[base + 22LLU] = 3555LLU/*throw to this address*/;
4190341969 stack[base + 23LLU] = base;
41904- stack[base + 24LLU] = 3550LLU;
41970+ stack[base + 24LLU] = 3556LLU;
4190541971 // arguments for call to neq
4190641972 stack[base + 26LLU] = stack[base + 16]/*content*/;
4190741973 stack[base + 27LLU] = 657807020572803072LLU;
@@ -41910,13 +41976,13 @@
4191041976 label = 18446744073709551599LLU; // neq
4191141977 break;
4191241978 }
41913- case 3549LLU: // copy-back deleter (neq to procblock)
41979+ case 3555LLU: // copy-back deleter (neq to procblock)
4191441980 {
4191541981 // copy mutable arguments back from call to neq
41916- label = 3541LLU; // continue to roll stack
41982+ label = 3547LLU; // continue to roll stack
4191741983 break;
4191841984 }
41919- case 3550LLU: // return from neq to procblock
41985+ case 3556LLU: // return from neq to procblock
4192041986 {
4192141987 // copy mutable arguments back from call to neq
4192241988 // copy back results provided by call to neq
@@ -41923,15 +41989,15 @@
4192341989 stack[base + 20] = stack[base + 25LLU];
4192441990 if(!stack[base + 20]/*isequal*/)
4192541991 {
41926- label = 3551LLU; // jump to alternative
41992+ label = 3557LLU; // jump to alternative
4192741993 break;
4192841994 }
4192941995
4193041996 // consequent
4193141997 // call neq from procblock
41932- stack[base + 22LLU] = 3553LLU/*throw to this address*/;
41998+ stack[base + 22LLU] = 3559LLU/*throw to this address*/;
4193341999 stack[base + 23LLU] = base;
41934- stack[base + 24LLU] = 3554LLU;
42000+ stack[base + 24LLU] = 3560LLU;
4193542001 // arguments for call to neq
4193642002 stack[base + 26LLU] = stack[base + 16]/*content*/;
4193742003 stack[base + 27LLU] = 842897672560967680LLU;
@@ -41940,13 +42006,13 @@
4194042006 label = 18446744073709551599LLU; // neq
4194142007 break;
4194242008 }
41943- case 3553LLU: // copy-back deleter (neq to procblock)
42009+ case 3559LLU: // copy-back deleter (neq to procblock)
4194442010 {
4194542011 // copy mutable arguments back from call to neq
41946- label = 3541LLU; // continue to roll stack
42012+ label = 3547LLU; // continue to roll stack
4194742013 break;
4194842014 }
41949- case 3554LLU: // return from neq to procblock
42015+ case 3560LLU: // return from neq to procblock
4195042016 {
4195142017 // copy mutable arguments back from call to neq
4195242018 // copy back results provided by call to neq
@@ -41953,15 +42019,15 @@
4195342019 stack[base + 20] = stack[base + 25LLU];
4195442020 if(!stack[base + 20]/*isequal*/)
4195542021 {
41956- label = 3555LLU; // jump to alternative
42022+ label = 3561LLU; // jump to alternative
4195742023 break;
4195842024 }
4195942025
4196042026 // consequent
4196142027 // call neq from procblock
41962- stack[base + 22LLU] = 3557LLU/*throw to this address*/;
42028+ stack[base + 22LLU] = 3563LLU/*throw to this address*/;
4196342029 stack[base + 23LLU] = base;
41964- stack[base + 24LLU] = 3558LLU;
42030+ stack[base + 24LLU] = 3564LLU;
4196542031 // arguments for call to neq
4196642032 stack[base + 26LLU] = stack[base + 16]/*content*/;
4196742033 stack[base + 27LLU] = 859571802316210176LLU;
@@ -41970,59 +42036,59 @@
4197042036 label = 18446744073709551599LLU; // neq
4197142037 break;
4197242038 }
41973- case 3557LLU: // copy-back deleter (neq to procblock)
42039+ case 3563LLU: // copy-back deleter (neq to procblock)
4197442040 {
4197542041 // copy mutable arguments back from call to neq
41976- label = 3541LLU; // continue to roll stack
42042+ label = 3547LLU; // continue to roll stack
4197742043 break;
4197842044 }
41979- case 3558LLU: // return from neq to procblock
42045+ case 3564LLU: // return from neq to procblock
4198042046 {
4198142047 // copy mutable arguments back from call to neq
4198242048 // copy back results provided by call to neq
4198342049 stack[base + 20] = stack[base + 25LLU];
41984- label = 3556LLU; // consequent complete
42050+ label = 3562LLU; // consequent complete
4198542051 break;
4198642052 }
41987- case 3555LLU: // alternative
42053+ case 3561LLU: // alternative
4198842054 {
41989- label = 3556LLU; // alternative complete
42055+ label = 3562LLU; // alternative complete
4199042056 break;
4199142057 }
41992- case 3556LLU: // completed if-then-else
42058+ case 3562LLU: // completed if-then-else
4199342059 {
41994- label = 3552LLU; // consequent complete
42060+ label = 3558LLU; // consequent complete
4199542061 break;
4199642062 }
41997- case 3551LLU: // alternative
42063+ case 3557LLU: // alternative
4199842064 {
41999- label = 3552LLU; // alternative complete
42065+ label = 3558LLU; // alternative complete
4200042066 break;
4200142067 }
42002- case 3552LLU: // completed if-then-else
42068+ case 3558LLU: // completed if-then-else
4200342069 {
42004- label = 3546LLU; // consequent complete
42070+ label = 3552LLU; // consequent complete
4200542071 break;
4200642072 }
42007- case 3545LLU: // alternative
42073+ case 3551LLU: // alternative
4200842074 {
4200942075 stack[base + 20]/*isequal*/ = 0;
42010- label = 3546LLU; // alternative complete
42076+ label = 3552LLU; // alternative complete
4201142077 break;
4201242078 }
42013- case 3546LLU: // completed if-then-else
42079+ case 3552LLU: // completed if-then-else
4201442080 {
4201542081 if(!stack[base + 20]/*isequal*/)
4201642082 {
42017- label = 3559LLU; // jump to alternative
42083+ label = 3565LLU; // jump to alternative
4201842084 break;
4201942085 }
4202042086
4202142087 // consequent
4202242088 // call issimple from procblock
42023- stack[base + 22LLU] = 3561LLU/*throw to this address*/;
42089+ stack[base + 22LLU] = 3567LLU/*throw to this address*/;
4202442090 stack[base + 23LLU] = base;
42025- stack[base + 24LLU] = 3562LLU;
42091+ stack[base + 24LLU] = 3568LLU;
4202642092 // arguments for call to issimple
4202742093 stack[base + 26LLU] = stack[base + 15]/*variant*/;
4202842094 stack[base + 27LLU] = stack[base + 16]/*content*/;
@@ -42032,13 +42098,13 @@
4203242098 label = 166LLU; // issimple
4203342099 break;
4203442100 }
42035- case 3561LLU: // copy-back deleter (issimple to procblock)
42101+ case 3567LLU: // copy-back deleter (issimple to procblock)
4203642102 {
4203742103 // copy mutable arguments back from call to issimple
42038- label = 3541LLU; // continue to roll stack
42104+ label = 3547LLU; // continue to roll stack
4203942105 break;
4204042106 }
42041- case 3562LLU: // return from issimple to procblock
42107+ case 3568LLU: // return from issimple to procblock
4204242108 {
4204342109 // copy mutable arguments back from call to issimple
4204442110 // copy back results provided by call to issimple
@@ -42045,15 +42111,15 @@
4204542111 stack[base + 20] = stack[base + 25LLU];
4204642112 if(!stack[base + 20]/*isequal*/)
4204742113 {
42048- label = 3563LLU; // jump to alternative
42114+ label = 3569LLU; // jump to alternative
4204942115 break;
4205042116 }
4205142117
4205242118 // consequent
4205342119 // call verbatim from procblock
42054- stack[base + 22LLU] = 3565LLU/*throw to this address*/;
42120+ stack[base + 22LLU] = 3571LLU/*throw to this address*/;
4205542121 stack[base + 23LLU] = base;
42056- stack[base + 24LLU] = 3566LLU;
42122+ stack[base + 24LLU] = 3572LLU;
4205742123 // arguments for call to verbatim
4205842124 stack[base + 25LLU] = stack[base + 2]/*scopes*/;
4205942125 stack[base + 26LLU] = stack[base + 3]/*scope*/;
@@ -42060,29 +42126,29 @@
4206042126 stack[base + 27LLU] = stack[base + 19]/*lookahead*/;
4206142127 // set stack-base & callee-address
4206242128 base += 25LLU;
42063- label = 3290LLU; // verbatim
42129+ label = 3296LLU; // verbatim
4206442130 break;
4206542131 }
42066- case 3565LLU: // copy-back deleter (verbatim to procblock)
42132+ case 3571LLU: // copy-back deleter (verbatim to procblock)
4206742133 {
4206842134 // copy mutable arguments back from call to verbatim
4206942135 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
42070- label = 3541LLU; // continue to roll stack
42136+ label = 3547LLU; // continue to roll stack
4207142137 break;
4207242138 }
42073- case 3566LLU: // return from verbatim to procblock
42139+ case 3572LLU: // return from verbatim to procblock
4207442140 {
4207542141 // copy mutable arguments back from call to verbatim
4207642142 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
42077- label = 3564LLU; // consequent complete
42143+ label = 3570LLU; // consequent complete
4207842144 break;
4207942145 }
42080- case 3563LLU: // alternative
42146+ case 3569LLU: // alternative
4208142147 {
4208242148 // call PROCRETURN from procblock
42083- stack[base + 22LLU] = 3567LLU/*throw to this address*/;
42149+ stack[base + 22LLU] = 3573LLU/*throw to this address*/;
4208442150 stack[base + 23LLU] = base;
42085- stack[base + 24LLU] = 3568LLU;
42151+ stack[base + 24LLU] = 3574LLU;
4208642152 // arguments for call to PROCRETURN
4208742153 stack[base + 25LLU] = stack[base + 0]/*fndefs*/;
4208842154 stack[base + 26LLU] = stack[base + 1]/*datadefs*/;
@@ -42107,7 +42173,7 @@
4210742173 label = 2848LLU; // PROCRETURN
4210842174 break;
4210942175 }
42110- case 3567LLU: // copy-back deleter (PROCRETURN to procblock)
42176+ case 3573LLU: // copy-back deleter (PROCRETURN to procblock)
4211142177 {
4211242178 // copy mutable arguments back from call to PROCRETURN
4211342179 stack[base + 17]/*label*/ = stack[base + 42LLU];
@@ -42116,10 +42182,10 @@
4211642182 stack[base + 19]/*lookahead*/ = stack[base + 39LLU];
4211742183 stack[base + 12]/*fnmaxcount*/ = stack[base + 38LLU];
4211842184 stack[base + 3]/*scope*/ = stack[base + 28LLU];
42119- label = 3541LLU; // continue to roll stack
42185+ label = 3547LLU; // continue to roll stack
4212042186 break;
4212142187 }
42122- case 3568LLU: // return from PROCRETURN to procblock
42188+ case 3574LLU: // return from PROCRETURN to procblock
4212342189 {
4212442190 // copy mutable arguments back from call to PROCRETURN
4212542191 stack[base + 17]/*label*/ = stack[base + 42LLU];
@@ -42128,15 +42194,15 @@
4212842194 stack[base + 19]/*lookahead*/ = stack[base + 39LLU];
4212942195 stack[base + 12]/*fnmaxcount*/ = stack[base + 38LLU];
4213042196 stack[base + 3]/*scope*/ = stack[base + 28LLU];
42131- label = 3564LLU; // alternative complete
42197+ label = 3570LLU; // alternative complete
4213242198 break;
4213342199 }
42134- case 3564LLU: // completed if-then-else
42200+ case 3570LLU: // completed if-then-else
4213542201 {
4213642202 // call MATCHPEEK from procblock
42137- stack[base + 22LLU] = 3569LLU/*throw to this address*/;
42203+ stack[base + 22LLU] = 3575LLU/*throw to this address*/;
4213842204 stack[base + 23LLU] = base;
42139- stack[base + 24LLU] = 3570LLU;
42205+ stack[base + 24LLU] = 3576LLU;
4214042206 // arguments for call to MATCHPEEK
4214142207 stack[base + 25LLU] = stack[base + 8]/*fnid*/;
4214242208 stack[base + 26LLU] = 125LLU;
@@ -42146,21 +42212,21 @@
4214642212 label = 206LLU; // MATCHPEEK
4214742213 break;
4214842214 }
42149- case 3569LLU: // copy-back deleter (MATCHPEEK to procblock)
42215+ case 3575LLU: // copy-back deleter (MATCHPEEK to procblock)
4215042216 {
4215142217 // copy mutable arguments back from call to MATCHPEEK
4215242218 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
42153- label = 3541LLU; // continue to roll stack
42219+ label = 3547LLU; // continue to roll stack
4215442220 break;
4215542221 }
42156- case 3570LLU: // return from MATCHPEEK to procblock
42222+ case 3576LLU: // return from MATCHPEEK to procblock
4215742223 {
4215842224 // copy mutable arguments back from call to MATCHPEEK
4215942225 stack[base + 19]/*lookahead*/ = stack[base + 27LLU];
4216042226 // call EOSbyte from procblock
42161- stack[base + 22LLU] = 3571LLU/*throw to this address*/;
42227+ stack[base + 22LLU] = 3577LLU/*throw to this address*/;
4216242228 stack[base + 23LLU] = base;
42163- stack[base + 24LLU] = 3572LLU;
42229+ stack[base + 24LLU] = 3578LLU;
4216442230 // arguments for call to EOSbyte
4216542231 // set stack-base & callee-address
4216642232 base += 25LLU;
@@ -42167,42 +42233,42 @@
4216742233 label = 77LLU; // EOSbyte
4216842234 break;
4216942235 }
42170- case 3571LLU: // copy-back deleter (EOSbyte to procblock)
42236+ case 3577LLU: // copy-back deleter (EOSbyte to procblock)
4217142237 {
4217242238 // copy mutable arguments back from call to EOSbyte
42173- label = 3541LLU; // continue to roll stack
42239+ label = 3547LLU; // continue to roll stack
4217442240 break;
4217542241 }
42176- case 3572LLU: // return from EOSbyte to procblock
42242+ case 3578LLU: // return from EOSbyte to procblock
4217742243 {
4217842244 // copy mutable arguments back from call to EOSbyte
4217942245 // copy back results provided by call to EOSbyte
4218042246 stack[base + 19] = stack[base + 25LLU];
42181- label = 3560LLU; // consequent complete
42247+ label = 3566LLU; // consequent complete
4218242248 break;
4218342249 }
42184- case 3559LLU: // alternative
42250+ case 3565LLU: // alternative
4218542251 {
42186- label = 3574LLU; // skip deleter
42252+ label = 3580LLU; // skip deleter
4218742253 break;
4218842254 }
42189- case 3573LLU: // deleter
42255+ case 3579LLU: // deleter
4219042256 {
4219142257 // throw from procblock
4219242258 if(!stack[base + 22])
4219342259 {
42194- label = 3541LLU; // skip, variable already deleted/unscoped
42260+ label = 3547LLU; // skip, variable already deleted/unscoped
4219542261 break;
4219642262 }
42197- label = 3541LLU; // continue unrolling stack, delete next variable
42263+ label = 3547LLU; // continue unrolling stack, delete next variable
4219842264 break;
4219942265 }
42200- case 3574LLU: // skipped deleter
42266+ case 3580LLU: // skipped deleter
4220142267 {
4220242268 // call equ from procblock
42203- stack[base + 23LLU] = 3575LLU/*throw to this address*/;
42269+ stack[base + 23LLU] = 3581LLU/*throw to this address*/;
4220442270 stack[base + 24LLU] = base;
42205- stack[base + 25LLU] = 3576LLU;
42271+ stack[base + 25LLU] = 3582LLU;
4220642272 // arguments for call to equ
4220742273 stack[base + 27LLU] = stack[base + 16]/*content*/;
4220842274 stack[base + 28LLU] = 910715104645873664LLU;
@@ -42211,13 +42277,13 @@
4221142277 label = 18446744073709551600LLU; // equ
4221242278 break;
4221342279 }
42214- case 3575LLU: // copy-back deleter (equ to procblock)
42280+ case 3581LLU: // copy-back deleter (equ to procblock)
4221542281 {
4221642282 // copy mutable arguments back from call to equ
42217- label = 3541LLU; // continue to roll stack
42283+ label = 3547LLU; // continue to roll stack
4221842284 break;
4221942285 }
42220- case 3576LLU: // return from equ to procblock
42286+ case 3582LLU: // return from equ to procblock
4222142287 {
4222242288 // copy mutable arguments back from call to equ
4222342289 // copy back results provided by call to equ
@@ -42224,21 +42290,21 @@
4222442290 stack[base + 22] = stack[base + 26LLU];
4222542291 if(!stack[base + 22]/*when*/)
4222642292 {
42227- label = 3577LLU; // jump to alternative
42293+ label = 3583LLU; // jump to alternative
4222842294 break;
4222942295 }
4223042296
4223142297 // consequent
4223242298 stack[base + 20]/*isequal*/ = 1;
42233- label = 3578LLU; // consequent complete
42299+ label = 3584LLU; // consequent complete
4223442300 break;
4223542301 }
42236- case 3577LLU: // alternative
42302+ case 3583LLU: // alternative
4223742303 {
4223842304 // call equ from procblock
42239- stack[base + 23LLU] = 3579LLU/*throw to this address*/;
42305+ stack[base + 23LLU] = 3585LLU/*throw to this address*/;
4224042306 stack[base + 24LLU] = base;
42241- stack[base + 25LLU] = 3580LLU;
42307+ stack[base + 25LLU] = 3586LLU;
4224242308 // arguments for call to equ
4224342309 stack[base + 27LLU] = stack[base + 16]/*content*/;
4224442310 stack[base + 28LLU] = 657807020572803072LLU;
@@ -42247,33 +42313,33 @@
4224742313 label = 18446744073709551600LLU; // equ
4224842314 break;
4224942315 }
42250- case 3579LLU: // copy-back deleter (equ to procblock)
42316+ case 3585LLU: // copy-back deleter (equ to procblock)
4225142317 {
4225242318 // copy mutable arguments back from call to equ
42253- label = 3573LLU; // continue to roll stack
42319+ label = 3579LLU; // continue to roll stack
4225442320 break;
4225542321 }
42256- case 3580LLU: // return from equ to procblock
42322+ case 3586LLU: // return from equ to procblock
4225742323 {
4225842324 // copy mutable arguments back from call to equ
4225942325 // copy back results provided by call to equ
4226042326 stack[base + 20] = stack[base + 26LLU];
42261- label = 3578LLU; // alternative complete
42327+ label = 3584LLU; // alternative complete
4226242328 break;
4226342329 }
42264- case 3578LLU: // completed if-then-else
42330+ case 3584LLU: // completed if-then-else
4226542331 {
4226642332 if(!stack[base + 20]/*isequal*/)
4226742333 {
42268- label = 3581LLU; // jump to alternative
42334+ label = 3587LLU; // jump to alternative
4226942335 break;
4227042336 }
4227142337
4227242338 // consequent
4227342339 // call add from procblock
42274- stack[base + 23LLU] = 3583LLU/*throw to this address*/;
42340+ stack[base + 23LLU] = 3589LLU/*throw to this address*/;
4227542341 stack[base + 24LLU] = base;
42276- stack[base + 25LLU] = 3584LLU;
42342+ stack[base + 25LLU] = 3590LLU;
4227742343 // arguments for call to add
4227842344 stack[base + 27LLU] = 1LLU;
4227942345 stack[base + 28LLU] = stack[base + 17]/*label*/;
@@ -42282,38 +42348,38 @@
4228242348 label = 18446744073709551605LLU; // add
4228342349 break;
4228442350 }
42285- case 3583LLU: // copy-back deleter (add to procblock)
42351+ case 3589LLU: // copy-back deleter (add to procblock)
4228642352 {
4228742353 // copy mutable arguments back from call to add
42288- label = 3573LLU; // continue to roll stack
42354+ label = 3579LLU; // continue to roll stack
4228942355 break;
4229042356 }
42291- case 3584LLU: // return from add to procblock
42357+ case 3590LLU: // return from add to procblock
4229242358 {
4229342359 // copy mutable arguments back from call to add
4229442360 // copy back results provided by call to add
4229542361 stack[base + 17] = stack[base + 26LLU];
42296- label = 3586LLU; // skip deleter
42362+ label = 3592LLU; // skip deleter
4229742363 break;
4229842364 }
42299- case 3585LLU: // deleter
42365+ case 3591LLU: // deleter
4230042366 {
4230142367 // throw from procblock
4230242368 if(!stack[base + 23])
4230342369 {
42304- label = 3573LLU; // skip, variable already deleted/unscoped
42370+ label = 3579LLU; // skip, variable already deleted/unscoped
4230542371 break;
4230642372 }
42307- label = 3573LLU; // continue unrolling stack, delete next variable
42373+ label = 3579LLU; // continue unrolling stack, delete next variable
4230842374 break;
4230942375 }
42310- case 3586LLU: // skipped deleter
42376+ case 3592LLU: // skipped deleter
4231142377 {
4231242378 stack[base + 23] = stack[base + 17]/*label*/;
4231342379 // call add from procblock
42314- stack[base + 24LLU] = 3587LLU/*throw to this address*/;
42380+ stack[base + 24LLU] = 3593LLU/*throw to this address*/;
4231542381 stack[base + 25LLU] = base;
42316- stack[base + 26LLU] = 3588LLU;
42382+ stack[base + 26LLU] = 3594LLU;
4231742383 // arguments for call to add
4231842384 stack[base + 28LLU] = 1LLU;
4231942385 stack[base + 29LLU] = stack[base + 17]/*label*/;
@@ -42322,38 +42388,38 @@
4232242388 label = 18446744073709551605LLU; // add
4232342389 break;
4232442390 }
42325- case 3587LLU: // copy-back deleter (add to procblock)
42391+ case 3593LLU: // copy-back deleter (add to procblock)
4232642392 {
4232742393 // copy mutable arguments back from call to add
42328- label = 3585LLU; // continue to roll stack
42394+ label = 3591LLU; // continue to roll stack
4232942395 break;
4233042396 }
42331- case 3588LLU: // return from add to procblock
42397+ case 3594LLU: // return from add to procblock
4233242398 {
4233342399 // copy mutable arguments back from call to add
4233442400 // copy back results provided by call to add
4233542401 stack[base + 17] = stack[base + 27LLU];
42336- label = 3590LLU; // skip deleter
42402+ label = 3596LLU; // skip deleter
4233742403 break;
4233842404 }
42339- case 3589LLU: // deleter
42405+ case 3595LLU: // deleter
4234042406 {
4234142407 // throw from procblock
4234242408 if(!stack[base + 24])
4234342409 {
42344- label = 3585LLU; // skip, variable already deleted/unscoped
42410+ label = 3591LLU; // skip, variable already deleted/unscoped
4234542411 break;
4234642412 }
42347- label = 3585LLU; // continue unrolling stack, delete next variable
42413+ label = 3591LLU; // continue unrolling stack, delete next variable
4234842414 break;
4234942415 }
42350- case 3590LLU: // skipped deleter
42416+ case 3596LLU: // skipped deleter
4235142417 {
4235242418 stack[base + 24] = stack[base + 17]/*label*/;
4235342419 // call ParseToken from procblock
42354- stack[base + 25LLU] = 3591LLU/*throw to this address*/;
42420+ stack[base + 25LLU] = 3597LLU/*throw to this address*/;
4235542421 stack[base + 26LLU] = base;
42356- stack[base + 27LLU] = 3592LLU;
42422+ stack[base + 27LLU] = 3598LLU;
4235742423 // arguments for call to ParseToken
4235842424 stack[base + 30LLU] = stack[base + 19]/*lookahead*/;
4235942425 // set stack-base & callee-address
@@ -42361,14 +42427,14 @@
4236142427 label = 3LLU; // ParseToken
4236242428 break;
4236342429 }
42364- case 3591LLU: // copy-back deleter (ParseToken to procblock)
42430+ case 3597LLU: // copy-back deleter (ParseToken to procblock)
4236542431 {
4236642432 // copy mutable arguments back from call to ParseToken
4236742433 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
42368- label = 3589LLU; // continue to roll stack
42434+ label = 3595LLU; // continue to roll stack
4236942435 break;
4237042436 }
42371- case 3592LLU: // return from ParseToken to procblock
42437+ case 3598LLU: // return from ParseToken to procblock
4237242438 {
4237342439 // copy mutable arguments back from call to ParseToken
4237442440 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
@@ -42376,9 +42442,9 @@
4237642442 stack[base + 15] = stack[base + 28LLU];
4237742443 stack[base + 16] = stack[base + 29LLU];
4237842444 // call issimple from procblock
42379- stack[base + 25LLU] = 3593LLU/*throw to this address*/;
42445+ stack[base + 25LLU] = 3599LLU/*throw to this address*/;
4238042446 stack[base + 26LLU] = base;
42381- stack[base + 27LLU] = 3594LLU;
42447+ stack[base + 27LLU] = 3600LLU;
4238242448 // arguments for call to issimple
4238342449 stack[base + 29LLU] = stack[base + 15]/*variant*/;
4238442450 stack[base + 30LLU] = stack[base + 16]/*content*/;
@@ -42388,13 +42454,13 @@
4238842454 label = 166LLU; // issimple
4238942455 break;
4239042456 }
42391- case 3593LLU: // copy-back deleter (issimple to procblock)
42457+ case 3599LLU: // copy-back deleter (issimple to procblock)
4239242458 {
4239342459 // copy mutable arguments back from call to issimple
42394- label = 3589LLU; // continue to roll stack
42460+ label = 3595LLU; // continue to roll stack
4239542461 break;
4239642462 }
42397- case 3594LLU: // return from issimple to procblock
42463+ case 3600LLU: // return from issimple to procblock
4239842464 {
4239942465 // copy mutable arguments back from call to issimple
4240042466 // copy back results provided by call to issimple
@@ -42401,7 +42467,7 @@
4240142467 stack[base + 20] = stack[base + 28LLU];
4240242468 if(!stack[base + 20]/*isequal*/)
4240342469 {
42404- label = 3595LLU; // jump to alternative
42470+ label = 3601LLU; // jump to alternative
4240542471 break;
4240642472 }
4240742473
@@ -42408,9 +42474,9 @@
4240842474 // consequent
4240942475 printf("%s", "\n if(!");
4241042476 // call ParseToken from procblock
42411- stack[base + 25LLU] = 3597LLU/*throw to this address*/;
42477+ stack[base + 25LLU] = 3603LLU/*throw to this address*/;
4241242478 stack[base + 26LLU] = base;
42413- stack[base + 27LLU] = 3598LLU;
42479+ stack[base + 27LLU] = 3604LLU;
4241442480 // arguments for call to ParseToken
4241542481 stack[base + 30LLU] = stack[base + 19]/*lookahead*/;
4241642482 // set stack-base & callee-address
@@ -42418,14 +42484,14 @@
4241842484 label = 3LLU; // ParseToken
4241942485 break;
4242042486 }
42421- case 3597LLU: // copy-back deleter (ParseToken to procblock)
42487+ case 3603LLU: // copy-back deleter (ParseToken to procblock)
4242242488 {
4242342489 // copy mutable arguments back from call to ParseToken
4242442490 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
42425- label = 3589LLU; // continue to roll stack
42491+ label = 3595LLU; // continue to roll stack
4242642492 break;
4242742493 }
42428- case 3598LLU: // return from ParseToken to procblock
42494+ case 3604LLU: // return from ParseToken to procblock
4242942495 {
4243042496 // copy mutable arguments back from call to ParseToken
4243142497 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
@@ -42433,9 +42499,9 @@
4243342499 stack[base + 15] = stack[base + 28LLU];
4243442500 stack[base + 16] = stack[base + 29LLU];
4243542501 // call equ from procblock
42436- stack[base + 25LLU] = 3599LLU/*throw to this address*/;
42502+ stack[base + 25LLU] = 3605LLU/*throw to this address*/;
4243742503 stack[base + 26LLU] = base;
42438- stack[base + 27LLU] = 3600LLU;
42504+ stack[base + 27LLU] = 3606LLU;
4243942505 // arguments for call to equ
4244042506 stack[base + 29LLU] = stack[base + 15]/*variant*/;
4244142507 stack[base + 30LLU] = 1LLU;
@@ -42444,13 +42510,13 @@
4244442510 label = 18446744073709551600LLU; // equ
4244542511 break;
4244642512 }
42447- case 3599LLU: // copy-back deleter (equ to procblock)
42513+ case 3605LLU: // copy-back deleter (equ to procblock)
4244842514 {
4244942515 // copy mutable arguments back from call to equ
42450- label = 3589LLU; // continue to roll stack
42516+ label = 3595LLU; // continue to roll stack
4245142517 break;
4245242518 }
42453- case 3600LLU: // return from equ to procblock
42519+ case 3606LLU: // return from equ to procblock
4245442520 {
4245542521 // copy mutable arguments back from call to equ
4245642522 // copy back results provided by call to equ
@@ -42457,15 +42523,15 @@
4245742523 stack[base + 20] = stack[base + 28LLU];
4245842524 if(!stack[base + 20]/*isequal*/)
4245942525 {
42460- label = 3601LLU; // jump to alternative
42526+ label = 3607LLU; // jump to alternative
4246142527 break;
4246242528 }
4246342529
4246442530 // consequent
4246542531 // call printnr from procblock
42466- stack[base + 25LLU] = 3603LLU/*throw to this address*/;
42532+ stack[base + 25LLU] = 3609LLU/*throw to this address*/;
4246742533 stack[base + 26LLU] = base;
42468- stack[base + 27LLU] = 3604LLU;
42534+ stack[base + 27LLU] = 3610LLU;
4246942535 // arguments for call to printnr
4247042536 stack[base + 28LLU] = stack[base + 16]/*content*/;
4247142537 // set stack-base & callee-address
@@ -42473,24 +42539,24 @@
4247342539 label = 18446744073709551590LLU; // printnr
4247442540 break;
4247542541 }
42476- case 3603LLU: // copy-back deleter (printnr to procblock)
42542+ case 3609LLU: // copy-back deleter (printnr to procblock)
4247742543 {
4247842544 // copy mutable arguments back from call to printnr
42479- label = 3589LLU; // continue to roll stack
42545+ label = 3595LLU; // continue to roll stack
4248042546 break;
4248142547 }
42482- case 3604LLU: // return from printnr to procblock
42548+ case 3610LLU: // return from printnr to procblock
4248342549 {
4248442550 // copy mutable arguments back from call to printnr
42485- label = 3602LLU; // consequent complete
42551+ label = 3608LLU; // consequent complete
4248642552 break;
4248742553 }
42488- case 3601LLU: // alternative
42554+ case 3607LLU: // alternative
4248942555 {
4249042556 // call equ from procblock
42491- stack[base + 25LLU] = 3605LLU/*throw to this address*/;
42557+ stack[base + 25LLU] = 3611LLU/*throw to this address*/;
4249242558 stack[base + 26LLU] = base;
42493- stack[base + 27LLU] = 3606LLU;
42559+ stack[base + 27LLU] = 3612LLU;
4249442560 // arguments for call to equ
4249542561 stack[base + 29LLU] = stack[base + 15]/*variant*/;
4249642562 stack[base + 30LLU] = 4LLU;
@@ -42499,13 +42565,13 @@
4249942565 label = 18446744073709551600LLU; // equ
4250042566 break;
4250142567 }
42502- case 3605LLU: // copy-back deleter (equ to procblock)
42568+ case 3611LLU: // copy-back deleter (equ to procblock)
4250342569 {
4250442570 // copy mutable arguments back from call to equ
42505- label = 3589LLU; // continue to roll stack
42571+ label = 3595LLU; // continue to roll stack
4250642572 break;
4250742573 }
42508- case 3606LLU: // return from equ to procblock
42574+ case 3612LLU: // return from equ to procblock
4250942575 {
4251042576 // copy mutable arguments back from call to equ
4251142577 // copy back results provided by call to equ
@@ -42512,15 +42578,15 @@
4251242578 stack[base + 20] = stack[base + 28LLU];
4251342579 if(!stack[base + 20]/*isequal*/)
4251442580 {
42515- label = 3607LLU; // jump to alternative
42581+ label = 3613LLU; // jump to alternative
4251642582 break;
4251742583 }
4251842584
4251942585 // consequent
4252042586 // call emitvar from procblock
42521- stack[base + 25LLU] = 3609LLU/*throw to this address*/;
42587+ stack[base + 25LLU] = 3615LLU/*throw to this address*/;
4252242588 stack[base + 26LLU] = base;
42523- stack[base + 27LLU] = 3610LLU;
42589+ stack[base + 27LLU] = 3616LLU;
4252442590 // arguments for call to emitvar
4252542591 stack[base + 28LLU] = stack[base + 8]/*fnid*/;
4252642592 stack[base + 29LLU] = stack[base + 16]/*content*/;
@@ -42531,25 +42597,25 @@
4253142597 label = 749LLU; // emitvar
4253242598 break;
4253342599 }
42534- case 3609LLU: // copy-back deleter (emitvar to procblock)
42600+ case 3615LLU: // copy-back deleter (emitvar to procblock)
4253542601 {
4253642602 // copy mutable arguments back from call to emitvar
42537- label = 3589LLU; // continue to roll stack
42603+ label = 3595LLU; // continue to roll stack
4253842604 break;
4253942605 }
42540- case 3610LLU: // return from emitvar to procblock
42606+ case 3616LLU: // return from emitvar to procblock
4254142607 {
4254242608 // copy mutable arguments back from call to emitvar
42543- label = 3608LLU; // consequent complete
42609+ label = 3614LLU; // consequent complete
4254442610 break;
4254542611 }
42546- case 3607LLU: // alternative
42612+ case 3613LLU: // alternative
4254742613 {
4254842614 fprintf(stderr, "%s", "expected identifier in if-then-else but found ");
4254942615 // call reporttok from procblock
42550- stack[base + 25LLU] = 3611LLU/*throw to this address*/;
42616+ stack[base + 25LLU] = 3617LLU/*throw to this address*/;
4255142617 stack[base + 26LLU] = base;
42552- stack[base + 27LLU] = 3612LLU;
42618+ stack[base + 27LLU] = 3618LLU;
4255342619 // arguments for call to reporttok
4255442620 stack[base + 28LLU] = stack[base + 15]/*variant*/;
4255542621 stack[base + 29LLU] = stack[base + 16]/*content*/;
@@ -42558,35 +42624,35 @@
4255842624 label = 18446744073709551582LLU; // reporttok
4255942625 break;
4256042626 }
42561- case 3611LLU: // copy-back deleter (reporttok to procblock)
42627+ case 3617LLU: // copy-back deleter (reporttok to procblock)
4256242628 {
4256342629 // copy mutable arguments back from call to reporttok
42564- label = 3589LLU; // continue to roll stack
42630+ label = 3595LLU; // continue to roll stack
4256542631 break;
4256642632 }
42567- case 3612LLU: // return from reporttok to procblock
42633+ case 3618LLU: // return from reporttok to procblock
4256842634 {
4256942635 // copy mutable arguments back from call to reporttok
4257042636 fprintf(stderr, "%s", "\n");
4257142637 {
42572- label = 3589LLU; // throw: begin to unroll stack
42638+ label = 3595LLU; // throw: begin to unroll stack
4257342639 break;
4257442640 }
4257542641
42576- label = 3608LLU; // alternative complete
42642+ label = 3614LLU; // alternative complete
4257742643 break;
4257842644 }
42579- case 3608LLU: // completed if-then-else
42645+ case 3614LLU: // completed if-then-else
4258042646 {
42581- label = 3602LLU; // alternative complete
42647+ label = 3608LLU; // alternative complete
4258242648 break;
4258342649 }
42584- case 3602LLU: // completed if-then-else
42650+ case 3608LLU: // completed if-then-else
4258542651 {
4258642652 // call matchsym from procblock
42587- stack[base + 25LLU] = 3613LLU/*throw to this address*/;
42653+ stack[base + 25LLU] = 3619LLU/*throw to this address*/;
4258842654 stack[base + 26LLU] = base;
42589- stack[base + 27LLU] = 3614LLU;
42655+ stack[base + 27LLU] = 3620LLU;
4259042656 // arguments for call to matchsym
4259142657 stack[base + 28LLU] = stack[base + 8]/*fnid*/;
4259242658 stack[base + 29LLU] = 41LLU;
@@ -42596,14 +42662,14 @@
4259642662 label = 246LLU; // matchsym
4259742663 break;
4259842664 }
42599- case 3613LLU: // copy-back deleter (matchsym to procblock)
42665+ case 3619LLU: // copy-back deleter (matchsym to procblock)
4260042666 {
4260142667 // copy mutable arguments back from call to matchsym
4260242668 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
42603- label = 3589LLU; // continue to roll stack
42669+ label = 3595LLU; // continue to roll stack
4260442670 break;
4260542671 }
42606- case 3614LLU: // return from matchsym to procblock
42672+ case 3620LLU: // return from matchsym to procblock
4260742673 {
4260842674 // copy mutable arguments back from call to matchsym
4260942675 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
@@ -42611,9 +42677,9 @@
4261142677 printf("%s", "\n {");
4261242678 printf("%s", "\n label = ");
4261342679 // call printnr from procblock
42614- stack[base + 25LLU] = 3615LLU/*throw to this address*/;
42680+ stack[base + 25LLU] = 3621LLU/*throw to this address*/;
4261542681 stack[base + 26LLU] = base;
42616- stack[base + 27LLU] = 3616LLU;
42682+ stack[base + 27LLU] = 3622LLU;
4261742683 // arguments for call to printnr
4261842684 stack[base + 28LLU] = stack[base + 23]/*labelalt*/;
4261942685 // set stack-base & callee-address
@@ -42621,13 +42687,13 @@
4262142687 label = 18446744073709551590LLU; // printnr
4262242688 break;
4262342689 }
42624- case 3615LLU: // copy-back deleter (printnr to procblock)
42690+ case 3621LLU: // copy-back deleter (printnr to procblock)
4262542691 {
4262642692 // copy mutable arguments back from call to printnr
42627- label = 3589LLU; // continue to roll stack
42693+ label = 3595LLU; // continue to roll stack
4262842694 break;
4262942695 }
42630- case 3616LLU: // return from printnr to procblock
42696+ case 3622LLU: // return from printnr to procblock
4263142697 {
4263242698 // copy mutable arguments back from call to printnr
4263342699 printf("%s", "LLU; // jump to alternative");
@@ -42636,9 +42702,9 @@
4263642702 printf("%s", "\n");
4263742703 printf("%s", "\n // consequent");
4263842704 // call matchsym from procblock
42639- stack[base + 25LLU] = 3617LLU/*throw to this address*/;
42705+ stack[base + 25LLU] = 3623LLU/*throw to this address*/;
4264042706 stack[base + 26LLU] = base;
42641- stack[base + 27LLU] = 3618LLU;
42707+ stack[base + 27LLU] = 3624LLU;
4264242708 // arguments for call to matchsym
4264342709 stack[base + 28LLU] = stack[base + 8]/*fnid*/;
4264442710 stack[base + 29LLU] = 123LLU;
@@ -42648,20 +42714,20 @@
4264842714 label = 246LLU; // matchsym
4264942715 break;
4265042716 }
42651- case 3617LLU: // copy-back deleter (matchsym to procblock)
42717+ case 3623LLU: // copy-back deleter (matchsym to procblock)
4265242718 {
4265342719 // copy mutable arguments back from call to matchsym
4265442720 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
42655- label = 3589LLU; // continue to roll stack
42721+ label = 3595LLU; // continue to roll stack
4265642722 break;
4265742723 }
42658- case 3618LLU: // return from matchsym to procblock
42724+ case 3624LLU: // return from matchsym to procblock
4265942725 {
4266042726 // copy mutable arguments back from call to matchsym
4266142727 stack[base + 19]/*lookahead*/ = stack[base + 30LLU];
4266242728 if(!stack[base + 21]/*returnflag*/)
4266342729 {
42664- label = 3619LLU; // jump to alternative
42730+ label = 3625LLU; // jump to alternative
4266542731 break;
4266642732 }
4266742733
@@ -42669,7 +42735,7 @@
4266942735 uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t));
4267042736 if(!newstack)
4267142737 {
42672- label = 3589LLU; // throw: begin to unroll stack
42738+ label = 3595LLU; // throw: begin to unroll stack
4267342739 break;
4267442740 }
4267542741
@@ -42676,9 +42742,9 @@
4267642742 newstack[160LLU] = 9876543210LLU; // overflow-marker
4267742743 // call procblock from procblock
4267842744 newstack[0] = (uint64_t)stack; // backup stack location
42679- newstack[1] = 3621LLU;
42745+ newstack[1] = 3627LLU;
4268042746 newstack[2] = base;
42681- newstack[3] = 3622LLU;
42747+ newstack[3] = 3628LLU;
4268242748 // arguments for call to procblock
4268342749 newstack[4LLU] = stack[base + 0]/*fndefs*/;
4268442750 newstack[5LLU] = stack[base + 1]/*datadefs*/;
@@ -42701,10 +42767,10 @@
4270142767 stack = newstack;
4270242768 // set stack-base & callee-address
4270342769 base = 4/*deloffset*/;
42704- label = 3474LLU; // procblock
42770+ label = 3480LLU; // procblock
4270542771 break;
4270642772 }
42707- case 3621LLU: // copy-back deleter (procblock to procblock)
42773+ case 3627LLU: // copy-back deleter (procblock to procblock)
4270842774 {
4270942775 uint64_t *oldstack = (uint64_t *)stack[0];
4271042776 // copy mutable arguments back from call to procblock
@@ -42721,10 +42787,10 @@
4272142787 }
4272242788 Free(160LLU + 1, sizeof(uint64_t), stack);
4272342789 stack = oldstack;
42724- label = 3589LLU; // continue to unroll stack
42790+ label = 3595LLU; // continue to unroll stack
4272542791 break;
4272642792 }
42727- case 3622LLU: // return from procblock to procblock
42793+ case 3628LLU: // return from procblock to procblock
4272842794 {
4272942795 uint64_t *oldstack = (uint64_t *)stack[0];
4273042796 // copy mutable arguments back from call to procblock
@@ -42741,31 +42807,31 @@
4274142807 }
4274242808 Free(160LLU + 1, sizeof(uint64_t), stack);
4274342809 stack = oldstack;
42744- label = 3620LLU; // consequent complete
42810+ label = 3626LLU; // consequent complete
4274542811 break;
4274642812 }
42747- case 3619LLU: // alternative
42813+ case 3625LLU: // alternative
4274842814 {
42749- label = 3624LLU; // skip deleter
42815+ label = 3630LLU; // skip deleter
4275042816 break;
4275142817 }
42752- case 3623LLU: // deleter
42818+ case 3629LLU: // deleter
4275342819 {
4275442820 // throw from procblock
4275542821 if(!stack[base + 25])
4275642822 {
42757- label = 3589LLU; // skip, variable already deleted/unscoped
42823+ label = 3595LLU; // skip, variable already deleted/unscoped
4275842824 break;
4275942825 }
4276042826 // delete list
42761- label = 3625LLU; // start to repeat
42827+ label = 3631LLU; // start to repeat
4276242828 break;
4276342829 }
42764- case 3625LLU: // repeat from here
42830+ case 3631LLU: // repeat from here
4276542831 {
4276642832 if(!stack[base + 25])
4276742833 {
42768- label = 3626LLU; // break loop
42834+ label = 3632LLU; // break loop
4276942835 break;
4277042836 }
4277142837
@@ -42776,7 +42842,7 @@
4277642842 newstack[0] = (uint64_t)stack; // backup stack location
4277742843 newstack[1] = 1234567890;
4277842844 newstack[2] = base;
42779- newstack[3] = 3627LLU;
42845+ newstack[3] = 3633LLU;
4278042846 stack = newstack;
4278142847 // set stack-base & callee-address
4278242848 base = 4/*deloffset*/;
@@ -42783,7 +42849,7 @@
4278342849 label = 399LLU; // ~typeidx
4278442850 break;
4278542851 }
42786- case 3627LLU: // return from ~typeidx to procblock
42852+ case 3633LLU: // return from ~typeidx to procblock
4278742853 {
4278842854 stack = (uint64_t *)stack[0];
4278942855 // releasing toplevel container
@@ -42794,21 +42860,21 @@
4279442860 stack[base + 25] = (uint64_t)list->next;
4279542861 Free(1, sizeof(struct listnode), list);
4279642862 }
42797- label = 3625LLU; // repeat
42863+ label = 3631LLU; // repeat
4279842864 break;
4279942865 }
42800- case 3626LLU: // loop finished
42866+ case 3632LLU: // loop finished
4280142867 {
42802- label = 3589LLU; // continue unrolling stack, delete next variable
42868+ label = 3595LLU; // continue unrolling stack, delete next variable
4280342869 break;
4280442870 }
42805- case 3624LLU: // skipped deleter
42871+ case 3630LLU: // skipped deleter
4280642872 {
4280742873 stack[base + 25] = 0;
4280842874 uint64_t *newstack = (uint64_t *)Calloc(160LLU + 1, sizeof(uint64_t));
4280942875 if(!newstack)
4281042876 {
42811- label = 3623LLU; // throw: begin to unroll stack
42877+ label = 3629LLU; // throw: begin to unroll stack
4281242878 break;
4281342879 }
4281442880
@@ -42815,9 +42881,9 @@
4281542881 newstack[160LLU] = 9876543210LLU; // overflow-marker
4281642882 // call procblock from procblock
4281742883 newstack[0] = (uint64_t)stack; // backup stack location
42818- newstack[1] = 3628LLU;
42884+ newstack[1] = 3634LLU;
4281942885 newstack[2] = base;
42820- newstack[3] = 3629LLU;
42886+ newstack[3] = 3635LLU;
4282142887 // arguments for call to procblock
4282242888 newstack[4LLU] = stack[base + 0]/*fndefs*/;
4282342889 newstack[5LLU] = stack[base + 1]/*datadefs*/;
@@ -42840,10 +42906,10 @@
4284042906 stack = newstack;
4284142907 // set stack-base & callee-address
4284242908 base = 4/*deloffset*/;
42843- label = 3474LLU; // procblock
42909+ label = 3480LLU; // procblock
4284442910 break;
4284542911 }
42846- case 3628LLU: // copy-back deleter (procblock to procblock)
42912+ case 3634LLU: // copy-back deleter (procblock to procblock)
4284742913 {
4284842914 uint64_t *oldstack = (uint64_t *)stack[0];
4284942915 // copy mutable arguments back from call to procblock
@@ -42860,10 +42926,10 @@
4286042926 }
4286142927 Free(160LLU + 1, sizeof(uint64_t), stack);
4286242928 stack = oldstack;
42863- label = 3623LLU; // continue to unroll stack
42929+ label = 3629LLU; // continue to unroll stack
4286442930 break;
4286542931 }
42866- case 3629LLU: // return from procblock to procblock
42932+ case 3635LLU: // return from procblock to procblock
4286742933 {
4286842934 uint64_t *oldstack = (uint64_t *)stack[0];
4286942935 // copy mutable arguments back from call to procblock
@@ -42881,14 +42947,14 @@
4288142947 Free(160LLU + 1, sizeof(uint64_t), stack);
4288242948 stack = oldstack;
4288342949 // delete list
42884- label = 3630LLU; // start to repeat
42950+ label = 3636LLU; // start to repeat
4288542951 break;
4288642952 }
42887- case 3630LLU: // repeat from here
42953+ case 3636LLU: // repeat from here
4288842954 {
4288942955 if(!stack[base + 25])
4289042956 {
42891- label = 3631LLU; // break loop
42957+ label = 3637LLU; // break loop
4289242958 break;
4289342959 }
4289442960
@@ -42899,7 +42965,7 @@
4289942965 newstack[0] = (uint64_t)stack; // backup stack location
4290042966 newstack[1] = 1234567890;
4290142967 newstack[2] = base;
42902- newstack[3] = 3632LLU;
42968+ newstack[3] = 3638LLU;
4290342969 stack = newstack;
4290442970 // set stack-base & callee-address
4290542971 base = 4/*deloffset*/;
@@ -42906,7 +42972,7 @@
4290642972 label = 399LLU; // ~typeidx
4290742973 break;
4290842974 }
42909- case 3632LLU: // return from ~typeidx to procblock
42975+ case 3638LLU: // return from ~typeidx to procblock
4291042976 {
4291142977 stack = (uint64_t *)stack[0];
4291242978 // releasing toplevel container
@@ -42917,21 +42983,21 @@
4291742983 stack[base + 25] = (uint64_t)list->next;
4291842984 Free(1, sizeof(struct listnode), list);
4291942985 }
42920- label = 3630LLU; // repeat
42986+ label = 3636LLU; // repeat
4292142987 break;
4292242988 }
42923- case 3631LLU: // loop finished
42989+ case 3637LLU: // loop finished
4292442990 {
42925- label = 3620LLU; // alternative complete
42991+ label = 3626LLU; // alternative complete
4292642992 break;
4292742993 }
42928- case 3620LLU: // completed if-then-else
42994+ case 3626LLU: // completed if-then-else
4292942995 {
4293042996 printf("%s", "\n label = ");
4293142997 // call printnr from procblock
42932- stack[base + 25LLU] = 3633LLU/*throw to this address*/;
42998+ stack[base + 25LLU] = 3639LLU/*throw to this address*/;
4293342999 stack[base + 26LLU] = base;
42934- stack[base + 27LLU] = 3634LLU;
43000+ stack[base + 27LLU] = 3640LLU;
4293543001 // arguments for call to printnr
4293643002 stack[base + 28LLU] = stack[base + 24]/*labelskip*/;
4293743003 // set stack-base & callee-address
@@ -42939,13 +43005,13 @@
4293943005 label = 18446744073709551590LLU; // printnr
4294043006 break;
4294143007 }
42942- case 3633LLU: // copy-back deleter (printnr to procblock)
43008+ case 3639LLU: // copy-back deleter (printnr to procblock)
4294343009 {
4294443010 // copy mutable arguments back from call to printnr
42945- label = 3589LLU; // continue to roll stack
43011+ label = 3595LLU; // continue to roll stack
4294643012 break;
4294743013 }
42948- case 3634LLU: // return from printnr to procblock
43014+ case 3640LLU: // return from printnr to procblock
4294943015 {
4295043016 // copy mutable arguments back from call to printnr
4295143017 printf("%s", "LLU; // consequent complete");
@@ -42953,9 +43019,9 @@
4295343019 printf("%s", "\n }");
4295443020 printf("%s", "\n case ");
4295543021 // call printnr from procblock
42956- stack[base + 25LLU] = 3635LLU/*throw to this address*/;
43022+ stack[base + 25LLU] = 3641LLU/*throw to this address*/;
4295743023 stack[base + 26LLU] = base;
42958- stack[base + 27LLU] = 3636LLU;
43024+ stack[base + 27LLU] = 3642LLU;
4295943025 // arguments for call to printnr
4296043026 stack[base + 28LLU] = stack[base + 23]/*labelalt*/;
4296143027 // set stack-base & callee-address
@@ -42963,42 +43029,42 @@
4296343029 label = 18446744073709551590LLU; // printnr
4296443030 break;
4296543031 }
42966- case 3635LLU: // copy-back deleter (printnr to procblock)
43032+ case 3641LLU: // copy-back deleter (printnr to procblock)
4296743033 {
4296843034 // copy mutable arguments back from call to printnr
42969- label = 3589LLU; // continue to roll stack
43035+ label = 3595LLU; // continue to roll stack
4297043036 break;
4297143037 }
42972- case 3636LLU: // return from printnr to procblock
43038+ case 3642LLU: // return from printnr to procblock
4297343039 {
4297443040 // copy mutable arguments back from call to printnr
4297543041 printf("%s", "LLU: // alternative");
4297643042 printf("%s", "\n {");
42977- label = 3596LLU; // consequent complete
43043+ label = 3602LLU; // consequent complete
4297843044 break;
4297943045 }
42980- case 3595LLU: // alternative
43046+ case 3601LLU: // alternative
4298143047 {
42982- label = 3638LLU; // skip deleter
43048+ label = 3644LLU; // skip deleter
4298343049 break;
4298443050 }
42985- case 3637LLU: // deleter
43051+ case 3643LLU: // deleter
4298643052 {
4298743053 // throw from procblock
4298843054 if(!stack[base + 25])
4298943055 {
42990- label = 3589LLU; // skip, variable already deleted/unscoped
43056+ label = 3595LLU; // skip, variable already deleted/unscoped
4299143057 break;
4299243058 }
42993- label = 3589LLU; // continue unrolling stack, delete next variable
43059+ label = 3595LLU; // continue unrolling stack, delete next variable
4299443060 break;
4299543061 }
42996- case 3638LLU: // skipped deleter
43062+ case 3644LLU: // skipped deleter
4299743063 {
4299843064 // call equ from procblock
42999- stack[base + 26LLU] = 3639LLU/*throw to this address*/;
43065+ stack[base + 26LLU] = 3645LLU/*throw to this address*/;
4300043066 stack[base + 27LLU] = base;
43001- stack[base + 28LLU] = 3640LLU;
43067+ stack[base + 28LLU] = 3646LLU;
4300243068 // arguments for call to equ
4300343069 stack[base + 30LLU] = stack[base + 16]/*content*/;
4300443070 stack[base + 31LLU] = 747825068330975232LLU;
@@ -43007,13 +43073,13 @@
4300743073 label = 18446744073709551600LLU; // equ
4300843074 break;
4300943075 }
43010- case 3639LLU: // copy-back deleter (equ to procblock)
43076+ case 3645LLU: // copy-back deleter (equ to procblock)
4301143077 {
4301243078 // copy mutable arguments back from call to equ
43013- label = 3589LLU; // continue to roll stack
43079+ label = 3595LLU; // continue to roll stack
4301443080 break;
4301543081 }
43016- case 3640LLU: // return from equ to procblock
43082+ case 3646LLU: // return from equ to procblock
4301743083 {
4301843084 // copy mutable arguments back from call to equ
4301943085 // copy back results provided by call to equ
@@ -43020,37 +43086,37 @@
4302043086 stack[base + 20] = stack[base + 29LLU];
4302143087 if(!stack[base + 20]/*isequal*/)
4302243088 {
43023- label = 3641LLU; // jump to alternative
43089+ label = 3647LLU; // jump to alternative
4302443090 break;
4302543091 }
4302643092
4302743093 // consequent
43028- label = 3644LLU; // skip deleter
43094+ label = 3650LLU; // skip deleter
4302943095 break;
4303043096 }
43031- case 3643LLU: // deleter
43097+ case 3649LLU: // deleter
4303243098 {
4303343099 // throw from procblock
4303443100 if(!stack[base + 25])
4303543101 {
43036- label = 3589LLU; // skip, variable already deleted/unscoped
43102+ label = 3595LLU; // skip, variable already deleted/unscoped
4303743103 break;
4303843104 }
43039- label = 3589LLU; // continue unrolling stack, delete next variable
43105+ label = 3595LLU; // continue unrolling stack, delete next variable
4304043106 break;
4304143107 }
43042- case 3644LLU: // skipped deleter
43108+ case 3650LLU: // skipped deleter
4304343109 {
4304443110 stack[base + 25] = 0;
43045- label = 3642LLU; // consequent complete
43111+ label = 3648LLU; // consequent complete
4304643112 break;
4304743113 }
43048- case 3641LLU: // alternative
43114+ case 3647LLU: // alternative
4304943115 {
4305043116 // call equ from procblock
43051- stack[base + 26LLU] = 3645LLU/*throw to this address*/;
43117+ stack[base + 26LLU] = 3651LLU/*throw to this address*/;
4305243118 stack[base + 27LLU] = base;
43053- stack[base + 28LLU] = 3646LLU;
43119+ stack[base + 28LLU] = 3652LLU;
4305443120 // arguments for call to equ
4305543121 stack[base + 30LLU] = stack[base + 16]/*content*/;
4305643122 stack[base + 31LLU] = 786630200929550336LLU;
@@ -43059,13 +43125,13 @@
4305943125 label = 18446744073709551600LLU; // equ
4306043126 break;
4306143127 }
43062- case 3645LLU: // copy-back deleter (equ to procblock)
43128+ case 3651LLU: // copy-back deleter (equ to procblock)
4306343129 {
4306443130 // copy mutable arguments back from call to equ
43065- label = 3589LLU; // continue to roll stack
43131+ label = 3595LLU; // continue to roll stack
4306643132 break;
4306743133 }
43068- case 3646LLU: // return from equ to procblock
43134+ case 3652LLU: // return from equ to procblock
4306943135 {
4307043136 // copy mutable arguments back from call to equ
4307143137 // copy back results provided by call to equ
@@ -43072,38 +43138,38 @@
4307243138 stack[base + 20] = stack[base + 29LLU];
4307343139 if(!stack[base + 20]/*isequal*/)
4307443140 {
43075- label = 3647LLU; // jump to alternative
43141+ label = 3653LLU; // jump to alternative
4307643142 break;
4307743143 }
4307843144
4307943145 // consequent
43080- label = 3650LLU; // skip deleter
43146+ label = 3656LLU; // skip deleter
4308143147 break;
4308243148 }
43083- case 3649LLU: // deleter
43149+ case 3655LLU: // deleter
4308443150 {
4308543151 // throw from procblock
4308643152 if(!stack[base + 25])
4308743153 {
43088- label = 3589LLU; // skip, variable already deleted/unscoped
43154+ label = 3595LLU; // skip, variable already deleted/unscoped
4308943155 break;
4309043156 }
43091- label = 3589LLU; // continue unrolling stack, delete next variable
43157+ label = 3595LLU; // continue unrolling stack, delete next variable
4309243158 break;
4309343159 }
43094- case 3650LLU: // skipped deleter
43160+ case 3656LLU: // skipped deleter
4309543161 {
4309643162 stack[base + 25] = 1;
43097- label = 3648LLU; // consequent complete
43163+ label = 3654LLU; // consequent complete
4309843164 break;
4309943165 }
43100- case 3647LLU: // alternative
43166+ case 3653LLU: // alternative
4310143167 {
4310243168 fprintf(stderr, "%s", "expected '(' but found token ");
4310343169 // call reporttok from procblock
43104- stack[base + 26LLU] = 3651LLU/*throw to this address*/;
43170+ stack[base + 26LLU] = 3657LLU/*throw to this address*/;
4310543171 stack[base + 27LLU] = base;
43106- stack[base + 28LLU] = 3652LLU;
43172+ stack[base + 28LLU] = 3658LLU;
4310743173 // arguments for call to reporttok
4310843174 stack[base + 29LLU] = stack[base + 15]/*variant*/;
4310943175 stack[base + 30LLU] = stack[base + 16]/*content*/;
@@ -43112,83 +43178,83 @@
4311243178 label = 18446744073709551582LLU; // reporttok
4311343179 break;
4311443180 }
43115- case 3651LLU: // copy-back deleter (reporttok to procblock)
43181+ case 3657LLU: // copy-back deleter (reporttok to procblock)
4311643182 {
4311743183 // copy mutable arguments back from call to reporttok
43118- label = 3589LLU; // continue to roll stack
43184+ label = 3595LLU; // continue to roll stack
4311943185 break;
4312043186 }
43121- case 3652LLU: // return from reporttok to procblock
43187+ case 3658LLU: // return from reporttok to procblock
4312243188 {
4312343189 // copy mutable arguments back from call to reporttok
4312443190 fprintf(stderr, "%s", "\n");
4312543191 {
43126- label = 3589LLU; // throw: begin to unroll stack
43192+ label = 3595LLU; // throw: begin to unroll stack
4312743193 break;
4312843194 }
4312943195
43130- label = 3648LLU; // alternative complete
43196+ label = 3654LLU; // alternative complete
4313143197 break;
4313243198 }
43133- case 3648LLU: // completed if-then-else
43199+ case 3654LLU: // completed if-then-else
4313443200 {
43135- label = 3642LLU; // alternative complete
43201+ label = 3648LLU; // alternative complete
4313643202 break;
4313743203 }
43138- case 3642LLU: // completed if-then-else
43204+ case 3648LLU: // completed if-then-else
4313943205 {
43140- label = 3654LLU; // skip deleter
43206+ label = 3660LLU; // skip deleter
4314143207 break;
4314243208 }
43143- case 3653LLU: // deleter
43209+ case 3659LLU: // deleter
4314443210 {
4314543211 // throw from procblock
4314643212 if(!stack[base + 26])
4314743213 {
43148- label = 3637LLU; // skip, variable already deleted/unscoped
43214+ label = 3643LLU; // skip, variable already deleted/unscoped
4314943215 break;
4315043216 }
43151- label = 3637LLU; // continue unrolling stack, delete next variable
43217+ label = 3643LLU; // continue unrolling stack, delete next variable
4315243218 break;
4315343219 }
43154- case 3654LLU: // skipped deleter
43220+ case 3660LLU: // skipped deleter
4315543221 {
43156- label = 3656LLU; // skip deleter
43222+ label = 3662LLU; // skip deleter
4315743223 break;
4315843224 }
43159- case 3655LLU: // deleter
43225+ case 3661LLU: // deleter
4316043226 {
4316143227 // throw from procblock
4316243228 if(!stack[base + 27])
4316343229 {
43164- label = 3653LLU; // skip, variable already deleted/unscoped
43230+ label = 3659LLU; // skip, variable already deleted/unscoped
4316543231 break;
4316643232 }
43167- label = 3653LLU; // continue unrolling stack, delete next variable
43233+ label = 3659LLU; // continue unrolling stack, delete next variable
4316843234 break;
4316943235 }
43170- case 3656LLU: // skipped deleter
43236+ case 3662LLU: // skipped deleter
4317143237 {
4317243238 // call listtoelem from procblock
43173- stack[base + 28LLU] = 3657LLU/*throw to this address*/;
43239+ stack[base + 28LLU] = 3663LLU/*throw to this address*/;
4317443240 stack[base + 29LLU] = base;
43175- stack[base + 30LLU] = 3658LLU;
43241+ stack[base + 30LLU] = 3664LLU;
4317643242 // arguments for call to listtoelem
4317743243 stack[base + 33LLU] = stack[base + 8]/*fnid*/;
4317843244 stack[base + 34LLU] = stack[base + 19]/*lookahead*/;
4317943245 // set stack-base & callee-address
4318043246 base += 31LLU;
43181- label = 3308LLU; // listtoelem
43247+ label = 3314LLU; // listtoelem
4318243248 break;
4318343249 }
43184- case 3657LLU: // copy-back deleter (listtoelem to procblock)
43250+ case 3663LLU: // copy-back deleter (listtoelem to procblock)
4318543251 {
4318643252 // copy mutable arguments back from call to listtoelem
4318743253 stack[base + 19]/*lookahead*/ = stack[base + 34LLU];
43188- label = 3637LLU; // continue to roll stack
43254+ label = 3643LLU; // continue to roll stack
4318943255 break;
4319043256 }
43191- case 3658LLU: // return from listtoelem to procblock
43257+ case 3664LLU: // return from listtoelem to procblock
4319243258 {
4319343259 // copy mutable arguments back from call to listtoelem
4319443260 stack[base + 19]/*lookahead*/ = stack[base + 34LLU];
@@ -43195,15 +43261,15 @@
4319543261 // copy back results provided by call to listtoelem
4319643262 stack[base + 26] = stack[base + 31LLU];
4319743263 stack[base + 27] = stack[base + 32LLU];
43198- label = 3660LLU; // skip deleter
43264+ label = 3666LLU; // skip deleter
4319943265 break;
4320043266 }
43201- case 3659LLU: // deleter
43267+ case 3665LLU: // deleter
4320243268 {
4320343269 // throw from procblock
4320443270 if(!stack[base + 28])
4320543271 {
43206- label = 3655LLU; // skip, variable already deleted/unscoped
43272+ label = 3661LLU; // skip, variable already deleted/unscoped
4320743273 break;
4320843274 }
4320943275
@@ -43212,7 +43278,7 @@
4321243278 newstack[0] = (uint64_t)stack; // backup stack location
4321343279 newstack[1] = 1234567890;
4321443280 newstack[2] = base;
43215- newstack[3] = 3661LLU;
43281+ newstack[3] = 3667LLU;
4321643282 stack = newstack;
4321743283 // set stack-base & callee-address
4321843284 base = 4/*deloffset*/;
@@ -43219,21 +43285,21 @@
4321943285 label = 486LLU; // ~letdef
4322043286 break;
4322143287 }
43222- case 3661LLU: // return from ~letdef to procblock
43288+ case 3667LLU: // return from ~letdef to procblock
4322343289 {
4322443290 stack = (uint64_t *)stack[0];
4322543291 // releasing toplevel container
4322643292 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 28] - sizeof(uint64_t) * 4));
4322743293
43228- label = 3655LLU; // continue unrolling stack, delete next variable
43294+ label = 3661LLU; // continue unrolling stack, delete next variable
4322943295 break;
4323043296 }
43231- case 3660LLU: // skipped deleter
43297+ case 3666LLU: // skipped deleter
4323243298 {
4323343299 // call FindLet from procblock
43234- stack[base + 29LLU] = 3662LLU/*throw to this address*/;
43300+ stack[base + 29LLU] = 3668LLU/*throw to this address*/;
4323543301 stack[base + 30LLU] = base;
43236- stack[base + 31LLU] = 3663LLU;
43302+ stack[base + 31LLU] = 3669LLU;
4323743303 // arguments for call to FindLet
4323843304 stack[base + 33LLU] = stack[base + 8]/*fnid*/;
4323943305 stack[base + 34LLU] = stack[base + 26]/*listid*/;
@@ -43244,13 +43310,13 @@
4324443310 label = 619LLU; // FindLet
4324543311 break;
4324643312 }
43247- case 3662LLU: // copy-back deleter (FindLet to procblock)
43313+ case 3668LLU: // copy-back deleter (FindLet to procblock)
4324843314 {
4324943315 // copy mutable arguments back from call to FindLet
43250- label = 3655LLU; // continue to roll stack
43316+ label = 3661LLU; // continue to roll stack
4325143317 break;
4325243318 }
43253- case 3663LLU: // return from FindLet to procblock
43319+ case 3669LLU: // return from FindLet to procblock
4325443320 {
4325543321 // copy mutable arguments back from call to FindLet
4325643322 // copy back results provided by call to FindLet
@@ -43257,7 +43323,7 @@
4325743323 stack[base + 28] = stack[base + 32LLU];
4325843324 if(/*letdef*/0 != ((uint64_t *)(stack[base + 28]/*letdef*/))[0])
4325943325 {
43260- label = 3665LLU; // jump to alternative
43326+ label = 3671LLU; // jump to alternative
4326143327 break;
4326243328 }
4326343329
@@ -43271,28 +43337,28 @@
4327143337 printf("%s", "\n { // if ");
4327243338 if(!stack[base + 25]/*consume*/)
4327343339 {
43274- label = 3667LLU; // jump to alternative
43340+ label = 3673LLU; // jump to alternative
4327543341 break;
4327643342 }
4327743343
4327843344 // consequent
4327943345 printf("%s", "pop");
43280- label = 3668LLU; // consequent complete
43346+ label = 3674LLU; // consequent complete
4328143347 break;
4328243348 }
43283- case 3667LLU: // alternative
43349+ case 3673LLU: // alternative
4328443350 {
4328543351 printf("%s", "next");
43286- label = 3668LLU; // alternative complete
43352+ label = 3674LLU; // alternative complete
4328743353 break;
4328843354 }
43289- case 3668LLU: // completed if-then-else
43355+ case 3674LLU: // completed if-then-else
4329043356 {
4329143357 printf("%s", "\n struct listnode *list = (struct listnode *)");
4329243358 // call emitvaridx from procblock
43293- stack[base + 34LLU] = 3669LLU/*throw to this address*/;
43359+ stack[base + 34LLU] = 3675LLU/*throw to this address*/;
4329443360 stack[base + 35LLU] = base;
43295- stack[base + 36LLU] = 3670LLU;
43361+ stack[base + 36LLU] = 3676LLU;
4329643362 // arguments for call to emitvaridx
4329743363 stack[base + 37LLU] = stack[base + 31]/*listindex*/;
4329843364 // set stack-base & callee-address
@@ -43300,20 +43366,20 @@
4330043366 label = 745LLU; // emitvaridx
4330143367 break;
4330243368 }
43303- case 3669LLU: // copy-back deleter (emitvaridx to procblock)
43369+ case 3675LLU: // copy-back deleter (emitvaridx to procblock)
4330443370 {
4330543371 // copy mutable arguments back from call to emitvaridx
43306- label = 3666LLU; // continue to roll stack
43372+ label = 3672LLU; // continue to roll stack
4330743373 break;
4330843374 }
43309- case 3670LLU: // return from emitvaridx to procblock
43375+ case 3676LLU: // return from emitvaridx to procblock
4331043376 {
4331143377 // copy mutable arguments back from call to emitvaridx
4331243378 printf("%s", "/*");
4331343379 // call printid from procblock
43314- stack[base + 34LLU] = 3671LLU/*throw to this address*/;
43380+ stack[base + 34LLU] = 3677LLU/*throw to this address*/;
4331543381 stack[base + 35LLU] = base;
43316- stack[base + 36LLU] = 3672LLU;
43382+ stack[base + 36LLU] = 3678LLU;
4331743383 // arguments for call to printid
4331843384 stack[base + 37LLU] = stack[base + 30]/*listname*/;
4331943385 // set stack-base & callee-address
@@ -43321,26 +43387,26 @@
4332143387 label = 18446744073709551587LLU; // printid
4332243388 break;
4332343389 }
43324- case 3671LLU: // copy-back deleter (printid to procblock)
43390+ case 3677LLU: // copy-back deleter (printid to procblock)
4332543391 {
4332643392 // copy mutable arguments back from call to printid
43327- label = 3666LLU; // continue to roll stack
43393+ label = 3672LLU; // continue to roll stack
4332843394 break;
4332943395 }
43330- case 3672LLU: // return from printid to procblock
43396+ case 3678LLU: // return from printid to procblock
4333143397 {
4333243398 // copy mutable arguments back from call to printid
4333343399 printf("%s", "*/;");
4333443400 printf("%s", "\n if(!list)");
43335- label = 3674LLU; // skip deleter
43401+ label = 3680LLU; // skip deleter
4333643402 break;
4333743403 }
43338- case 3673LLU: // deleter
43404+ case 3679LLU: // deleter
4333943405 {
4334043406 // throw from procblock
4334143407 if(!stack[base + 34])
4334243408 {
43343- label = 3666LLU; // skip, variable already deleted/unscoped
43409+ label = 3672LLU; // skip, variable already deleted/unscoped
4334443410 break;
4334543411 }
4334643412
@@ -43349,7 +43415,7 @@
4334943415 newstack[0] = (uint64_t)stack; // backup stack location
4335043416 newstack[1] = 1234567890;
4335143417 newstack[2] = base;
43352- newstack[3] = 3675LLU;
43418+ newstack[3] = 3681LLU;
4335343419 stack = newstack;
4335443420 // set stack-base & callee-address
4335543421 base = 4/*deloffset*/;
@@ -43356,21 +43422,21 @@
4335643422 label = 562LLU; // ~scope
4335743423 break;
4335843424 }
43359- case 3675LLU: // return from ~scope to procblock
43425+ case 3681LLU: // return from ~scope to procblock
4336043426 {
4336143427 stack = (uint64_t *)stack[0];
4336243428 // releasing toplevel container
4336343429 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 34] - sizeof(uint64_t) * 4));
4336443430
43365- label = 3666LLU; // continue unrolling stack, delete next variable
43431+ label = 3672LLU; // continue unrolling stack, delete next variable
4336643432 break;
4336743433 }
43368- case 3674LLU: // skipped deleter
43434+ case 3680LLU: // skipped deleter
4336943435 {
4337043436 // call linkscope from procblock
43371- stack[base + 35LLU] = 3676LLU/*throw to this address*/;
43437+ stack[base + 35LLU] = 3682LLU/*throw to this address*/;
4337243438 stack[base + 36LLU] = base;
43373- stack[base + 37LLU] = 3677LLU;
43439+ stack[base + 37LLU] = 3683LLU;
4337443440 // arguments for call to linkscope
4337543441 stack[base + 39LLU] = stack[base + 3]/*scope*/;
4337643442 // set stack-base & callee-address
@@ -43378,13 +43444,13 @@
4337843444 label = 589LLU; // linkscope
4337943445 break;
4338043446 }
43381- case 3676LLU: // copy-back deleter (linkscope to procblock)
43447+ case 3682LLU: // copy-back deleter (linkscope to procblock)
4338243448 {
4338343449 // copy mutable arguments back from call to linkscope
43384- label = 3666LLU; // continue to roll stack
43450+ label = 3672LLU; // continue to roll stack
4338543451 break;
4338643452 }
43387- case 3677LLU: // return from linkscope to procblock
43453+ case 3683LLU: // return from linkscope to procblock
4338843454 {
4338943455 // copy mutable arguments back from call to linkscope
4339043456 // copy back results provided by call to linkscope
@@ -43403,26 +43469,26 @@
4340343469 /*scopes*/stack[base + 2] = (uint64_t)list;
4340443470 MOVE(&list->data, &stack[base + 34]/*newscope*/);
4340543471 }
43406- label = 3679LLU; // skip deleter
43472+ label = 3685LLU; // skip deleter
4340743473 break;
4340843474 }
43409- case 3678LLU: // deleter
43475+ case 3684LLU: // deleter
4341043476 {
4341143477 // throw from procblock
4341243478 if(!stack[base + 34])
4341343479 {
43414- label = 3666LLU; // skip, variable already deleted/unscoped
43480+ label = 3672LLU; // skip, variable already deleted/unscoped
4341543481 break;
4341643482 }
43417- label = 3666LLU; // continue unrolling stack, delete next variable
43483+ label = 3672LLU; // continue unrolling stack, delete next variable
4341843484 break;
4341943485 }
43420- case 3679LLU: // skipped deleter
43486+ case 3685LLU: // skipped deleter
4342143487 {
4342243488 // call getdeladdr from procblock
43423- stack[base + 35LLU] = 3680LLU/*throw to this address*/;
43489+ stack[base + 35LLU] = 3686LLU/*throw to this address*/;
4342443490 stack[base + 36LLU] = base;
43425- stack[base + 37LLU] = 3681LLU;
43491+ stack[base + 37LLU] = 3687LLU;
4342643492 // arguments for call to getdeladdr
4342743493 stack[base + 39LLU] = stack[base + 3]/*scope*/;
4342843494 // set stack-base & callee-address
@@ -43430,21 +43496,21 @@
4343043496 label = 596LLU; // getdeladdr
4343143497 break;
4343243498 }
43433- case 3680LLU: // copy-back deleter (getdeladdr to procblock)
43499+ case 3686LLU: // copy-back deleter (getdeladdr to procblock)
4343443500 {
4343543501 // copy mutable arguments back from call to getdeladdr
43436- label = 3666LLU; // continue to roll stack
43502+ label = 3672LLU; // continue to roll stack
4343743503 break;
4343843504 }
43439- case 3681LLU: // return from getdeladdr to procblock
43505+ case 3687LLU: // return from getdeladdr to procblock
4344043506 {
4344143507 // copy mutable arguments back from call to getdeladdr
4344243508 // copy back results provided by call to getdeladdr
4344343509 stack[base + 34] = stack[base + 38LLU];
4344443510 // call add from procblock
43445- stack[base + 35LLU] = 3682LLU/*throw to this address*/;
43511+ stack[base + 35LLU] = 3688LLU/*throw to this address*/;
4344643512 stack[base + 36LLU] = base;
43447- stack[base + 37LLU] = 3683LLU;
43513+ stack[base + 37LLU] = 3689LLU;
4344843514 // arguments for call to add
4344943515 stack[base + 39LLU] = 1LLU;
4345043516 stack[base + 40LLU] = stack[base + 17]/*label*/;
@@ -43453,43 +43519,43 @@
4345343519 label = 18446744073709551605LLU; // add
4345443520 break;
4345543521 }
43456- case 3682LLU: // copy-back deleter (add to procblock)
43522+ case 3688LLU: // copy-back deleter (add to procblock)
4345743523 {
4345843524 // copy mutable arguments back from call to add
43459- label = 3678LLU; // continue to roll stack
43525+ label = 3684LLU; // continue to roll stack
4346043526 break;
4346143527 }
43462- case 3683LLU: // return from add to procblock
43528+ case 3689LLU: // return from add to procblock
4346343529 {
4346443530 // copy mutable arguments back from call to add
4346543531 // copy back results provided by call to add
4346643532 stack[base + 17] = stack[base + 38LLU];
43467- label = 3685LLU; // skip deleter
43533+ label = 3691LLU; // skip deleter
4346843534 break;
4346943535 }
43470- case 3684LLU: // deleter
43536+ case 3690LLU: // deleter
4347143537 {
4347243538 // throw from procblock
4347343539 if(!stack[base + 35])
4347443540 {
43475- label = 3678LLU; // skip, variable already deleted/unscoped
43541+ label = 3684LLU; // skip, variable already deleted/unscoped
4347643542 break;
4347743543 }
43478- label = 3678LLU; // continue unrolling stack, delete next variable
43544+ label = 3684LLU; // continue unrolling stack, delete next variable
4347943545 break;
4348043546 }
43481- case 3685LLU: // skipped deleter
43547+ case 3691LLU: // skipped deleter
4348243548 {
4348343549 stack[base + 35] = stack[base + 17]/*label*/;
43484- label = 3687LLU; // skip deleter
43550+ label = 3693LLU; // skip deleter
4348543551 break;
4348643552 }
43487- case 3686LLU: // deleter
43553+ case 3692LLU: // deleter
4348843554 {
4348943555 // throw from procblock
4349043556 if(!stack[base + 36])
4349143557 {
43492- label = 3684LLU; // skip, variable already deleted/unscoped
43558+ label = 3690LLU; // skip, variable already deleted/unscoped
4349343559 break;
4349443560 }
4349543561
@@ -43498,7 +43564,7 @@
4349843564 newstack[0] = (uint64_t)stack; // backup stack location
4349943565 newstack[1] = 1234567890;
4350043566 newstack[2] = base;
43501- newstack[3] = 3688LLU;
43567+ newstack[3] = 3694LLU;
4350243568 stack = newstack;
4350343569 // set stack-base & callee-address
4350443570 base = 4/*deloffset*/;
@@ -43505,21 +43571,21 @@
4350543571 label = 562LLU; // ~scope
4350643572 break;
4350743573 }
43508- case 3688LLU: // return from ~scope to procblock
43574+ case 3694LLU: // return from ~scope to procblock
4350943575 {
4351043576 stack = (uint64_t *)stack[0];
4351143577 // releasing toplevel container
4351243578 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4));
4351343579
43514- label = 3684LLU; // continue unrolling stack, delete next variable
43580+ label = 3690LLU; // continue unrolling stack, delete next variable
4351543581 break;
4351643582 }
43517- case 3687LLU: // skipped deleter
43583+ case 3693LLU: // skipped deleter
4351843584 {
4351943585 // call chainscope from procblock
43520- stack[base + 37LLU] = 3689LLU/*throw to this address*/;
43586+ stack[base + 37LLU] = 3695LLU/*throw to this address*/;
4352143587 stack[base + 38LLU] = base;
43522- stack[base + 39LLU] = 3690LLU;
43588+ stack[base + 39LLU] = 3696LLU;
4352343589 // arguments for call to chainscope
4352443590 stack[base + 41LLU] = stack[base + 35]/*labelfail*/;
4352543591 // set stack-base & callee-address
@@ -43527,13 +43593,13 @@
4352743593 label = 579LLU; // chainscope
4352843594 break;
4352943595 }
43530- case 3689LLU: // copy-back deleter (chainscope to procblock)
43596+ case 3695LLU: // copy-back deleter (chainscope to procblock)
4353143597 {
4353243598 // copy mutable arguments back from call to chainscope
43533- label = 3684LLU; // continue to roll stack
43599+ label = 3690LLU; // continue to roll stack
4353443600 break;
4353543601 }
43536- case 3690LLU: // return from chainscope to procblock
43602+ case 3696LLU: // return from chainscope to procblock
4353743603 {
4353843604 // copy mutable arguments back from call to chainscope
4353943605 // copy back results provided by call to chainscope
@@ -43554,7 +43620,7 @@
4355443620 }
4355543621 if(/*typelist*/1 != ((uint64_t *)(stack[base + 29]/*listtype*/))[0])
4355643622 {
43557- label = 3692LLU; // jump to alternative
43623+ label = 3698LLU; // jump to alternative
4355843624 break;
4355943625 }
4356043626
@@ -43561,42 +43627,42 @@
4356143627 /*subtype*/stack[base + 36] = ((uint64_t **)(stack[base + 29]/*listtype*/))[1][0]/*subtype*/;
4356243628
4356343629 // case
43564- label = 3695LLU; // skip deleter
43630+ label = 3701LLU; // skip deleter
4356543631 break;
4356643632 }
43567- case 3694LLU: // deleter
43633+ case 3700LLU: // deleter
4356843634 {
4356943635 // throw from procblock
4357043636 if(!stack[base + 37])
4357143637 {
43572- label = 3693LLU; // skip, variable already deleted/unscoped
43638+ label = 3699LLU; // skip, variable already deleted/unscoped
4357343639 break;
4357443640 }
43575- label = 3693LLU; // continue unrolling stack, delete next variable
43641+ label = 3699LLU; // continue unrolling stack, delete next variable
4357643642 break;
4357743643 }
43578- case 3695LLU: // skipped deleter
43644+ case 3701LLU: // skipped deleter
4357943645 {
43580- label = 3697LLU; // skip deleter
43646+ label = 3703LLU; // skip deleter
4358143647 break;
4358243648 }
43583- case 3696LLU: // deleter
43649+ case 3702LLU: // deleter
4358443650 {
4358543651 // throw from procblock
4358643652 if(!stack[base + 38])
4358743653 {
43588- label = 3693LLU; // skip, variable already deleted/unscoped
43654+ label = 3699LLU; // skip, variable already deleted/unscoped
4358943655 break;
4359043656 }
43591- label = 3693LLU; // continue unrolling stack, delete next variable
43657+ label = 3699LLU; // continue unrolling stack, delete next variable
4359243658 break;
4359343659 }
43594- case 3697LLU: // skipped deleter
43660+ case 3703LLU: // skipped deleter
4359543661 {
4359643662 // call isparam from procblock
43597- stack[base + 39LLU] = 3698LLU/*throw to this address*/;
43663+ stack[base + 39LLU] = 3704LLU/*throw to this address*/;
4359843664 stack[base + 40LLU] = base;
43599- stack[base + 41LLU] = 3699LLU;
43665+ stack[base + 41LLU] = 3705LLU;
4360043666 // arguments for call to isparam
4360143667 stack[base + 43LLU] = stack[base + 10]/*fnrescount*/;
4360243668 stack[base + 44LLU] = stack[base + 11]/*fnargcount*/;
@@ -43606,13 +43672,13 @@
4360643672 label = 1671LLU; // isparam
4360743673 break;
4360843674 }
43609- case 3698LLU: // copy-back deleter (isparam to procblock)
43675+ case 3704LLU: // copy-back deleter (isparam to procblock)
4361043676 {
4361143677 // copy mutable arguments back from call to isparam
43612- label = 3693LLU; // continue to roll stack
43678+ label = 3699LLU; // continue to roll stack
4361343679 break;
4361443680 }
43615- case 3699LLU: // return from isparam to procblock
43681+ case 3705LLU: // return from isparam to procblock
4361643682 {
4361743683 // copy mutable arguments back from call to isparam
4361843684 // copy back results provided by call to isparam
@@ -43619,37 +43685,37 @@
4361943685 stack[base + 38] = stack[base + 42LLU];
4362043686 if(!stack[base + 32]/*listmut*/)
4362143687 {
43622- label = 3700LLU; // jump to alternative
43688+ label = 3706LLU; // jump to alternative
4362343689 break;
4362443690 }
4362543691
4362643692 // consequent
43627- label = 3703LLU; // skip deleter
43693+ label = 3709LLU; // skip deleter
4362843694 break;
4362943695 }
43630- case 3702LLU: // deleter
43696+ case 3708LLU: // deleter
4363143697 {
4363243698 // throw from procblock
4363343699 if(!stack[base + 37])
4363443700 {
43635- label = 3696LLU; // skip, variable already deleted/unscoped
43701+ label = 3702LLU; // skip, variable already deleted/unscoped
4363643702 break;
4363743703 }
43638- label = 3696LLU; // continue unrolling stack, delete next variable
43704+ label = 3702LLU; // continue unrolling stack, delete next variable
4363943705 break;
4364043706 }
43641- case 3703LLU: // skipped deleter
43707+ case 3709LLU: // skipped deleter
4364243708 {
4364343709 stack[base + 37] = 0;
43644- label = 3701LLU; // consequent complete
43710+ label = 3707LLU; // consequent complete
4364543711 break;
4364643712 }
43647- case 3700LLU: // alternative
43713+ case 3706LLU: // alternative
4364843714 {
4364943715 // call or from procblock
43650- stack[base + 39LLU] = 3704LLU/*throw to this address*/;
43716+ stack[base + 39LLU] = 3710LLU/*throw to this address*/;
4365143717 stack[base + 40LLU] = base;
43652- stack[base + 41LLU] = 3705LLU;
43718+ stack[base + 41LLU] = 3711LLU;
4365343719 // arguments for call to or
4365443720 stack[base + 43LLU] = stack[base + 33]/*substruct*/;
4365543721 stack[base + 44LLU] = stack[base + 38]/*listparam*/;
@@ -43658,42 +43724,42 @@
4365843724 label = 18446744073709551611LLU; // or
4365943725 break;
4366043726 }
43661- case 3704LLU: // copy-back deleter (or to procblock)
43727+ case 3710LLU: // copy-back deleter (or to procblock)
4366243728 {
4366343729 // copy mutable arguments back from call to or
43664- label = 3696LLU; // continue to roll stack
43730+ label = 3702LLU; // continue to roll stack
4366543731 break;
4366643732 }
43667- case 3705LLU: // return from or to procblock
43733+ case 3711LLU: // return from or to procblock
4366843734 {
4366943735 // copy mutable arguments back from call to or
4367043736 // copy back results provided by call to or
4367143737 stack[base + 37] = stack[base + 42LLU];
43672- label = 3701LLU; // alternative complete
43738+ label = 3707LLU; // alternative complete
4367343739 break;
4367443740 }
43675- case 3701LLU: // completed if-then-else
43741+ case 3707LLU: // completed if-then-else
4367643742 {
43677- label = 3707LLU; // skip deleter
43743+ label = 3713LLU; // skip deleter
4367843744 break;
4367943745 }
43680- case 3706LLU: // deleter
43746+ case 3712LLU: // deleter
4368143747 {
4368243748 // throw from procblock
4368343749 if(!stack[base + 38])
4368443750 {
43685- label = 3694LLU; // skip, variable already deleted/unscoped
43751+ label = 3700LLU; // skip, variable already deleted/unscoped
4368643752 break;
4368743753 }
43688- label = 3694LLU; // continue unrolling stack, delete next variable
43754+ label = 3700LLU; // continue unrolling stack, delete next variable
4368943755 break;
4369043756 }
43691- case 3707LLU: // skipped deleter
43757+ case 3713LLU: // skipped deleter
4369243758 {
4369343759 // call newvarraw from procblock
43694- stack[base + 39LLU] = 3708LLU/*throw to this address*/;
43760+ stack[base + 39LLU] = 3714LLU/*throw to this address*/;
4369543761 stack[base + 40LLU] = base;
43696- stack[base + 41LLU] = 3709LLU;
43762+ stack[base + 41LLU] = 3715LLU;
4369743763 // arguments for call to newvarraw
4369843764 stack[base + 43LLU] = stack[base + 36]/*subtype*/;
4369943765 stack[base + 44LLU] = stack[base + 27]/*elemid*/;
@@ -43709,16 +43775,16 @@
4370943775 label = 759LLU; // newvarraw
4371043776 break;
4371143777 }
43712- case 3708LLU: // copy-back deleter (newvarraw to procblock)
43778+ case 3714LLU: // copy-back deleter (newvarraw to procblock)
4371343779 {
4371443780 // copy mutable arguments back from call to newvarraw
4371543781 stack[base + 3]/*scope*/ = stack[base + 50LLU];
4371643782 stack[base + 18]/*varcount*/ = stack[base + 49LLU];
4371743783 stack[base + 12]/*fnmaxcount*/ = stack[base + 48LLU];
43718- label = 3694LLU; // continue to roll stack
43784+ label = 3700LLU; // continue to roll stack
4371943785 break;
4372043786 }
43721- case 3709LLU: // return from newvarraw to procblock
43787+ case 3715LLU: // return from newvarraw to procblock
4372243788 {
4372343789 // copy mutable arguments back from call to newvarraw
4372443790 stack[base + 3]/*scope*/ = stack[base + 50LLU];
@@ -43729,9 +43795,9 @@
4372943795 printf("%s", "\n {");
4373043796 printf("%s", "\n label = ");
4373143797 // call printnr from procblock
43732