OSDN -- Develop and Download Open Source Software
  • R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1170 (tree)
Time2021-02-24 06:40:26
Authorjakobthomsen

Log Message

cleanup

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1169)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1170)
@@ -1137,11 +1137,11 @@
11371137 // throw from isalpha
11381138 if(!stack[base + 2])
11391139 {
1140- fprintf(stderr, "in function isalpha: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1140+ fprintf(stderr, "in function isalpha: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
11411141 label = 30LLU; // skip, variable already deleted/unscoped
11421142 break;
11431143 }
1144- fprintf(stderr, "in function isalpha: unrolling stack, variable u64 \n");
1144+ fprintf(stderr, "in function isalpha: unrolling stack, variable u64 isequal\n");
11451145 label = 30LLU; // continue unrolling stack, delete next variable
11461146 break;
11471147 }
@@ -1321,11 +1321,11 @@
13211321 // throw from isspace
13221322 if(!stack[base + 2])
13231323 {
1324- fprintf(stderr, "in function isspace: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1324+ fprintf(stderr, "in function isspace: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
13251325 label = 48LLU; // skip, variable already deleted/unscoped
13261326 break;
13271327 }
1328- fprintf(stderr, "in function isspace: unrolling stack, variable u64 \n");
1328+ fprintf(stderr, "in function isspace: unrolling stack, variable u64 isequal\n");
13291329 label = 48LLU; // continue unrolling stack, delete next variable
13301330 break;
13311331 }
@@ -1603,11 +1603,11 @@
16031603 // throw from skip
16041604 if(!stack[base + 1])
16051605 {
1606- fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1606+ fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 lookahead\n");
16071607 label = 76LLU; // skip, variable already deleted/unscoped
16081608 break;
16091609 }
1610- fprintf(stderr, "in function skip: unrolling stack, variable u64 \n");
1610+ fprintf(stderr, "in function skip: unrolling stack, variable u64 lookahead\n");
16111611 label = 76LLU; // continue unrolling stack, delete next variable
16121612 break;
16131613 }
@@ -1622,11 +1622,11 @@
16221622 // throw from skip
16231623 if(!stack[base + 2])
16241624 {
1625- fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 \n");
1625+ fprintf(stderr, "in function skip: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
16261626 label = 77LLU; // skip, variable already deleted/unscoped
16271627 break;
16281628 }
1629- fprintf(stderr, "in function skip: unrolling stack, variable u64 \n");
1629+ fprintf(stderr, "in function skip: unrolling stack, variable u64 isequal\n");
16301630 label = 77LLU; // continue unrolling stack, delete next variable
16311631 break;
16321632 }
@@ -2583,11 +2583,11 @@
25832583 // throw from existsid
25842584 if(!stack[base + 3])
25852585 {
2586- fprintf(stderr, "in function existsid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2586+ fprintf(stderr, "in function existsid: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
25872587 label = 146LLU; // skip, variable already deleted/unscoped
25882588 break;
25892589 }
2590- fprintf(stderr, "in function existsid: unrolling stack, variable u64 \n");
2590+ fprintf(stderr, "in function existsid: unrolling stack, variable u64 found\n");
25912591 label = 146LLU; // continue unrolling stack, delete next variable
25922592 break;
25932593 }
@@ -2708,11 +2708,11 @@
27082708 // throw from issimple
27092709 if(!stack[base + 4])
27102710 {
2711- fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2711+ fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
27122712 label = 159LLU; // skip, variable already deleted/unscoped
27132713 break;
27142714 }
2715- fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2715+ fprintf(stderr, "in function issimple: unrolling stack, variable u64 isequal\n");
27162716 label = 159LLU; // continue unrolling stack, delete next variable
27172717 break;
27182718 }
@@ -2884,11 +2884,11 @@
28842884 // throw from isident
28852885 if(!stack[base + 4])
28862886 {
2887- fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2887+ fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
28882888 label = 177LLU; // skip, variable already deleted/unscoped
28892889 break;
28902890 }
2891- fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2891+ fprintf(stderr, "in function isident: unrolling stack, variable u64 isequal\n");
28922892 label = 177LLU; // continue unrolling stack, delete next variable
28932893 break;
28942894 }
@@ -3249,11 +3249,11 @@
32493249 // throw from matchsym
32503250 if(!stack[base + 3])
32513251 {
3252- fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3252+ fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 variant\n");
32533253 label = 213LLU; // skip, variable already deleted/unscoped
32543254 break;
32553255 }
3256- fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3256+ fprintf(stderr, "in function matchsym: unrolling stack, variable u64 variant\n");
32573257 label = 213LLU; // continue unrolling stack, delete next variable
32583258 break;
32593259 }
@@ -3268,11 +3268,11 @@
32683268 // throw from matchsym
32693269 if(!stack[base + 4])
32703270 {
3271- fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3271+ fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 content\n");
32723272 label = 214LLU; // skip, variable already deleted/unscoped
32733273 break;
32743274 }
3275- fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3275+ fprintf(stderr, "in function matchsym: unrolling stack, variable u64 content\n");
32763276 label = 214LLU; // continue unrolling stack, delete next variable
32773277 break;
32783278 }
@@ -3313,11 +3313,11 @@
33133313 // throw from matchsym
33143314 if(!stack[base + 5])
33153315 {
3316- fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3316+ fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 isqual\n");
33173317 label = 216LLU; // skip, variable already deleted/unscoped
33183318 break;
33193319 }
3320- fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3320+ fprintf(stderr, "in function matchsym: unrolling stack, variable u64 isqual\n");
33213321 label = 216LLU; // continue unrolling stack, delete next variable
33223322 break;
33233323 }
@@ -3571,11 +3571,11 @@
35713571 // throw from matchid
35723572 if(!stack[base + 3])
35733573 {
3574- fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3574+ fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 variant\n");
35753575 label = 243LLU; // skip, variable already deleted/unscoped
35763576 break;
35773577 }
3578- fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3578+ fprintf(stderr, "in function matchid: unrolling stack, variable u64 variant\n");
35793579 label = 243LLU; // continue unrolling stack, delete next variable
35803580 break;
35813581 }
@@ -3590,11 +3590,11 @@
35903590 // throw from matchid
35913591 if(!stack[base + 4])
35923592 {
3593- fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3593+ fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 content\n");
35943594 label = 244LLU; // skip, variable already deleted/unscoped
35953595 break;
35963596 }
3597- fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3597+ fprintf(stderr, "in function matchid: unrolling stack, variable u64 content\n");
35983598 label = 244LLU; // continue unrolling stack, delete next variable
35993599 break;
36003600 }
@@ -3635,11 +3635,11 @@
36353635 // throw from matchid
36363636 if(!stack[base + 5])
36373637 {
3638- fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3638+ fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 isqual\n");
36393639 label = 246LLU; // skip, variable already deleted/unscoped
36403640 break;
36413641 }
3642- fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3642+ fprintf(stderr, "in function matchid: unrolling stack, variable u64 isqual\n");
36433643 label = 246LLU; // continue unrolling stack, delete next variable
36443644 break;
36453645 }
@@ -3892,11 +3892,11 @@
38923892 // throw from isncs
38933893 if(!stack[base + 2])
38943894 {
3895- fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3895+ fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
38963896 label = 273LLU; // skip, variable already deleted/unscoped
38973897 break;
38983898 }
3899- fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
3899+ fprintf(stderr, "in function isncs: unrolling stack, variable u64 isequal\n");
39003900 label = 273LLU; // continue unrolling stack, delete next variable
39013901 break;
39023902 }
@@ -4984,11 +4984,11 @@
49844984 // throw from copytypeid
49854985 if(!stack[base + 5])
49864986 {
4987- fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4987+ fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable u64 copyid\n");
49884988 label = 362LLU; // skip, variable already deleted/unscoped
49894989 break;
49904990 }
4991- fprintf(stderr, "in function copytypeid: unrolling stack, variable u64 \n");
4991+ fprintf(stderr, "in function copytypeid: unrolling stack, variable u64 copyid\n");
49924992 label = 362LLU; // continue unrolling stack, delete next variable
49934993 break;
49944994 }
@@ -5298,11 +5298,11 @@
52985298 // throw from cptypeidx
52995299 if(!stack[base + 5])
53005300 {
5301- fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5301+ fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable u64 cidx\n");
53025302 label = 386LLU; // skip, variable already deleted/unscoped
53035303 break;
53045304 }
5305- fprintf(stderr, "in function cptypeidx: unrolling stack, variable u64 \n");
5305+ fprintf(stderr, "in function cptypeidx: unrolling stack, variable u64 cidx\n");
53065306 label = 386LLU; // continue unrolling stack, delete next variable
53075307 break;
53085308 }
@@ -5746,11 +5746,11 @@
57465746 // throw from copyparam
57475747 if(!stack[base + 5])
57485748 {
5749- fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5749+ fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable u64 copymut\n");
57505750 label = 421LLU; // skip, variable already deleted/unscoped
57515751 break;
57525752 }
5753- fprintf(stderr, "in function copyparam: unrolling stack, variable u64 \n");
5753+ fprintf(stderr, "in function copyparam: unrolling stack, variable u64 copymut\n");
57545754 label = 421LLU; // continue unrolling stack, delete next variable
57555755 break;
57565756 }
@@ -5932,11 +5932,11 @@
59325932 // throw from lookparam
59335933 if(!stack[base + 3])
59345934 {
5935- fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5935+ fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
59365936 label = 439LLU; // skip, variable already deleted/unscoped
59375937 break;
59385938 }
5939- fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
5939+ fprintf(stderr, "in function lookparam: unrolling stack, variable u64 found\n");
59405940 label = 439LLU; // continue unrolling stack, delete next variable
59415941 break;
59425942 }
@@ -6155,11 +6155,11 @@
61556155 // throw from mkletdummy
61566156 if(!stack[base + 1])
61576157 {
6158- fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6158+ fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newid\n");
61596159 label = 461LLU; // skip, variable already deleted/unscoped
61606160 break;
61616161 }
6162- fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6162+ fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newid\n");
61636163 label = 461LLU; // continue unrolling stack, delete next variable
61646164 break;
61656165 }
@@ -6174,11 +6174,11 @@
61746174 // throw from mkletdummy
61756175 if(!stack[base + 2])
61766176 {
6177- fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable type \n");
6177+ fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable type newtype\n");
61786178 label = 462LLU; // skip, variable already deleted/unscoped
61796179 break;
61806180 }
6181- fprintf(stderr, "in function mkletdummy: unrolling stack, variable type \n");
6181+ fprintf(stderr, "in function mkletdummy: unrolling stack, variable type newtype\n");
61826182
61836183 uint64_t *newstack = (uint64_t *)(stack[base + 2] - sizeof(uint64_t) * 4);
61846184 // call ~type from mkletdummy
@@ -6221,11 +6221,11 @@
62216221 // throw from mkletdummy
62226222 if(!stack[base + 3])
62236223 {
6224- fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6224+ fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newindex\n");
62256225 label = 464LLU; // skip, variable already deleted/unscoped
62266226 break;
62276227 }
6228- fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6228+ fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newindex\n");
62296229 label = 464LLU; // continue unrolling stack, delete next variable
62306230 break;
62316231 }
@@ -6240,11 +6240,11 @@
62406240 // throw from mkletdummy
62416241 if(!stack[base + 4])
62426242 {
6243- fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6243+ fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 newmutable\n");
62446244 label = 467LLU; // skip, variable already deleted/unscoped
62456245 break;
62466246 }
6247- fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6247+ fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 newmutable\n");
62486248 label = 467LLU; // continue unrolling stack, delete next variable
62496249 break;
62506250 }
@@ -6259,11 +6259,11 @@
62596259 // throw from mkletdummy
62606260 if(!stack[base + 5])
62616261 {
6262- fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6262+ fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 substruct\n");
62636263 label = 469LLU; // skip, variable already deleted/unscoped
62646264 break;
62656265 }
6266- fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6266+ fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 substruct\n");
62676267 label = 469LLU; // continue unrolling stack, delete next variable
62686268 break;
62696269 }
@@ -6533,11 +6533,11 @@
65336533 // throw from equletdef
65346534 if(!stack[base + 13])
65356535 {
6536- fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6536+ fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 result\n");
65376537 label = 493LLU; // skip, variable already deleted/unscoped
65386538 break;
65396539 }
6540- fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6540+ fprintf(stderr, "in function equletdef: unrolling stack, variable u64 result\n");
65416541 label = 493LLU; // continue unrolling stack, delete next variable
65426542 break;
65436543 }
@@ -6552,11 +6552,11 @@
65526552 // throw from equletdef
65536553 if(!stack[base + 14])
65546554 {
6555- fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6555+ fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
65566556 label = 494LLU; // skip, variable already deleted/unscoped
65576557 break;
65586558 }
6559- fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6559+ fprintf(stderr, "in function equletdef: unrolling stack, variable u64 isequal\n");
65606560 label = 494LLU; // continue unrolling stack, delete next variable
65616561 break;
65626562 }
@@ -7123,11 +7123,11 @@
71237123 // throw from emptyscope
71247124 if(!stack[base + 1])
71257125 {
7126- fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7126+ fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable u64 deleteaddr\n");
71277127 label = 536LLU; // skip, variable already deleted/unscoped
71287128 break;
71297129 }
7130- fprintf(stderr, "in function emptyscope: unrolling stack, variable u64 \n");
7130+ fprintf(stderr, "in function emptyscope: unrolling stack, variable u64 deleteaddr\n");
71317131 label = 536LLU; // continue unrolling stack, delete next variable
71327132 break;
71337133 }
@@ -7142,11 +7142,11 @@
71427142 // throw from emptyscope
71437143 if(!stack[base + 2])
71447144 {
7145- fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
7145+ fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable [letdef] letdefs\n");
71467146 label = 537LLU; // skip, variable already deleted/unscoped
71477147 break;
71487148 }
7149- fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] \n");
7149+ fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] letdefs\n");
71507150 // delete list
71517151 label = 541LLU; // start to repeat
71527152 break;
@@ -7267,11 +7267,11 @@
72677267 // throw from chainscope
72687268 if(!stack[base + 2])
72697269 {
7270- fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
7270+ fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable [letdef] letdefs\n");
72717271 label = 548LLU; // skip, variable already deleted/unscoped
72727272 break;
72737273 }
7274- fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] \n");
7274+ fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] letdefs\n");
72757275 // delete list
72767276 label = 551LLU; // start to repeat
72777277 break;
@@ -7525,11 +7525,11 @@
75257525 // throw from existslet
75267526 if(!stack[base + 3])
75277527 {
7528- fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7528+ fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
75297529 label = 572LLU; // skip, variable already deleted/unscoped
75307530 break;
75317531 }
7532- fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7532+ fprintf(stderr, "in function existslet: unrolling stack, variable u64 found\n");
75337533 label = 572LLU; // continue unrolling stack, delete next variable
75347534 break;
75357535 }
@@ -7711,11 +7711,11 @@
77117711 // throw from FindLetNew
77127712 if(!stack[base + 6])
77137713 {
7714- fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7714+ fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 curid\n");
77157715 label = 588LLU; // skip, variable already deleted/unscoped
77167716 break;
77177717 }
7718- fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7718+ fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 curid\n");
77197719 label = 588LLU; // continue unrolling stack, delete next variable
77207720 break;
77217721 }
@@ -7730,11 +7730,11 @@
77307730 // throw from FindLetNew
77317731 if(!stack[base + 7])
77327732 {
7733- fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7733+ fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 curindex\n");
77347734 label = 591LLU; // skip, variable already deleted/unscoped
77357735 break;
77367736 }
7737- fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7737+ fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 curindex\n");
77387738 label = 591LLU; // continue unrolling stack, delete next variable
77397739 break;
77407740 }
@@ -7749,11 +7749,11 @@
77497749 // throw from FindLetNew
77507750 if(!stack[base + 8])
77517751 {
7752- fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7752+ fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
77537753 label = 593LLU; // skip, variable already deleted/unscoped
77547754 break;
77557755 }
7756- fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7756+ fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 found\n");
77577757 label = 593LLU; // continue unrolling stack, delete next variable
77587758 break;
77597759 }
@@ -8994,11 +8994,11 @@
89948994 // throw from newvarraw
89958995 if(!stack[base + 10])
89968996 {
8997- fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8997+ fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 index\n");
89988998 label = 704LLU; // skip, variable already deleted/unscoped
89998999 break;
90009000 }
9001- fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
9001+ fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 index\n");
90029002 label = 704LLU; // continue unrolling stack, delete next variable
90039003 break;
90049004 }
@@ -9023,11 +9023,11 @@
90239023 // throw from newvarraw
90249024 if(!stack[base + 13])
90259025 {
9026- fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9026+ fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 sum\n");
90279027 label = 709LLU; // skip, variable already deleted/unscoped
90289028 break;
90299029 }
9030- fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
9030+ fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 sum\n");
90319031 label = 709LLU; // continue unrolling stack, delete next variable
90329032 break;
90339033 }
@@ -9164,11 +9164,11 @@
91649164 // throw from newvarraw
91659165 if(!stack[base + 15])
91669166 {
9167- fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable letdef \n");
9167+ fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable letdef newlet\n");
91689168 label = 710LLU; // skip, variable already deleted/unscoped
91699169 break;
91709170 }
9171- fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef \n");
9171+ fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef newlet\n");
91729172
91739173 uint64_t *newstack = (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4);
91749174 // call ~letdef from newvarraw
@@ -9366,11 +9366,11 @@
93669366 // throw from newvar
93679367 if(!stack[base + 10])
93689368 {
9369- fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9369+ fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 sum\n");
93709370 label = 735LLU; // skip, variable already deleted/unscoped
93719371 break;
93729372 }
9373- fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9373+ fprintf(stderr, "in function newvar: unrolling stack, variable u64 sum\n");
93749374 label = 735LLU; // continue unrolling stack, delete next variable
93759375 break;
93769376 }
@@ -9528,11 +9528,11 @@
95289528 // throw from newvar
95299529 if(!stack[base + 12])
95309530 {
9531- fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9531+ fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 substruct\n");
95329532 label = 736LLU; // skip, variable already deleted/unscoped
95339533 break;
95349534 }
9535- fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9535+ fprintf(stderr, "in function newvar: unrolling stack, variable u64 substruct\n");
95369536 label = 736LLU; // continue unrolling stack, delete next variable
95379537 break;
95389538 }
@@ -9547,11 +9547,11 @@
95479547 // throw from newvar
95489548 if(!stack[base + 13])
95499549 {
9550- fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable letdef \n");
9550+ fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable letdef newlet\n");
95519551 label = 748LLU; // skip, variable already deleted/unscoped
95529552 break;
95539553 }
9554- fprintf(stderr, "in function newvar: unrolling stack, variable letdef \n");
9554+ fprintf(stderr, "in function newvar: unrolling stack, variable letdef newlet\n");
95559555
95569556 uint64_t *newstack = (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4);
95579557 // call ~letdef from newvar
@@ -9748,11 +9748,11 @@
97489748 // throw from unscopelet
97499749 if(!stack[base + 5])
97509750 {
9751- fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
9751+ fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable [letdef] letdefs\n");
97529752 label = 765LLU; // skip, variable already deleted/unscoped
97539753 break;
97549754 }
9755- fprintf(stderr, "in function unscopelet: unrolling stack, variable [letdef] \n");
9755+ fprintf(stderr, "in function unscopelet: unrolling stack, variable [letdef] letdefs\n");
97569756 // delete list
97579757 label = 768LLU; // start to repeat
97589758 break;
@@ -9809,11 +9809,11 @@
98099809 // throw from unscopelet
98109810 if(!stack[base + 6])
98119811 {
9812- fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9812+ fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
98139813 label = 766LLU; // skip, variable already deleted/unscoped
98149814 break;
98159815 }
9816- fprintf(stderr, "in function unscopelet: unrolling stack, variable u64 \n");
9816+ fprintf(stderr, "in function unscopelet: unrolling stack, variable u64 found\n");
98179817 label = 766LLU; // continue unrolling stack, delete next variable
98189818 break;
98199819 }
@@ -10198,11 +10198,11 @@
1019810198 // throw from lookidnr
1019910199 if(!stack[base + 3])
1020010200 {
10201- fprintf(stderr, "in function lookidnr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10201+ fprintf(stderr, "in function lookidnr: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1020210202 label = 801LLU; // skip, variable already deleted/unscoped
1020310203 break;
1020410204 }
10205- fprintf(stderr, "in function lookidnr: unrolling stack, variable u64 \n");
10205+ fprintf(stderr, "in function lookidnr: unrolling stack, variable u64 found\n");
1020610206 label = 801LLU; // continue unrolling stack, delete next variable
1020710207 break;
1020810208 }
@@ -10462,11 +10462,11 @@
1046210462 // throw from parsetype
1046310463 if(!stack[base + 6])
1046410464 {
10465- fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10465+ fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1046610466 label = 828LLU; // skip, variable already deleted/unscoped
1046710467 break;
1046810468 }
10469- fprintf(stderr, "in function parsetype: unrolling stack, variable u64 \n");
10469+ fprintf(stderr, "in function parsetype: unrolling stack, variable u64 isequal\n");
1047010470 label = 828LLU; // continue unrolling stack, delete next variable
1047110471 break;
1047210472 }
@@ -11085,11 +11085,11 @@
1108511085 // throw from mkvariantd
1108611086 if(!stack[base + 1])
1108711087 {
11088- fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11088+ fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable u64 newid\n");
1108911089 label = 876LLU; // skip, variable already deleted/unscoped
1109011090 break;
1109111091 }
11092- fprintf(stderr, "in function mkvariantd: unrolling stack, variable u64 \n");
11092+ fprintf(stderr, "in function mkvariantd: unrolling stack, variable u64 newid\n");
1109311093 label = 876LLU; // continue unrolling stack, delete next variable
1109411094 break;
1109511095 }
@@ -11104,11 +11104,11 @@
1110411104 // throw from mkvariantd
1110511105 if(!stack[base + 2])
1110611106 {
11107- fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable [typeid] \n");
11107+ fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable [typeid] newelems\n");
1110811108 label = 877LLU; // skip, variable already deleted/unscoped
1110911109 break;
1111011110 }
11111- fprintf(stderr, "in function mkvariantd: unrolling stack, variable [typeid] \n");
11111+ fprintf(stderr, "in function mkvariantd: unrolling stack, variable [typeid] newelems\n");
1111211112 // delete list
1111311113 label = 881LLU; // start to repeat
1111411114 break;
@@ -11239,11 +11239,11 @@
1123911239 // throw from cpvariant
1124011240 if(!stack[base + 4])
1124111241 {
11242- fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11242+ fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable u64 cid\n");
1124311243 label = 891LLU; // skip, variable already deleted/unscoped
1124411244 break;
1124511245 }
11246- fprintf(stderr, "in function cpvariant: unrolling stack, variable u64 \n");
11246+ fprintf(stderr, "in function cpvariant: unrolling stack, variable u64 cid\n");
1124711247 label = 891LLU; // continue unrolling stack, delete next variable
1124811248 break;
1124911249 }
@@ -11258,11 +11258,11 @@
1125811258 // throw from cpvariant
1125911259 if(!stack[base + 5])
1126011260 {
11261- fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable [typeid] \n");
11261+ fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable [typeid] celements\n");
1126211262 label = 892LLU; // skip, variable already deleted/unscoped
1126311263 break;
1126411264 }
11265- fprintf(stderr, "in function cpvariant: unrolling stack, variable [typeid] \n");
11265+ fprintf(stderr, "in function cpvariant: unrolling stack, variable [typeid] celements\n");
1126611266 // delete list
1126711267 label = 896LLU; // start to repeat
1126811268 break;
@@ -11490,11 +11490,11 @@
1149011490 // throw from GetVariant
1149111491 if(!stack[base + 6])
1149211492 {
11493- fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11493+ fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 index\n");
1149411494 label = 908LLU; // skip, variable already deleted/unscoped
1149511495 break;
1149611496 }
11497- fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 \n");
11497+ fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 index\n");
1149811498 label = 908LLU; // continue unrolling stack, delete next variable
1149911499 break;
1150011500 }
@@ -11509,11 +11509,11 @@
1150911509 // throw from GetVariant
1151011510 if(!stack[base + 7])
1151111511 {
11512- fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11512+ fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1151311513 label = 911LLU; // skip, variable already deleted/unscoped
1151411514 break;
1151511515 }
11516- fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 \n");
11516+ fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 found\n");
1151711517 label = 911LLU; // continue unrolling stack, delete next variable
1151811518 break;
1151911519 }
@@ -11566,11 +11566,11 @@
1156611566 // throw from GetVariant
1156711567 if(!stack[base + 13])
1156811568 {
11569- fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11569+ fprintf(stderr, "in function GetVariant: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1157011570 label = 922LLU; // skip, variable already deleted/unscoped
1157111571 break;
1157211572 }
11573- fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 \n");
11573+ fprintf(stderr, "in function GetVariant: unrolling stack, variable u64 isequal\n");
1157411574 label = 922LLU; // continue unrolling stack, delete next variable
1157511575 break;
1157611576 }
@@ -11929,11 +11929,11 @@
1192911929 // throw from mkdatadefd
1193011930 if(!stack[base + 1])
1193111931 {
11932- fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable u64 \n");
11932+ fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable u64 newid\n");
1193311933 label = 951LLU; // skip, variable already deleted/unscoped
1193411934 break;
1193511935 }
11936- fprintf(stderr, "in function mkdatadefd: unrolling stack, variable u64 \n");
11936+ fprintf(stderr, "in function mkdatadefd: unrolling stack, variable u64 newid\n");
1193711937 label = 951LLU; // continue unrolling stack, delete next variable
1193811938 break;
1193911939 }
@@ -11948,11 +11948,11 @@
1194811948 // throw from mkdatadefd
1194911949 if(!stack[base + 2])
1195011950 {
11951- fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable [variant] \n");
11951+ fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable [variant] newvars\n");
1195211952 label = 952LLU; // skip, variable already deleted/unscoped
1195311953 break;
1195411954 }
11955- fprintf(stderr, "in function mkdatadefd: unrolling stack, variable [variant] \n");
11955+ fprintf(stderr, "in function mkdatadefd: unrolling stack, variable [variant] newvars\n");
1195611956 // delete list
1195711957 label = 956LLU; // start to repeat
1195811958 break;
@@ -12009,11 +12009,11 @@
1200912009 // throw from mkdatadefd
1201012010 if(!stack[base + 3])
1201112011 {
12012- fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12012+ fprintf(stderr, "in function mkdatadefd: unrolling stack, skipping already deleted/unscoped variable u64 destrlabel\n");
1201312013 label = 954LLU; // skip, variable already deleted/unscoped
1201412014 break;
1201512015 }
12016- fprintf(stderr, "in function mkdatadefd: unrolling stack, variable u64 \n");
12016+ fprintf(stderr, "in function mkdatadefd: unrolling stack, variable u64 destrlabel\n");
1201712017 label = 954LLU; // continue unrolling stack, delete next variable
1201812018 break;
1201912019 }
@@ -12104,11 +12104,11 @@
1210412104 // throw from cpdatadef
1210512105 if(!stack[base + 5])
1210612106 {
12107- fprintf(stderr, "in function cpdatadef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12107+ fprintf(stderr, "in function cpdatadef: unrolling stack, skipping already deleted/unscoped variable u64 cid\n");
1210812108 label = 968LLU; // skip, variable already deleted/unscoped
1210912109 break;
1211012110 }
12111- fprintf(stderr, "in function cpdatadef: unrolling stack, variable u64 \n");
12111+ fprintf(stderr, "in function cpdatadef: unrolling stack, variable u64 cid\n");
1211212112 label = 968LLU; // continue unrolling stack, delete next variable
1211312113 break;
1211412114 }
@@ -12123,11 +12123,11 @@
1212312123 // throw from cpdatadef
1212412124 if(!stack[base + 6])
1212512125 {
12126- fprintf(stderr, "in function cpdatadef: unrolling stack, skipping already deleted/unscoped variable [variant] \n");
12126+ fprintf(stderr, "in function cpdatadef: unrolling stack, skipping already deleted/unscoped variable [variant] cvariants\n");
1212712127 label = 969LLU; // skip, variable already deleted/unscoped
1212812128 break;
1212912129 }
12130- fprintf(stderr, "in function cpdatadef: unrolling stack, variable [variant] \n");
12130+ fprintf(stderr, "in function cpdatadef: unrolling stack, variable [variant] cvariants\n");
1213112131 // delete list
1213212132 label = 973LLU; // start to repeat
1213312133 break;
@@ -12334,11 +12334,11 @@
1233412334 // throw from existsdata
1233512335 if(!stack[base + 3])
1233612336 {
12337- fprintf(stderr, "in function existsdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12337+ fprintf(stderr, "in function existsdata: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1233812338 label = 985LLU; // skip, variable already deleted/unscoped
1233912339 break;
1234012340 }
12341- fprintf(stderr, "in function existsdata: unrolling stack, variable u64 \n");
12341+ fprintf(stderr, "in function existsdata: unrolling stack, variable u64 found\n");
1234212342 label = 985LLU; // continue unrolling stack, delete next variable
1234312343 break;
1234412344 }
@@ -12392,11 +12392,11 @@
1239212392 // throw from existsdata
1239312393 if(!stack[base + 10])
1239412394 {
12395- fprintf(stderr, "in function existsdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12395+ fprintf(stderr, "in function existsdata: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1239612396 label = 995LLU; // skip, variable already deleted/unscoped
1239712397 break;
1239812398 }
12399- fprintf(stderr, "in function existsdata: unrolling stack, variable u64 \n");
12399+ fprintf(stderr, "in function existsdata: unrolling stack, variable u64 isequal\n");
1240012400 label = 995LLU; // continue unrolling stack, delete next variable
1240112401 break;
1240212402 }
@@ -12549,11 +12549,11 @@
1254912549 // throw from FindData
1255012550 if(!stack[base + 4])
1255112551 {
12552- fprintf(stderr, "in function FindData: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12552+ fprintf(stderr, "in function FindData: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1255312553 label = 1005LLU; // skip, variable already deleted/unscoped
1255412554 break;
1255512555 }
12556- fprintf(stderr, "in function FindData: unrolling stack, variable u64 \n");
12556+ fprintf(stderr, "in function FindData: unrolling stack, variable u64 found\n");
1255712557 label = 1005LLU; // continue unrolling stack, delete next variable
1255812558 break;
1255912559 }
@@ -12607,11 +12607,11 @@
1260712607 // throw from FindData
1260812608 if(!stack[base + 11])
1260912609 {
12610- fprintf(stderr, "in function FindData: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12610+ fprintf(stderr, "in function FindData: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1261112611 label = 1017LLU; // skip, variable already deleted/unscoped
1261212612 break;
1261312613 }
12614- fprintf(stderr, "in function FindData: unrolling stack, variable u64 \n");
12614+ fprintf(stderr, "in function FindData: unrolling stack, variable u64 isequal\n");
1261512615 label = 1017LLU; // continue unrolling stack, delete next variable
1261612616 break;
1261712617 }
@@ -12925,11 +12925,11 @@
1292512925 // throw from calldestrN
1292612926 if(!stack[base + 6])
1292712927 {
12928- fprintf(stderr, "in function calldestrN: unrolling stack, skipping already deleted/unscoped variable u64 \n");
12928+ fprintf(stderr, "in function calldestrN: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1292912929 label = 1043LLU; // skip, variable already deleted/unscoped
1293012930 break;
1293112931 }
12932- fprintf(stderr, "in function calldestrN: unrolling stack, variable u64 \n");
12932+ fprintf(stderr, "in function calldestrN: unrolling stack, variable u64 isequal\n");
1293312933 label = 1043LLU; // continue unrolling stack, delete next variable
1293412934 break;
1293512935 }
@@ -13405,11 +13405,11 @@
1340513405 // throw from calldestr
1340613406 if(!stack[base + 6])
1340713407 {
13408- fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13408+ fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1340913409 label = 1085LLU; // skip, variable already deleted/unscoped
1341013410 break;
1341113411 }
13412- fprintf(stderr, "in function calldestr: unrolling stack, variable u64 \n");
13412+ fprintf(stderr, "in function calldestr: unrolling stack, variable u64 isequal\n");
1341313413 label = 1085LLU; // continue unrolling stack, delete next variable
1341413414 break;
1341513415 }
@@ -13506,11 +13506,11 @@
1350613506 // throw from calldestr
1350713507 if(!stack[base + 8])
1350813508 {
13509- fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13509+ fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 labelloop\n");
1351013510 label = 1094LLU; // skip, variable already deleted/unscoped
1351113511 break;
1351213512 }
13513- fprintf(stderr, "in function calldestr: unrolling stack, variable u64 \n");
13513+ fprintf(stderr, "in function calldestr: unrolling stack, variable u64 labelloop\n");
1351413514 label = 1094LLU; // continue unrolling stack, delete next variable
1351513515 break;
1351613516 }
@@ -13549,11 +13549,11 @@
1354913549 // throw from calldestr
1355013550 if(!stack[base + 9])
1355113551 {
13552- fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13552+ fprintf(stderr, "in function calldestr: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
1355313553 label = 1097LLU; // skip, variable already deleted/unscoped
1355413554 break;
1355513555 }
13556- fprintf(stderr, "in function calldestr: unrolling stack, variable u64 \n");
13556+ fprintf(stderr, "in function calldestr: unrolling stack, variable u64 labelskip\n");
1355713557 label = 1097LLU; // continue unrolling stack, delete next variable
1355813558 break;
1355913559 }
@@ -13886,11 +13886,11 @@
1388613886 // throw from procdata
1388713887 if(!stack[base + 6])
1388813888 {
13889- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13889+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 lookahead\n");
1389013890 label = 1124LLU; // skip, variable already deleted/unscoped
1389113891 break;
1389213892 }
13893- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
13893+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 lookahead\n");
1389413894 label = 1124LLU; // continue unrolling stack, delete next variable
1389513895 break;
1389613896 }
@@ -13931,11 +13931,11 @@
1393113931 // throw from procdata
1393213932 if(!stack[base + 7])
1393313933 {
13934- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13934+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 isname\n");
1393513935 label = 1125LLU; // skip, variable already deleted/unscoped
1393613936 break;
1393713937 }
13938- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
13938+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 isname\n");
1393913939 label = 1125LLU; // continue unrolling stack, delete next variable
1394013940 break;
1394113941 }
@@ -13974,11 +13974,11 @@
1397413974 // throw from procdata
1397513975 if(!stack[base + 8])
1397613976 {
13977- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
13977+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 identifier\n");
1397813978 label = 1129LLU; // skip, variable already deleted/unscoped
1397913979 break;
1398013980 }
13981- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
13981+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 identifier\n");
1398213982 label = 1129LLU; // continue unrolling stack, delete next variable
1398313983 break;
1398413984 }
@@ -14101,11 +14101,11 @@
1410114101 // throw from procdata
1410214102 if(!stack[base + 9])
1410314103 {
14104- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
14104+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 fnid\n");
1410514105 label = 1133LLU; // skip, variable already deleted/unscoped
1410614106 break;
1410714107 }
14108- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
14108+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 fnid\n");
1410914109 label = 1133LLU; // continue unrolling stack, delete next variable
1411014110 break;
1411114111 }
@@ -14120,11 +14120,11 @@
1412014120 // throw from procdata
1412114121 if(!stack[base + 10])
1412214122 {
14123- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
14123+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 symbol\n");
1412414124 label = 1145LLU; // skip, variable already deleted/unscoped
1412514125 break;
1412614126 }
14127- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
14127+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 symbol\n");
1412814128 label = 1145LLU; // continue unrolling stack, delete next variable
1412914129 break;
1413014130 }
@@ -14139,11 +14139,11 @@
1413914139 // throw from procdata
1414014140 if(!stack[base + 11])
1414114141 {
14142- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [variant] \n");
14142+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [variant] variants\n");
1414314143 label = 1147LLU; // skip, variable already deleted/unscoped
1414414144 break;
1414514145 }
14146- fprintf(stderr, "in function procdata: unrolling stack, variable [variant] \n");
14146+ fprintf(stderr, "in function procdata: unrolling stack, variable [variant] variants\n");
1414714147 // delete list
1414814148 label = 1151LLU; // start to repeat
1414914149 break;
@@ -14349,11 +14349,11 @@
1434914349 // throw from procdata
1435014350 if(!stack[base + 13])
1435114351 {
14352- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
14352+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 variantid\n");
1435314353 label = 1149LLU; // skip, variable already deleted/unscoped
1435414354 break;
1435514355 }
14356- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
14356+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 variantid\n");
1435714357 label = 1149LLU; // continue unrolling stack, delete next variable
1435814358 break;
1435914359 }
@@ -14368,11 +14368,11 @@
1436814368 // throw from procdata
1436914369 if(!stack[base + 14])
1437014370 {
14371- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [typeid] \n");
14371+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [typeid] typeids\n");
1437214372 label = 1170LLU; // skip, variable already deleted/unscoped
1437314373 break;
1437414374 }
14375- fprintf(stderr, "in function procdata: unrolling stack, variable [typeid] \n");
14375+ fprintf(stderr, "in function procdata: unrolling stack, variable [typeid] typeids\n");
1437614376 // delete list
1437714377 label = 1174LLU; // start to repeat
1437814378 break;
@@ -14670,11 +14670,11 @@
1467014670 // throw from procdata
1467114671 if(!stack[base + 17])
1467214672 {
14673- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable typeid \n");
14673+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable typeid typeid\n");
1467414674 label = 1172LLU; // skip, variable already deleted/unscoped
1467514675 break;
1467614676 }
14677- fprintf(stderr, "in function procdata: unrolling stack, variable typeid \n");
14677+ fprintf(stderr, "in function procdata: unrolling stack, variable typeid typeid\n");
1467814678
1467914679 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
1468014680 // call ~typeid from procdata
@@ -14795,11 +14795,11 @@
1479514795 // throw from procdata
1479614796 if(!stack[base + 15])
1479714797 {
14798- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable variant \n");
14798+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable variant constr\n");
1479914799 label = 1172LLU; // skip, variable already deleted/unscoped
1480014800 break;
1480114801 }
14802- fprintf(stderr, "in function procdata: unrolling stack, variable variant \n");
14802+ fprintf(stderr, "in function procdata: unrolling stack, variable variant constr\n");
1480314803
1480414804 uint64_t *newstack = (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4);
1480514805 // call ~variant from procdata
@@ -14954,11 +14954,11 @@
1495414954 // throw from procdata
1495514955 if(!stack[base + 12])
1495614956 {
14957- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
14957+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 destrlabel\n");
1495814958 label = 1149LLU; // skip, variable already deleted/unscoped
1495914959 break;
1496014960 }
14961- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
14961+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 destrlabel\n");
1496214962 label = 1149LLU; // continue unrolling stack, delete next variable
1496314963 break;
1496414964 }
@@ -14973,11 +14973,11 @@
1497314973 // throw from procdata
1497414974 if(!stack[base + 13])
1497514975 {
14976- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [variant] \n");
14976+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable [variant] VARIANTS\n");
1497714977 label = 1215LLU; // skip, variable already deleted/unscoped
1497814978 break;
1497914979 }
14980- fprintf(stderr, "in function procdata: unrolling stack, variable [variant] \n");
14980+ fprintf(stderr, "in function procdata: unrolling stack, variable [variant] VARIANTS\n");
1498114981 // delete list
1498214982 label = 1219LLU; // start to repeat
1498314983 break;
@@ -15122,11 +15122,11 @@
1512215122 // throw from procdata
1512315123 if(!stack[base + 17])
1512415124 {
15125- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable datadef \n");
15125+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable datadef datadef\n");
1512615126 label = 1217LLU; // skip, variable already deleted/unscoped
1512715127 break;
1512815128 }
15129- fprintf(stderr, "in function procdata: unrolling stack, variable datadef \n");
15129+ fprintf(stderr, "in function procdata: unrolling stack, variable datadef datadef\n");
1513015130
1513115131 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
1513215132 // call ~datadef from procdata
@@ -15182,11 +15182,11 @@
1518215182 // throw from procdata
1518315183 if(!stack[base + 13])
1518415184 {
15185- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15185+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 variantsz\n");
1518615186 label = 1215LLU; // skip, variable already deleted/unscoped
1518715187 break;
1518815188 }
15189- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15189+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 variantsz\n");
1519015190 label = 1215LLU; // continue unrolling stack, delete next variable
1519115191 break;
1519215192 }
@@ -15345,11 +15345,11 @@
1534515345 // throw from procdata
1534615346 if(!stack[base + 13])
1534715347 {
15348- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15348+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 variantnr\n");
1534915349 label = 1215LLU; // skip, variable already deleted/unscoped
1535015350 break;
1535115351 }
15352- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15352+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 variantnr\n");
1535315353 label = 1215LLU; // continue unrolling stack, delete next variable
1535415354 break;
1535515355 }
@@ -15479,11 +15479,11 @@
1547915479 // throw from procdata
1548015480 if(!stack[base + 19])
1548115481 {
15482- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15482+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 elementnr\n");
1548315483 label = 1253LLU; // skip, variable already deleted/unscoped
1548415484 break;
1548515485 }
15486- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15486+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 elementnr\n");
1548715487 label = 1253LLU; // continue unrolling stack, delete next variable
1548815488 break;
1548915489 }
@@ -15591,11 +15591,11 @@
1559115591 // throw from procdata
1559215592 if(!stack[base + 27])
1559315593 {
15594- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable type \n");
15594+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable type type\n");
1559515595 label = 1274LLU; // skip, variable already deleted/unscoped
1559615596 break;
1559715597 }
15598- fprintf(stderr, "in function procdata: unrolling stack, variable type \n");
15598+ fprintf(stderr, "in function procdata: unrolling stack, variable type type\n");
1559915599
1560015600 uint64_t *newstack = (uint64_t *)(stack[base + 27] - sizeof(uint64_t) * 4);
1560115601 // call ~type from procdata
@@ -15661,11 +15661,11 @@
1566115661 // throw from procdata
1566215662 if(!stack[base + 28])
1566315663 {
15664- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15664+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 reusedidx\n");
1566515665 label = 1279LLU; // skip, variable already deleted/unscoped
1566615666 break;
1566715667 }
15668- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15668+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 reusedidx\n");
1566915669 label = 1279LLU; // continue unrolling stack, delete next variable
1567015670 break;
1567115671 }
@@ -15802,11 +15802,11 @@
1580215802 // throw from procdata
1580315803 if(!stack[base + 26])
1580415804 {
15805- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15805+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 index\n");
1580615806 label = 1290LLU; // skip, variable already deleted/unscoped
1580715807 break;
1580815808 }
15809- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15809+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 index\n");
1581015810 label = 1290LLU; // continue unrolling stack, delete next variable
1581115811 break;
1581215812 }
@@ -15821,11 +15821,11 @@
1582115821 // throw from procdata
1582215822 if(!stack[base + 27])
1582315823 {
15824- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15824+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 level\n");
1582515825 label = 1293LLU; // skip, variable already deleted/unscoped
1582615826 break;
1582715827 }
15828- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15828+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 level\n");
1582915829 label = 1293LLU; // continue unrolling stack, delete next variable
1583015830 break;
1583115831 }
@@ -15864,11 +15864,11 @@
1586415864 // throw from procdata
1586515865 if(!stack[base + 28])
1586615866 {
15867- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15867+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 labelloop\n");
1586815868 label = 1295LLU; // skip, variable already deleted/unscoped
1586915869 break;
1587015870 }
15871- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15871+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 labelloop\n");
1587215872 label = 1295LLU; // continue unrolling stack, delete next variable
1587315873 break;
1587415874 }
@@ -15907,11 +15907,11 @@
1590715907 // throw from procdata
1590815908 if(!stack[base + 29])
1590915909 {
15910- fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 \n");
15910+ fprintf(stderr, "in function procdata: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
1591115911 label = 1299LLU; // skip, variable already deleted/unscoped
1591215912 break;
1591315913 }
15914- fprintf(stderr, "in function procdata: unrolling stack, variable u64 \n");
15914+ fprintf(stderr, "in function procdata: unrolling stack, variable u64 labelskip\n");
1591515915 label = 1299LLU; // continue unrolling stack, delete next variable
1591615916 break;
1591715917 }
@@ -16555,11 +16555,11 @@
1655516555 // throw from mkfndummy
1655616556 if(!stack[base + 1])
1655716557 {
16558- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16558+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 label\n");
1655916559 label = 1345LLU; // skip, variable already deleted/unscoped
1656016560 break;
1656116561 }
16562- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16562+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 label\n");
1656316563 label = 1345LLU; // continue unrolling stack, delete next variable
1656416564 break;
1656516565 }
@@ -16574,11 +16574,11 @@
1657416574 // throw from mkfndummy
1657516575 if(!stack[base + 2])
1657616576 {
16577- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable [result] \n");
16577+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable [result] restypes\n");
1657816578 label = 1346LLU; // skip, variable already deleted/unscoped
1657916579 break;
1658016580 }
16581- fprintf(stderr, "in function mkfndummy: unrolling stack, variable [result] \n");
16581+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable [result] restypes\n");
1658216582 // delete list
1658316583 label = 1350LLU; // start to repeat
1658416584 break;
@@ -16635,11 +16635,11 @@
1663516635 // throw from mkfndummy
1663616636 if(!stack[base + 3])
1663716637 {
16638- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable [param] \n");
16638+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable [param] argtypes\n");
1663916639 label = 1348LLU; // skip, variable already deleted/unscoped
1664016640 break;
1664116641 }
16642- fprintf(stderr, "in function mkfndummy: unrolling stack, variable [param] \n");
16642+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable [param] argtypes\n");
1664316643 // delete list
1664416644 label = 1355LLU; // start to repeat
1664516645 break;
@@ -16696,11 +16696,11 @@
1669616696 // throw from mkfndummy
1669716697 if(!stack[base + 4])
1669816698 {
16699- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16699+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 maxcount\n");
1670016700 label = 1353LLU; // skip, variable already deleted/unscoped
1670116701 break;
1670216702 }
16703- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16703+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 maxcount\n");
1670416704 label = 1353LLU; // continue unrolling stack, delete next variable
1670516705 break;
1670616706 }
@@ -16715,11 +16715,11 @@
1671516715 // throw from mkfndummy
1671616716 if(!stack[base + 5])
1671716717 {
16718- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16718+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 id\n");
1671916719 label = 1358LLU; // skip, variable already deleted/unscoped
1672016720 break;
1672116721 }
16722- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16722+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 id\n");
1672316723 label = 1358LLU; // continue unrolling stack, delete next variable
1672416724 break;
1672516725 }
@@ -16734,11 +16734,11 @@
1673416734 // throw from mkfndummy
1673516735 if(!stack[base + 6])
1673616736 {
16737- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16737+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 recursive\n");
1673816738 label = 1360LLU; // skip, variable already deleted/unscoped
1673916739 break;
1674016740 }
16741- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16741+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 recursive\n");
1674216742 label = 1360LLU; // continue unrolling stack, delete next variable
1674316743 break;
1674416744 }
@@ -16753,11 +16753,11 @@
1675316753 // throw from mkfndummy
1675416754 if(!stack[base + 7])
1675516755 {
16756- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16756+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 fallible\n");
1675716757 label = 1362LLU; // skip, variable already deleted/unscoped
1675816758 break;
1675916759 }
16760- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16760+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 fallible\n");
1676116761 label = 1362LLU; // continue unrolling stack, delete next variable
1676216762 break;
1676316763 }
@@ -16772,11 +16772,11 @@
1677216772 // throw from mkfndummy
1677316773 if(!stack[base + 8])
1677416774 {
16775- fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16775+ fprintf(stderr, "in function mkfndummy: unrolling stack, skipping already deleted/unscoped variable u64 canthrow\n");
1677616776 label = 1364LLU; // skip, variable already deleted/unscoped
1677716777 break;
1677816778 }
16779- fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 \n");
16779+ fprintf(stderr, "in function mkfndummy: unrolling stack, variable u64 canthrow\n");
1678016780 label = 1364LLU; // continue unrolling stack, delete next variable
1678116781 break;
1678216782 }
@@ -16877,11 +16877,11 @@
1687716877 // throw from copyfndef
1687816878 if(!stack[base + 10])
1687916879 {
16880- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
16880+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 clabel\n");
1688116881 label = 1375LLU; // skip, variable already deleted/unscoped
1688216882 break;
1688316883 }
16884- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
16884+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 clabel\n");
1688516885 label = 1375LLU; // continue unrolling stack, delete next variable
1688616886 break;
1688716887 }
@@ -16896,11 +16896,11 @@
1689616896 // throw from copyfndef
1689716897 if(!stack[base + 11])
1689816898 {
16899- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [result] \n");
16899+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [result] crestypes\n");
1690016900 label = 1376LLU; // skip, variable already deleted/unscoped
1690116901 break;
1690216902 }
16903- fprintf(stderr, "in function copyfndef: unrolling stack, variable [result] \n");
16903+ fprintf(stderr, "in function copyfndef: unrolling stack, variable [result] crestypes\n");
1690416904 // delete list
1690516905 label = 1380LLU; // start to repeat
1690616906 break;
@@ -16957,11 +16957,11 @@
1695716957 // throw from copyfndef
1695816958 if(!stack[base + 12])
1695916959 {
16960- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [param] \n");
16960+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable [param] cargtypes\n");
1696116961 label = 1378LLU; // skip, variable already deleted/unscoped
1696216962 break;
1696316963 }
16964- fprintf(stderr, "in function copyfndef: unrolling stack, variable [param] \n");
16964+ fprintf(stderr, "in function copyfndef: unrolling stack, variable [param] cargtypes\n");
1696516965 // delete list
1696616966 label = 1385LLU; // start to repeat
1696716967 break;
@@ -17018,11 +17018,11 @@
1701817018 // throw from copyfndef
1701917019 if(!stack[base + 13])
1702017020 {
17021- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17021+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 cmaxcount\n");
1702217022 label = 1383LLU; // skip, variable already deleted/unscoped
1702317023 break;
1702417024 }
17025- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
17025+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 cmaxcount\n");
1702617026 label = 1383LLU; // continue unrolling stack, delete next variable
1702717027 break;
1702817028 }
@@ -17037,11 +17037,11 @@
1703717037 // throw from copyfndef
1703817038 if(!stack[base + 14])
1703917039 {
17040- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17040+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 cid\n");
1704117041 label = 1388LLU; // skip, variable already deleted/unscoped
1704217042 break;
1704317043 }
17044- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
17044+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 cid\n");
1704517045 label = 1388LLU; // continue unrolling stack, delete next variable
1704617046 break;
1704717047 }
@@ -17056,11 +17056,11 @@
1705617056 // throw from copyfndef
1705717057 if(!stack[base + 15])
1705817058 {
17059- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17059+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 crecursive\n");
1706017060 label = 1390LLU; // skip, variable already deleted/unscoped
1706117061 break;
1706217062 }
17063- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
17063+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 crecursive\n");
1706417064 label = 1390LLU; // continue unrolling stack, delete next variable
1706517065 break;
1706617066 }
@@ -17075,11 +17075,11 @@
1707517075 // throw from copyfndef
1707617076 if(!stack[base + 16])
1707717077 {
17078- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17078+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 cfallible\n");
1707917079 label = 1392LLU; // skip, variable already deleted/unscoped
1708017080 break;
1708117081 }
17082- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
17082+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 cfallible\n");
1708317083 label = 1392LLU; // continue unrolling stack, delete next variable
1708417084 break;
1708517085 }
@@ -17094,11 +17094,11 @@
1709417094 // throw from copyfndef
1709517095 if(!stack[base + 17])
1709617096 {
17097- fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17097+ fprintf(stderr, "in function copyfndef: unrolling stack, skipping already deleted/unscoped variable u64 ccanthrow\n");
1709817098 label = 1394LLU; // skip, variable already deleted/unscoped
1709917099 break;
1710017100 }
17101- fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 \n");
17101+ fprintf(stderr, "in function copyfndef: unrolling stack, variable u64 ccanthrow\n");
1710217102 label = 1394LLU; // continue unrolling stack, delete next variable
1710317103 break;
1710417104 }
@@ -17364,11 +17364,11 @@
1736417364 // throw from FindFn
1736517365 if(!stack[base + 5])
1736617366 {
17367- fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17367+ fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1736817368 label = 1412LLU; // skip, variable already deleted/unscoped
1736917369 break;
1737017370 }
17371- fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n");
17371+ fprintf(stderr, "in function FindFn: unrolling stack, variable u64 found\n");
1737217372 label = 1412LLU; // continue unrolling stack, delete next variable
1737317373 break;
1737417374 }
@@ -17427,11 +17427,11 @@
1742717427 // throw from FindFn
1742817428 if(!stack[base + 17])
1742917429 {
17430- fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17430+ fprintf(stderr, "in function FindFn: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1743117431 label = 1424LLU; // skip, variable already deleted/unscoped
1743217432 break;
1743317433 }
17434- fprintf(stderr, "in function FindFn: unrolling stack, variable u64 \n");
17434+ fprintf(stderr, "in function FindFn: unrolling stack, variable u64 isequal\n");
1743517435 label = 1424LLU; // continue unrolling stack, delete next variable
1743617436 break;
1743717437 }
@@ -17698,11 +17698,11 @@
1769817698 // throw from existsfn
1769917699 if(!stack[base + 3])
1770017700 {
17701- fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17701+ fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1770217702 label = 1444LLU; // skip, variable already deleted/unscoped
1770317703 break;
1770417704 }
17705- fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n");
17705+ fprintf(stderr, "in function existsfn: unrolling stack, variable u64 found\n");
1770617706 label = 1444LLU; // continue unrolling stack, delete next variable
1770717707 break;
1770817708 }
@@ -17761,11 +17761,11 @@
1776117761 // throw from existsfn
1776217762 if(!stack[base + 15])
1776317763 {
17764- fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17764+ fprintf(stderr, "in function existsfn: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1776517765 label = 1454LLU; // skip, variable already deleted/unscoped
1776617766 break;
1776717767 }
17768- fprintf(stderr, "in function existsfn: unrolling stack, variable u64 \n");
17768+ fprintf(stderr, "in function existsfn: unrolling stack, variable u64 isequal\n");
1776917769 label = 1454LLU; // continue unrolling stack, delete next variable
1777017770 break;
1777117771 }
@@ -17946,11 +17946,11 @@
1794617946 // throw from existsidfn
1794717947 if(!stack[base + 3])
1794817948 {
17949- fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
17949+ fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 found\n");
1795017950 label = 1467LLU; // skip, variable already deleted/unscoped
1795117951 break;
1795217952 }
17953- fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n");
17953+ fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 found\n");
1795417954 label = 1467LLU; // continue unrolling stack, delete next variable
1795517955 break;
1795617956 }
@@ -18003,11 +18003,11 @@
1800318003 // throw from existsidfn
1800418004 if(!stack[base + 9])
1800518005 {
18006- fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18006+ fprintf(stderr, "in function existsidfn: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1800718007 label = 1477LLU; // skip, variable already deleted/unscoped
1800818008 break;
1800918009 }
18010- fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 \n");
18010+ fprintf(stderr, "in function existsidfn: unrolling stack, variable u64 isequal\n");
1801118011 label = 1477LLU; // continue unrolling stack, delete next variable
1801218012 break;
1801318013 }
@@ -18306,11 +18306,11 @@
1830618306 // throw from register
1830718307 if(!stack[base + 7])
1830818308 {
18309- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [result] \n");
18309+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [result] fnrestypes\n");
1831018310 label = 1501LLU; // skip, variable already deleted/unscoped
1831118311 break;
1831218312 }
18313- fprintf(stderr, "in function register: unrolling stack, variable [result] \n");
18313+ fprintf(stderr, "in function register: unrolling stack, variable [result] fnrestypes\n");
1831418314 // delete list
1831518315 label = 1506LLU; // start to repeat
1831618316 break;
@@ -18404,11 +18404,11 @@
1840418404 // throw from register
1840518405 if(!stack[base + 10])
1840618406 {
18407- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18407+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 mutable\n");
1840818408 label = 1504LLU; // skip, variable already deleted/unscoped
1840918409 break;
1841018410 }
18411- fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18411+ fprintf(stderr, "in function register: unrolling stack, variable u64 mutable\n");
1841218412 label = 1504LLU; // continue unrolling stack, delete next variable
1841318413 break;
1841418414 }
@@ -18423,11 +18423,11 @@
1842318423 // throw from register
1842418424 if(!stack[base + 11])
1842518425 {
18426- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable result \n");
18426+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable result result\n");
1842718427 label = 1513LLU; // skip, variable already deleted/unscoped
1842818428 break;
1842918429 }
18430- fprintf(stderr, "in function register: unrolling stack, variable result \n");
18430+ fprintf(stderr, "in function register: unrolling stack, variable result result\n");
1843118431
1843218432 uint64_t *newstack = (uint64_t *)(stack[base + 11] - sizeof(uint64_t) * 4);
1843318433 // call ~result from register
@@ -18487,11 +18487,11 @@
1848718487 // throw from register
1848818488 if(!stack[base + 9])
1848918489 {
18490- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [param] \n");
18490+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable [param] fnargtypes\n");
1849118491 label = 1504LLU; // skip, variable already deleted/unscoped
1849218492 break;
1849318493 }
18494- fprintf(stderr, "in function register: unrolling stack, variable [param] \n");
18494+ fprintf(stderr, "in function register: unrolling stack, variable [param] fnargtypes\n");
1849518495 // delete list
1849618496 label = 1520LLU; // start to repeat
1849718497 break;
@@ -18609,11 +18609,11 @@
1860918609 // throw from register
1861018610 if(!stack[base + 13])
1861118611 {
18612- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable typeid \n");
18612+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable typeid typeid\n");
1861318613 label = 1518LLU; // skip, variable already deleted/unscoped
1861418614 break;
1861518615 }
18616- fprintf(stderr, "in function register: unrolling stack, variable typeid \n");
18616+ fprintf(stderr, "in function register: unrolling stack, variable typeid typeid\n");
1861718617
1861818618 uint64_t *newstack = (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4);
1861918619 // call ~typeid from register
@@ -18657,11 +18657,11 @@
1865718657 // throw from register
1865818658 if(!stack[base + 14])
1865918659 {
18660- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18660+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 mutable\n");
1866118661 label = 1529LLU; // skip, variable already deleted/unscoped
1866218662 break;
1866318663 }
18664- fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18664+ fprintf(stderr, "in function register: unrolling stack, variable u64 mutable\n");
1866518665 label = 1529LLU; // continue unrolling stack, delete next variable
1866618666 break;
1866718667 }
@@ -18676,11 +18676,11 @@
1867618676 // throw from register
1867718677 if(!stack[base + 15])
1867818678 {
18679- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable param \n");
18679+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable param param\n");
1868018680 label = 1532LLU; // skip, variable already deleted/unscoped
1868118681 break;
1868218682 }
18683- fprintf(stderr, "in function register: unrolling stack, variable param \n");
18683+ fprintf(stderr, "in function register: unrolling stack, variable param param\n");
1868418684
1868518685 uint64_t *newstack = (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4);
1868618686 // call ~param from register
@@ -18740,11 +18740,11 @@
1874018740 // throw from register
1874118741 if(!stack[base + 11])
1874218742 {
18743- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18743+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 fnrec\n");
1874418744 label = 1518LLU; // skip, variable already deleted/unscoped
1874518745 break;
1874618746 }
18747- fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18747+ fprintf(stderr, "in function register: unrolling stack, variable u64 fnrec\n");
1874818748 label = 1518LLU; // continue unrolling stack, delete next variable
1874918749 break;
1875018750 }
@@ -18759,11 +18759,11 @@
1875918759 // throw from register
1876018760 if(!stack[base + 12])
1876118761 {
18762- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18762+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 fnlabel\n");
1876318763 label = 1537LLU; // skip, variable already deleted/unscoped
1876418764 break;
1876518765 }
18766- fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18766+ fprintf(stderr, "in function register: unrolling stack, variable u64 fnlabel\n");
1876718767 label = 1537LLU; // continue unrolling stack, delete next variable
1876818768 break;
1876918769 }
@@ -18826,11 +18826,11 @@
1882618826 // throw from register
1882718827 if(!stack[base + 13])
1882818828 {
18829- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 \n");
18829+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable u64 canthrow\n");
1883018830 label = 1539LLU; // skip, variable already deleted/unscoped
1883118831 break;
1883218832 }
18833- fprintf(stderr, "in function register: unrolling stack, variable u64 \n");
18833+ fprintf(stderr, "in function register: unrolling stack, variable u64 canthrow\n");
1883418834 label = 1539LLU; // continue unrolling stack, delete next variable
1883518835 break;
1883618836 }
@@ -18845,11 +18845,11 @@
1884518845 // throw from register
1884618846 if(!stack[base + 14])
1884718847 {
18848- fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable fndef \n");
18848+ fprintf(stderr, "in function register: unrolling stack, skipping already deleted/unscoped variable fndef fndef\n");
1884918849 label = 1545LLU; // skip, variable already deleted/unscoped
1885018850 break;
1885118851 }
18852- fprintf(stderr, "in function register: unrolling stack, variable fndef \n");
18852+ fprintf(stderr, "in function register: unrolling stack, variable fndef fndef\n");
1885318853
1885418854 uint64_t *newstack = (uint64_t *)(stack[base + 14] - sizeof(uint64_t) * 4);
1885518855 // call ~fndef from register
@@ -19105,11 +19105,11 @@
1910519105 // throw from ProcCall
1910619106 if(!stack[base + 18])
1910719107 {
19108- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19108+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
1910919109 label = 1567LLU; // skip, variable already deleted/unscoped
1911019110 break;
1911119111 }
19112- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19112+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 isequal\n");
1911319113 label = 1567LLU; // continue unrolling stack, delete next variable
1911419114 break;
1911519115 }
@@ -19124,11 +19124,11 @@
1912419124 // throw from ProcCall
1912519125 if(!stack[base + 19])
1912619126 {
19127- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable [idnr] \n");
19127+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable [idnr] copyback\n");
1912819128 label = 1568LLU; // skip, variable already deleted/unscoped
1912919129 break;
1913019130 }
19131- fprintf(stderr, "in function ProcCall: unrolling stack, variable [idnr] \n");
19131+ fprintf(stderr, "in function ProcCall: unrolling stack, variable [idnr] copyback\n");
1913219132 // delete list
1913319133 label = 1572LLU; // start to repeat
1913419134 break;
@@ -19361,11 +19361,11 @@
1936119361 // throw from ProcCall
1936219362 if(!stack[base + 28])
1936319363 {
19364- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19364+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 cerescount\n");
1936519365 label = 1577LLU; // skip, variable already deleted/unscoped
1936619366 break;
1936719367 }
19368- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19368+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 cerescount\n");
1936919369 label = 1577LLU; // continue unrolling stack, delete next variable
1937019370 break;
1937119371 }
@@ -19381,11 +19381,11 @@
1938119381 // throw from ProcCall
1938219382 if(!stack[base + 29])
1938319383 {
19384- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19384+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 ceargcount\n");
1938519385 label = 1594LLU; // skip, variable already deleted/unscoped
1938619386 break;
1938719387 }
19388- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19388+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 ceargcount\n");
1938919389 label = 1594LLU; // continue unrolling stack, delete next variable
1939019390 break;
1939119391 }
@@ -19420,11 +19420,11 @@
1942019420 // throw from ProcCall
1942119421 if(!stack[base + 30])
1942219422 {
19423- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19423+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 sum\n");
1942419424 label = 1596LLU; // skip, variable already deleted/unscoped
1942519425 break;
1942619426 }
19427- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19427+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 sum\n");
1942819428 label = 1596LLU; // continue unrolling stack, delete next variable
1942919429 break;
1943019430 }
@@ -19439,11 +19439,11 @@
1943919439 // throw from ProcCall
1944019440 if(!stack[base + 31])
1944119441 {
19442- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19442+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 n\n");
1944319443 label = 1600LLU; // skip, variable already deleted/unscoped
1944419444 break;
1944519445 }
19446- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19446+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 n\n");
1944719447 label = 1600LLU; // continue unrolling stack, delete next variable
1944819448 break;
1944919449 }
@@ -19458,11 +19458,11 @@
1945819458 // throw from ProcCall
1945919459 if(!stack[base + 32])
1946019460 {
19461- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19461+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 index\n");
1946219462 label = 1602LLU; // skip, variable already deleted/unscoped
1946319463 break;
1946419464 }
19465- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19465+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 index\n");
1946619466 label = 1602LLU; // continue unrolling stack, delete next variable
1946719467 break;
1946819468 }
@@ -19508,11 +19508,11 @@
1950819508 // throw from ProcCall
1950919509 if(!stack[base + 33])
1951019510 {
19511- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19511+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
1951219512 label = 1604LLU; // skip, variable already deleted/unscoped
1951319513 break;
1951419514 }
19515- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19515+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 labelfail\n");
1951619516 label = 1604LLU; // continue unrolling stack, delete next variable
1951719517 break;
1951819518 }
@@ -19527,11 +19527,11 @@
1952719527 // throw from ProcCall
1952819528 if(!stack[base + 34])
1952919529 {
19530- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19530+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 recsztotal\n");
1953119531 label = 1610LLU; // skip, variable already deleted/unscoped
1953219532 break;
1953319533 }
19534- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19534+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 recsztotal\n");
1953519535 label = 1610LLU; // continue unrolling stack, delete next variable
1953619536 break;
1953719537 }
@@ -19850,11 +19850,11 @@
1985019850 // throw from ProcCall
1985119851 if(!stack[base + 35])
1985219852 {
19853- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
19853+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 csubstruct\n");
1985419854 label = 1612LLU; // skip, variable already deleted/unscoped
1985519855 break;
1985619856 }
19857- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
19857+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 csubstruct\n");
1985819858 label = 1612LLU; // continue unrolling stack, delete next variable
1985919859 break;
1986019860 }
@@ -21579,11 +21579,11 @@
2157921579 // throw from ProcCall
2158021580 if(!stack[base + 49])
2158121581 {
21582- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
21582+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr idnr\n");
2158321583 label = 1759LLU; // skip, variable already deleted/unscoped
2158421584 break;
2158521585 }
21586- fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");
21586+ fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr idnr\n");
2158721587
2158821588 uint64_t *newstack = (uint64_t *)(stack[base + 49] - sizeof(uint64_t) * 4);
2158921589 // call ~idnr from ProcCall
@@ -23564,11 +23564,11 @@
2356423564 // throw from ProcCall
2356523565 if(!stack[base + 33])
2356623566 {
23567- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 \n");
23567+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
2356823568 label = 1604LLU; // skip, variable already deleted/unscoped
2356923569 break;
2357023570 }
23571- fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 \n");
23571+ fprintf(stderr, "in function ProcCall: unrolling stack, variable u64 labelfail\n");
2357223572 label = 1604LLU; // continue unrolling stack, delete next variable
2357323573 break;
2357423574 }
@@ -25284,11 +25284,11 @@
2528425284 // throw from ProcCall
2528525285 if(!stack[base + 43])
2528625286 {
25287- fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
25287+ fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr idnr\n");
2528825288 label = 2058LLU; // skip, variable already deleted/unscoped
2528925289 break;
2529025290 }
25291- fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");
25291+ fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr idnr\n");
2529225292
2529325293 uint64_t *newstack = (uint64_t *)(stack[base + 43] - sizeof(uint64_t) * 4);
2529425294 // call ~idnr from ProcCall
@@ -27431,6 +27431,7 @@
2743127431 //#define arg6 6
2743227432 //#define arg7 7
2743327433 //#define arg8 8
27434+//#define arg9 9
2743427435 label = 2256LLU; // skip deleter
2743527436 break;
2743627437 }
@@ -27437,173 +27438,135 @@
2743727438 case 2255LLU: // deleter
2743827439 {
2743927440 // throw from initfrom
27440- if(!stack[base + 9])
27441+ if(!stack[base + 10])
2744127442 {
27442- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27443+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
2744327444 label = 2254LLU; // skip, variable already deleted/unscoped
2744427445 break;
2744527446 }
27446- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27447+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 isequal\n");
2744727448 label = 2254LLU; // continue unrolling stack, delete next variable
2744827449 break;
2744927450 }
2745027451 case 2256LLU: // skipped deleter
2745127452 {
27452- stack[base + 9] = 0;
27453- label = 2258LLU; // skip deleter
27454- break;
27455- }
27456- case 2257LLU: // deleter
27457- {
27458- // throw from initfrom
27459- if(!stack[base + 10])
27460- {
27461- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27462- label = 2255LLU; // skip, variable already deleted/unscoped
27463- break;
27464- }
27465- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27466- label = 2255LLU; // continue unrolling stack, delete next variable
27467- break;
27468- }
27469- case 2258LLU: // skipped deleter
27470- {
2747127453 stack[base + 10] = 0;
27472- label = 2260LLU; // skip deleter
27473- break;
27474- }
27475- case 2259LLU: // deleter
27476- {
27477- // throw from initfrom
27478- if(!stack[base + 11])
27479- {
27480- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27481- label = 2257LLU; // skip, variable already deleted/unscoped
27482- break;
27483- }
27484- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27485- label = 2257LLU; // continue unrolling stack, delete next variable
27486- break;
27487- }
27488- case 2260LLU: // skipped deleter
27489- {
27490- stack[base + 11] = 0;
2749127454 // call add from initfrom
27492- stack[base + 12LLU] = 2261LLU/*throw to this address*/;
27493- stack[base + 13LLU] = base;
27494- stack[base + 14LLU] = 2262LLU;
27455+ stack[base + 11LLU] = 2257LLU/*throw to this address*/;
27456+ stack[base + 12LLU] = base;
27457+ stack[base + 13LLU] = 2258LLU;
2749527458 // arguments for call to add
27496- stack[base + 16LLU] = 1LLU;
27497- stack[base + 17LLU] = stack[base + 7]/*label*/;
27459+ stack[base + 15LLU] = 1LLU;
27460+ stack[base + 16LLU] = stack[base + 8]/*label*/;
2749827461 // set stack-base & callee-address
27499- base += 15LLU;
27462+ base += 14LLU;
2750027463 label = 18446744073709551605LLU; // add
2750127464 break;
2750227465 }
27503- case 2261LLU: // copy-back deleter (add to initfrom)
27466+ case 2257LLU: // copy-back deleter (add to initfrom)
2750427467 {
2750527468 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2750627469 // copy mutable arguments back from call to add
27507- label = 2259LLU; // continue to roll stack
27470+ label = 2255LLU; // continue to roll stack
2750827471 break;
2750927472 }
27510- case 2262LLU: // return from add to initfrom
27473+ case 2258LLU: // return from add to initfrom
2751127474 {
2751227475 // copy mutable arguments back from call to add
2751327476 // copy back results provided by call to add
27514- stack[base + 7] = stack[base + 15LLU];
27515- label = 2264LLU; // skip deleter
27477+ stack[base + 8] = stack[base + 14LLU];
27478+ label = 2260LLU; // skip deleter
2751627479 break;
2751727480 }
27518- case 2263LLU: // deleter
27481+ case 2259LLU: // deleter
2751927482 {
2752027483 // throw from initfrom
27521- if(!stack[base + 12])
27484+ if(!stack[base + 11])
2752227485 {
27523- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27524- label = 2259LLU; // skip, variable already deleted/unscoped
27486+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
27487+ label = 2255LLU; // skip, variable already deleted/unscoped
2752527488 break;
2752627489 }
27527- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27528- label = 2259LLU; // continue unrolling stack, delete next variable
27490+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelfail\n");
27491+ label = 2255LLU; // continue unrolling stack, delete next variable
2752927492 break;
2753027493 }
27531- case 2264LLU: // skipped deleter
27494+ case 2260LLU: // skipped deleter
2753227495 {
27533- stack[base + 12] = stack[base + 7]/*label*/;
27534- if(/*scope*/0 != ((uint64_t *)(stack[base + 5]/*scope*/))[0])
27496+ stack[base + 11] = stack[base + 8]/*label*/;
27497+ if(/*scope*/0 != ((uint64_t *)(stack[base + 6]/*scope*/))[0])
2753527498 {
27536- label = 2266LLU; // jump to alternative
27499+ label = 2262LLU; // jump to alternative
2753727500 break;
2753827501 }
2753927502
27540- /*labelthrow*/stack[base + 13] = ((uint64_t **)(stack[base + 5]/*scope*/))[1][0]/*deleteaddr*/;
27541- /*dummy*/stack[base + 14] = ((uint64_t **)(stack[base + 5]/*scope*/))[1][1]/*letdefs*/;
27503+ /*labelthrow*/stack[base + 12] = ((uint64_t **)(stack[base + 6]/*scope*/))[1][0]/*deleteaddr*/;
27504+ /*dummy*/stack[base + 13] = ((uint64_t **)(stack[base + 6]/*scope*/))[1][1]/*letdefs*/;
2754227505
2754327506 // case
2754427507 // call add from initfrom
27545- stack[base + 15LLU] = 2268LLU/*throw to this address*/;
27546- stack[base + 16LLU] = base;
27547- stack[base + 17LLU] = 2269LLU;
27508+ stack[base + 14LLU] = 2264LLU/*throw to this address*/;
27509+ stack[base + 15LLU] = base;
27510+ stack[base + 16LLU] = 2265LLU;
2754827511 // arguments for call to add
27549- stack[base + 19LLU] = 1LLU;
27550- stack[base + 20LLU] = stack[base + 7]/*label*/;
27512+ stack[base + 18LLU] = 1LLU;
27513+ stack[base + 19LLU] = stack[base + 8]/*label*/;
2755127514 // set stack-base & callee-address
27552- base += 18LLU;
27515+ base += 17LLU;
2755327516 label = 18446744073709551605LLU; // add
2755427517 break;
2755527518 }
27556- case 2268LLU: // copy-back deleter (add to initfrom)
27519+ case 2264LLU: // copy-back deleter (add to initfrom)
2755727520 {
2755827521 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2755927522 // copy mutable arguments back from call to add
27560- label = 2267LLU; // continue to roll stack
27523+ label = 2263LLU; // continue to roll stack
2756127524 break;
2756227525 }
27563- case 2269LLU: // return from add to initfrom
27526+ case 2265LLU: // return from add to initfrom
2756427527 {
2756527528 // copy mutable arguments back from call to add
2756627529 // copy back results provided by call to add
27567- stack[base + 7] = stack[base + 18LLU];
27568- label = 2271LLU; // skip deleter
27530+ stack[base + 8] = stack[base + 17LLU];
27531+ label = 2267LLU; // skip deleter
2756927532 break;
2757027533 }
27571- case 2270LLU: // deleter
27534+ case 2266LLU: // deleter
2757227535 {
2757327536 // throw from initfrom
27574- if(!stack[base + 15])
27537+ if(!stack[base + 14])
2757527538 {
27576- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27577- label = 2267LLU; // skip, variable already deleted/unscoped
27539+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
27540+ label = 2263LLU; // skip, variable already deleted/unscoped
2757827541 break;
2757927542 }
27580- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27581- label = 2267LLU; // continue unrolling stack, delete next variable
27543+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelskip\n");
27544+ label = 2263LLU; // continue unrolling stack, delete next variable
2758227545 break;
2758327546 }
27584- case 2271LLU: // skipped deleter
27547+ case 2267LLU: // skipped deleter
2758527548 {
27586- stack[base + 15] = stack[base + 7]/*label*/;
27549+ stack[base + 14] = stack[base + 8]/*label*/;
2758727550 printf("%s", "\n label = ");
2758827551 // call printnr from initfrom
27589- stack[base + 16LLU] = 2272LLU/*throw to this address*/;
27590- stack[base + 17LLU] = base;
27591- stack[base + 18LLU] = 2273LLU;
27552+ stack[base + 15LLU] = 2268LLU/*throw to this address*/;
27553+ stack[base + 16LLU] = base;
27554+ stack[base + 17LLU] = 2269LLU;
2759227555 // arguments for call to printnr
27593- stack[base + 19LLU] = stack[base + 15]/*labelskip*/;
27556+ stack[base + 18LLU] = stack[base + 14]/*labelskip*/;
2759427557 // set stack-base & callee-address
27595- base += 19LLU;
27558+ base += 18LLU;
2759627559 label = 18446744073709551590LLU; // printnr
2759727560 break;
2759827561 }
27599- case 2272LLU: // copy-back deleter (printnr to initfrom)
27562+ case 2268LLU: // copy-back deleter (printnr to initfrom)
2760027563 {
2760127564 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2760227565 // copy mutable arguments back from call to printnr
27603- label = 2270LLU; // continue to roll stack
27566+ label = 2266LLU; // continue to roll stack
2760427567 break;
2760527568 }
27606- case 2273LLU: // return from printnr to initfrom
27569+ case 2269LLU: // return from printnr to initfrom
2760727570 {
2760827571 // copy mutable arguments back from call to printnr
2760927572 printf("%s", "LLU; // skip deleter");
@@ -27611,24 +27574,24 @@
2761127574 printf("%s", "\n }");
2761227575 printf("%s", "\n case ");
2761327576 // call printnr from initfrom
27614- stack[base + 16LLU] = 2274LLU/*throw to this address*/;
27615- stack[base + 17LLU] = base;
27616- stack[base + 18LLU] = 2275LLU;
27577+ stack[base + 15LLU] = 2270LLU/*throw to this address*/;
27578+ stack[base + 16LLU] = base;
27579+ stack[base + 17LLU] = 2271LLU;
2761727580 // arguments for call to printnr
27618- stack[base + 19LLU] = stack[base + 12]/*labelfail*/;
27581+ stack[base + 18LLU] = stack[base + 11]/*labelfail*/;
2761927582 // set stack-base & callee-address
27620- base += 19LLU;
27583+ base += 18LLU;
2762127584 label = 18446744073709551590LLU; // printnr
2762227585 break;
2762327586 }
27624- case 2274LLU: // copy-back deleter (printnr to initfrom)
27587+ case 2270LLU: // copy-back deleter (printnr to initfrom)
2762527588 {
2762627589 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2762727590 // copy mutable arguments back from call to printnr
27628- label = 2270LLU; // continue to roll stack
27591+ label = 2266LLU; // continue to roll stack
2762927592 break;
2763027593 }
27631- case 2275LLU: // return from printnr to initfrom
27594+ case 2271LLU: // return from printnr to initfrom
2763227595 {
2763327596 // copy mutable arguments back from call to printnr
2763427597 printf("%s", "LLU: // deleter");
@@ -27635,46 +27598,46 @@
2763527598 printf("%s", "\n {");
2763627599 printf("%s", "\n // throw from ");
2763727600 // call printid from initfrom
27638- stack[base + 16LLU] = 2276LLU/*throw to this address*/;
27639- stack[base + 17LLU] = base;
27640- stack[base + 18LLU] = 2277LLU;
27601+ stack[base + 15LLU] = 2272LLU/*throw to this address*/;
27602+ stack[base + 16LLU] = base;
27603+ stack[base + 17LLU] = 2273LLU;
2764127604 // arguments for call to printid
27642- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
27605+ stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2764327606 // set stack-base & callee-address
27644- base += 19LLU;
27607+ base += 18LLU;
2764527608 label = 18446744073709551587LLU; // printid
2764627609 break;
2764727610 }
27648- case 2276LLU: // copy-back deleter (printid to initfrom)
27611+ case 2272LLU: // copy-back deleter (printid to initfrom)
2764927612 {
2765027613 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2765127614 // copy mutable arguments back from call to printid
27652- label = 2270LLU; // continue to roll stack
27615+ label = 2266LLU; // continue to roll stack
2765327616 break;
2765427617 }
27655- case 2277LLU: // return from printid to initfrom
27618+ case 2273LLU: // return from printid to initfrom
2765627619 {
2765727620 // copy mutable arguments back from call to printid
2765827621 printf("%s", "\n if(!");
2765927622 // call emitvaridx from initfrom
27660- stack[base + 16LLU] = 2278LLU/*throw to this address*/;
27661- stack[base + 17LLU] = base;
27662- stack[base + 18LLU] = 2279LLU;
27623+ stack[base + 15LLU] = 2274LLU/*throw to this address*/;
27624+ stack[base + 16LLU] = base;
27625+ stack[base + 17LLU] = 2275LLU;
2766327626 // arguments for call to emitvaridx
27664- stack[base + 19LLU] = stack[base + 2]/*dstindex*/;
27627+ stack[base + 18LLU] = stack[base + 3]/*dstindex*/;
2766527628 // set stack-base & callee-address
27666- base += 19LLU;
27629+ base += 18LLU;
2766727630 label = 691LLU; // emitvaridx
2766827631 break;
2766927632 }
27670- case 2278LLU: // copy-back deleter (emitvaridx to initfrom)
27633+ case 2274LLU: // copy-back deleter (emitvaridx to initfrom)
2767127634 {
2767227635 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2767327636 // copy mutable arguments back from call to emitvaridx
27674- label = 2270LLU; // continue to roll stack
27637+ label = 2266LLU; // continue to roll stack
2767527638 break;
2767627639 }
27677- case 2279LLU: // return from emitvaridx to initfrom
27640+ case 2275LLU: // return from emitvaridx to initfrom
2767827641 {
2767927642 // copy mutable arguments back from call to emitvaridx
2768027643 printf("%s", ")");
@@ -27681,24 +27644,24 @@
2768127644 printf("%s", "\n {");
2768227645 printf("%s", "\n fprintf(stderr, \"in function ");
2768327646 // call printid from initfrom
27684- stack[base + 16LLU] = 2280LLU/*throw to this address*/;
27685- stack[base + 17LLU] = base;
27686- stack[base + 18LLU] = 2281LLU;
27647+ stack[base + 15LLU] = 2276LLU/*throw to this address*/;
27648+ stack[base + 16LLU] = base;
27649+ stack[base + 17LLU] = 2277LLU;
2768727650 // arguments for call to printid
27688- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
27651+ stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2768927652 // set stack-base & callee-address
27690- base += 19LLU;
27653+ base += 18LLU;
2769127654 label = 18446744073709551587LLU; // printid
2769227655 break;
2769327656 }
27694- case 2280LLU: // copy-back deleter (printid to initfrom)
27657+ case 2276LLU: // copy-back deleter (printid to initfrom)
2769527658 {
2769627659 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2769727660 // copy mutable arguments back from call to printid
27698- label = 2270LLU; // continue to roll stack
27661+ label = 2266LLU; // continue to roll stack
2769927662 break;
2770027663 }
27701- case 2281LLU: // return from printid to initfrom
27664+ case 2277LLU: // return from printid to initfrom
2770227665 {
2770327666 // copy mutable arguments back from call to printid
2770427667 printf("%s", ": unrolling stack, skipping already deleted/unscoped variable ");
@@ -27705,7 +27668,7 @@
2770527668 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2770627669 if(!newstack)
2770727670 {
27708- label = 2270LLU; // throw: begin to unroll stack
27671+ label = 2266LLU; // throw: begin to unroll stack
2770927672 break;
2771027673 }
2771127674
@@ -27712,9 +27675,9 @@
2771227675 newstack[10LLU] = 9876543210LLU; // overflow-marker
2771327676 // call printtype from initfrom
2771427677 newstack[0] = (uint64_t)stack; // backup stack location
27715- newstack[1] = 2282LLU;
27678+ newstack[1] = 2278LLU;
2771627679 newstack[2] = base;
27717- newstack[3] = 2283LLU;
27680+ newstack[3] = 2279LLU;
2771827681 // arguments for call to printtype
2771927682 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2772027683 stack = newstack;
@@ -27723,7 +27686,7 @@
2772327686 label = 305LLU; // printtype
2772427687 break;
2772527688 }
27726- case 2282LLU: // copy-back deleter (printtype to initfrom)
27689+ case 2278LLU: // copy-back deleter (printtype to initfrom)
2772727690 {
2772827691 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
2772927692 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -27735,10 +27698,10 @@
2773527698 }
2773627699 Free(10LLU + 1, sizeof(uint64_t), stack);
2773727700 stack = oldstack;
27738- label = 2270LLU; // continue to unroll stack
27701+ label = 2266LLU; // continue to unroll stack
2773927702 break;
2774027703 }
27741- case 2283LLU: // return from printtype to initfrom
27704+ case 2279LLU: // return from printtype to initfrom
2774227705 {
2774327706 uint64_t *oldstack = (uint64_t *)stack[0];
2774427707 // copy mutable arguments back from call to printtype
@@ -27751,47 +27714,47 @@
2775127714 stack = oldstack;
2775227715 printf("%s", " ");
2775327716 // call printid from initfrom
27754- stack[base + 16LLU] = 2284LLU/*throw to this address*/;
27755- stack[base + 17LLU] = base;
27756- stack[base + 18LLU] = 2285LLU;
27717+ stack[base + 15LLU] = 2280LLU/*throw to this address*/;
27718+ stack[base + 16LLU] = base;
27719+ stack[base + 17LLU] = 2281LLU;
2775727720 // arguments for call to printid
27758- stack[base + 19LLU] = stack[base + 11]/*content*/;
27721+ stack[base + 18LLU] = stack[base + 2]/*dstid*/;
2775927722 // set stack-base & callee-address
27760- base += 19LLU;
27723+ base += 18LLU;
2776127724 label = 18446744073709551587LLU; // printid
2776227725 break;
2776327726 }
27764- case 2284LLU: // copy-back deleter (printid to initfrom)
27727+ case 2280LLU: // copy-back deleter (printid to initfrom)
2776527728 {
2776627729 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2776727730 // copy mutable arguments back from call to printid
27768- label = 2270LLU; // continue to roll stack
27731+ label = 2266LLU; // continue to roll stack
2776927732 break;
2777027733 }
27771- case 2285LLU: // return from printid to initfrom
27734+ case 2281LLU: // return from printid to initfrom
2777227735 {
2777327736 // copy mutable arguments back from call to printid
2777427737 printf("%s", "\\n\");");
2777527738 printf("%s", "\n label = ");
2777627739 // call printnr from initfrom
27777- stack[base + 16LLU] = 2286LLU/*throw to this address*/;
27778- stack[base + 17LLU] = base;
27779- stack[base + 18LLU] = 2287LLU;
27740+ stack[base + 15LLU] = 2282LLU/*throw to this address*/;
27741+ stack[base + 16LLU] = base;
27742+ stack[base + 17LLU] = 2283LLU;
2778027743 // arguments for call to printnr
27781- stack[base + 19LLU] = stack[base + 13]/*labelthrow*/;
27744+ stack[base + 18LLU] = stack[base + 12]/*labelthrow*/;
2778227745 // set stack-base & callee-address
27783- base += 19LLU;
27746+ base += 18LLU;
2778427747 label = 18446744073709551590LLU; // printnr
2778527748 break;
2778627749 }
27787- case 2286LLU: // copy-back deleter (printnr to initfrom)
27750+ case 2282LLU: // copy-back deleter (printnr to initfrom)
2778827751 {
2778927752 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2779027753 // copy mutable arguments back from call to printnr
27791- label = 2270LLU; // continue to roll stack
27754+ label = 2266LLU; // continue to roll stack
2779227755 break;
2779327756 }
27794- case 2287LLU: // return from printnr to initfrom
27757+ case 2283LLU: // return from printnr to initfrom
2779527758 {
2779627759 // copy mutable arguments back from call to printnr
2779727760 printf("%s", "LLU; // skip, variable already deleted/unscoped");
@@ -27799,24 +27762,24 @@
2779927762 printf("%s", "\n }");
2780027763 printf("%s", "\n fprintf(stderr, \"in function ");
2780127764 // call printid from initfrom
27802- stack[base + 16LLU] = 2288LLU/*throw to this address*/;
27803- stack[base + 17LLU] = base;
27804- stack[base + 18LLU] = 2289LLU;
27765+ stack[base + 15LLU] = 2284LLU/*throw to this address*/;
27766+ stack[base + 16LLU] = base;
27767+ stack[base + 17LLU] = 2285LLU;
2780527768 // arguments for call to printid
27806- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
27769+ stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2780727770 // set stack-base & callee-address
27808- base += 19LLU;
27771+ base += 18LLU;
2780927772 label = 18446744073709551587LLU; // printid
2781027773 break;
2781127774 }
27812- case 2288LLU: // copy-back deleter (printid to initfrom)
27775+ case 2284LLU: // copy-back deleter (printid to initfrom)
2781327776 {
2781427777 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2781527778 // copy mutable arguments back from call to printid
27816- label = 2270LLU; // continue to roll stack
27779+ label = 2266LLU; // continue to roll stack
2781727780 break;
2781827781 }
27819- case 2289LLU: // return from printid to initfrom
27782+ case 2285LLU: // return from printid to initfrom
2782027783 {
2782127784 // copy mutable arguments back from call to printid
2782227785 printf("%s", ": unrolling stack, variable ");
@@ -27823,7 +27786,7 @@
2782327786 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2782427787 if(!newstack)
2782527788 {
27826- label = 2270LLU; // throw: begin to unroll stack
27789+ label = 2266LLU; // throw: begin to unroll stack
2782727790 break;
2782827791 }
2782927792
@@ -27830,9 +27793,9 @@
2783027793 newstack[10LLU] = 9876543210LLU; // overflow-marker
2783127794 // call printtype from initfrom
2783227795 newstack[0] = (uint64_t)stack; // backup stack location
27833- newstack[1] = 2290LLU;
27796+ newstack[1] = 2286LLU;
2783427797 newstack[2] = base;
27835- newstack[3] = 2291LLU;
27798+ newstack[3] = 2287LLU;
2783627799 // arguments for call to printtype
2783727800 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2783827801 stack = newstack;
@@ -27841,7 +27804,7 @@
2784127804 label = 305LLU; // printtype
2784227805 break;
2784327806 }
27844- case 2290LLU: // copy-back deleter (printtype to initfrom)
27807+ case 2286LLU: // copy-back deleter (printtype to initfrom)
2784527808 {
2784627809 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
2784727810 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -27853,10 +27816,10 @@
2785327816 }
2785427817 Free(10LLU + 1, sizeof(uint64_t), stack);
2785527818 stack = oldstack;
27856- label = 2270LLU; // continue to unroll stack
27819+ label = 2266LLU; // continue to unroll stack
2785727820 break;
2785827821 }
27859- case 2291LLU: // return from printtype to initfrom
27822+ case 2287LLU: // return from printtype to initfrom
2786027823 {
2786127824 uint64_t *oldstack = (uint64_t *)stack[0];
2786227825 // copy mutable arguments back from call to printtype
@@ -27869,24 +27832,24 @@
2786927832 stack = oldstack;
2787027833 printf("%s", " ");
2787127834 // call printid from initfrom
27872- stack[base + 16LLU] = 2292LLU/*throw to this address*/;
27873- stack[base + 17LLU] = base;
27874- stack[base + 18LLU] = 2293LLU;
27835+ stack[base + 15LLU] = 2288LLU/*throw to this address*/;
27836+ stack[base + 16LLU] = base;
27837+ stack[base + 17LLU] = 2289LLU;
2787527838 // arguments for call to printid
27876- stack[base + 19LLU] = stack[base + 11]/*content*/;
27839+ stack[base + 18LLU] = stack[base + 2]/*dstid*/;
2787727840 // set stack-base & callee-address
27878- base += 19LLU;
27841+ base += 18LLU;
2787927842 label = 18446744073709551587LLU; // printid
2788027843 break;
2788127844 }
27882- case 2292LLU: // copy-back deleter (printid to initfrom)
27845+ case 2288LLU: // copy-back deleter (printid to initfrom)
2788327846 {
2788427847 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2788527848 // copy mutable arguments back from call to printid
27886- label = 2270LLU; // continue to roll stack
27849+ label = 2266LLU; // continue to roll stack
2788727850 break;
2788827851 }
27889- case 2293LLU: // return from printid to initfrom
27852+ case 2289LLU: // return from printid to initfrom
2789027853 {
2789127854 // copy mutable arguments back from call to printid
2789227855 printf("%s", "\\n\");");
@@ -27893,7 +27856,7 @@
2789327856 uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t));
2789427857 if(!newstack)
2789527858 {
27896- label = 2270LLU; // throw: begin to unroll stack
27859+ label = 2266LLU; // throw: begin to unroll stack
2789727860 break;
2789827861 }
2789927862
@@ -27900,15 +27863,15 @@
2790027863 newstack[75LLU] = 9876543210LLU; // overflow-marker
2790127864 // call calldestr from initfrom
2790227865 newstack[0] = (uint64_t)stack; // backup stack location
27903- newstack[1] = 2294LLU;
27866+ newstack[1] = 2290LLU;
2790427867 newstack[2] = base;
27905- newstack[3] = 2295LLU;
27868+ newstack[3] = 2291LLU;
2790627869 // arguments for call to calldestr
2790727870 newstack[4LLU] = stack[base + 0]/*fnid*/;
27908- newstack[5LLU] = stack[base + 3]/*typedefs*/;
27871+ newstack[5LLU] = stack[base + 4]/*typedefs*/;
2790927872 newstack[6LLU] = stack[base + 1]/*dsttype*/;
27910- newstack[7LLU] = stack[base + 2]/*dstindex*/;
27911- newstack[8LLU] = stack[base + 7]/*label*/;
27873+ newstack[7LLU] = stack[base + 3]/*dstindex*/;
27874+ newstack[8LLU] = stack[base + 8]/*label*/;
2791227875 newstack[9LLU] = 0LLU; //
2791327876 stack = newstack;
2791427877 // set stack-base & callee-address
@@ -27916,12 +27879,12 @@
2791627879 label = 1084LLU; // calldestr
2791727880 break;
2791827881 }
27919- case 2294LLU: // copy-back deleter (calldestr to initfrom)
27882+ case 2290LLU: // copy-back deleter (calldestr to initfrom)
2792027883 {
2792127884 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (calldestr to initfrom)\n");
2792227885 uint64_t *oldstack = (uint64_t *)stack[0];
2792327886 // copy mutable arguments back from call to calldestr
27924- oldstack[base + 7]/*label*/ = stack[8LLU];
27887+ oldstack[base + 8]/*label*/ = stack[8LLU];
2792527888 if(stack[75LLU] != 9876543210LLU)
2792627889 {
2792727890 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");
@@ -27929,14 +27892,14 @@
2792927892 }
2793027893 Free(75LLU + 1, sizeof(uint64_t), stack);
2793127894 stack = oldstack;
27932- label = 2270LLU; // continue to unroll stack
27895+ label = 2266LLU; // continue to unroll stack
2793327896 break;
2793427897 }
27935- case 2295LLU: // return from calldestr to initfrom
27898+ case 2291LLU: // return from calldestr to initfrom
2793627899 {
2793727900 uint64_t *oldstack = (uint64_t *)stack[0];
2793827901 // copy mutable arguments back from call to calldestr
27939- oldstack[base + 7]/*label*/ = stack[8LLU];
27902+ oldstack[base + 8]/*label*/ = stack[8LLU];
2794027903 if(stack[75LLU] != 9876543210LLU)
2794127904 {
2794227905 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");
@@ -27946,24 +27909,24 @@
2794627909 stack = oldstack;
2794727910 printf("%s", "\n label = ");
2794827911 // call printnr from initfrom
27949- stack[base + 16LLU] = 2296LLU/*throw to this address*/;
27950- stack[base + 17LLU] = base;
27951- stack[base + 18LLU] = 2297LLU;
27912+ stack[base + 15LLU] = 2292LLU/*throw to this address*/;
27913+ stack[base + 16LLU] = base;
27914+ stack[base + 17LLU] = 2293LLU;
2795227915 // arguments for call to printnr
27953- stack[base + 19LLU] = stack[base + 13]/*labelthrow*/;
27916+ stack[base + 18LLU] = stack[base + 12]/*labelthrow*/;
2795427917 // set stack-base & callee-address
27955- base += 19LLU;
27918+ base += 18LLU;
2795627919 label = 18446744073709551590LLU; // printnr
2795727920 break;
2795827921 }
27959- case 2296LLU: // copy-back deleter (printnr to initfrom)
27922+ case 2292LLU: // copy-back deleter (printnr to initfrom)
2796027923 {
2796127924 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2796227925 // copy mutable arguments back from call to printnr
27963- label = 2270LLU; // continue to roll stack
27926+ label = 2266LLU; // continue to roll stack
2796427927 break;
2796527928 }
27966- case 2297LLU: // return from printnr to initfrom
27929+ case 2293LLU: // return from printnr to initfrom
2796727930 {
2796827931 // copy mutable arguments back from call to printnr
2796927932 printf("%s", "LLU; // continue unrolling stack, delete next variable");
@@ -27971,101 +27934,101 @@
2797127934 printf("%s", "\n }");
2797227935 printf("%s", "\n case ");
2797327936 // call printnr from initfrom
27974- stack[base + 16LLU] = 2298LLU/*throw to this address*/;
27975- stack[base + 17LLU] = base;
27976- stack[base + 18LLU] = 2299LLU;
27937+ stack[base + 15LLU] = 2294LLU/*throw to this address*/;
27938+ stack[base + 16LLU] = base;
27939+ stack[base + 17LLU] = 2295LLU;
2797727940 // arguments for call to printnr
27978- stack[base + 19LLU] = stack[base + 15]/*labelskip*/;
27941+ stack[base + 18LLU] = stack[base + 14]/*labelskip*/;
2797927942 // set stack-base & callee-address
27980- base += 19LLU;
27943+ base += 18LLU;
2798127944 label = 18446744073709551590LLU; // printnr
2798227945 break;
2798327946 }
27984- case 2298LLU: // copy-back deleter (printnr to initfrom)
27947+ case 2294LLU: // copy-back deleter (printnr to initfrom)
2798527948 {
2798627949 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2798727950 // copy mutable arguments back from call to printnr
27988- label = 2270LLU; // continue to roll stack
27951+ label = 2266LLU; // continue to roll stack
2798927952 break;
2799027953 }
27991- case 2299LLU: // return from printnr to initfrom
27954+ case 2295LLU: // return from printnr to initfrom
2799227955 {
2799327956 // copy mutable arguments back from call to printnr
2799427957 printf("%s", "LLU: // skipped deleter");
2799527958 printf("%s", "\n {");
27996- ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
27997- ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
27998- label = 2265LLU; // case complete
27959+ ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 13];
27960+ ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 12];
27961+ label = 2261LLU; // case complete
2799927962 break;
2800027963 }
28001- case 2267LLU: // copy-back deleter (switch)
27964+ case 2263LLU: // copy-back deleter (switch)
2800227965 {
28003- ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
28004- ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
28005- label = 2263LLU; // continue to unroll stack
27966+ ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 13];
27967+ ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 12];
27968+ label = 2259LLU; // continue to unroll stack
2800627969 break;
2800727970 }
28008- case 2266LLU: // try next case
27971+ case 2262LLU: // try next case
2800927972 {
2801027973 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2801127974 exit(-1);
2801227975 }
28013- case 2265LLU: // completed switch
27976+ case 2261LLU: // completed switch
2801427977 {
2801527978 // call ParseToken from initfrom
28016- stack[base + 13LLU] = 2300LLU/*throw to this address*/;
28017- stack[base + 14LLU] = base;
28018- stack[base + 15LLU] = 2301LLU;
27979+ stack[base + 14LLU] = 2296LLU/*throw to this address*/;
27980+ stack[base + 15LLU] = base;
27981+ stack[base + 16LLU] = 2297LLU;
2801927982 // arguments for call to ParseToken
28020- stack[base + 18LLU] = stack[base + 6]/*lookahead*/;
27983+ stack[base + 19LLU] = stack[base + 7]/*lookahead*/;
2802127984 // set stack-base & callee-address
28022- base += 16LLU;
27985+ base += 17LLU;
2802327986 label = 3LLU; // ParseToken
2802427987 break;
2802527988 }
28026- case 2300LLU: // copy-back deleter (ParseToken to initfrom)
27989+ case 2296LLU: // copy-back deleter (ParseToken to initfrom)
2802727990 {
2802827991 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2802927992 // copy mutable arguments back from call to ParseToken
28030- stack[base + 6]/*lookahead*/ = stack[base + 18LLU];
28031- label = 2263LLU; // continue to roll stack
27993+ stack[base + 7]/*lookahead*/ = stack[base + 19LLU];
27994+ label = 2259LLU; // continue to roll stack
2803227995 break;
2803327996 }
28034- case 2301LLU: // return from ParseToken to initfrom
27997+ case 2297LLU: // return from ParseToken to initfrom
2803527998 {
2803627999 // copy mutable arguments back from call to ParseToken
28037- stack[base + 6]/*lookahead*/ = stack[base + 18LLU];
28000+ stack[base + 7]/*lookahead*/ = stack[base + 19LLU];
2803828001 // copy back results provided by call to ParseToken
28039- stack[base + 10] = stack[base + 16LLU];
28040- stack[base + 11] = stack[base + 17LLU];
28002+ stack[base + 12] = stack[base + 17LLU];
28003+ stack[base + 13] = stack[base + 18LLU];
2804128004 // call issimple from initfrom
28042- stack[base + 14LLU] = 2302LLU/*throw to this address*/;
28043- stack[base + 15LLU] = base;
28044- stack[base + 16LLU] = 2303LLU;
28005+ stack[base + 15LLU] = 2298LLU/*throw to this address*/;
28006+ stack[base + 16LLU] = base;
28007+ stack[base + 17LLU] = 2299LLU;
2804528008 // arguments for call to issimple
28046- stack[base + 18LLU] = stack[base + 10]/*variant*/;
28047- stack[base + 19LLU] = stack[base + 11]/*content*/;
28048- stack[base + 20LLU] = 33LLU;
28009+ stack[base + 19LLU] = stack[base + 12]/*variant*/;
28010+ stack[base + 20LLU] = stack[base + 13]/*content*/;
28011+ stack[base + 21LLU] = 33LLU;
2804928012 // set stack-base & callee-address
28050- base += 17LLU;
28013+ base += 18LLU;
2805128014 label = 158LLU; // issimple
2805228015 break;
2805328016 }
28054- case 2302LLU: // copy-back deleter (issimple to initfrom)
28017+ case 2298LLU: // copy-back deleter (issimple to initfrom)
2805528018 {
2805628019 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
2805728020 // copy mutable arguments back from call to issimple
28058- label = 2263LLU; // continue to roll stack
28021+ label = 2259LLU; // continue to roll stack
2805928022 break;
2806028023 }
28061- case 2303LLU: // return from issimple to initfrom
28024+ case 2299LLU: // return from issimple to initfrom
2806228025 {
2806328026 // copy mutable arguments back from call to issimple
2806428027 // copy back results provided by call to issimple
28065- stack[base + 13] = stack[base + 17LLU];
28066- if(!stack[base + 13]/*forceerror*/)
28028+ stack[base + 14] = stack[base + 18LLU];
28029+ if(!stack[base + 14]/*forceerror*/)
2806728030 {
28068- label = 2304LLU; // jump to alternative
28031+ label = 2300LLU; // jump to alternative
2806928032 break;
2807028033 }
2807128034
@@ -28072,187 +28035,187 @@
2807228035 // consequent
2807328036 fprintf(stderr, "%s", "in function ");
2807428037 // call reportid from initfrom
28075- stack[base + 14LLU] = 2306LLU/*throw to this address*/;
28076- stack[base + 15LLU] = base;
28077- stack[base + 16LLU] = 2307LLU;
28038+ stack[base + 15LLU] = 2302LLU/*throw to this address*/;
28039+ stack[base + 16LLU] = base;
28040+ stack[base + 17LLU] = 2303LLU;
2807828041 // arguments for call to reportid
28079- stack[base + 17LLU] = stack[base + 0]/*fnid*/;
28042+ stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2808028043 // set stack-base & callee-address
28081- base += 17LLU;
28044+ base += 18LLU;
2808228045 label = 18446744073709551586LLU; // reportid
2808328046 break;
2808428047 }
28085- case 2306LLU: // copy-back deleter (reportid to initfrom)
28048+ case 2302LLU: // copy-back deleter (reportid to initfrom)
2808628049 {
2808728050 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2808828051 // copy mutable arguments back from call to reportid
28089- label = 2263LLU; // continue to roll stack
28052+ label = 2259LLU; // continue to roll stack
2809028053 break;
2809128054 }
28092- case 2307LLU: // return from reportid to initfrom
28055+ case 2303LLU: // return from reportid to initfrom
2809328056 {
2809428057 // copy mutable arguments back from call to reportid
2809528058 fprintf(stderr, "%s", ": WARNING, FORCING CONSTRUCTION TO FAIL TO TEST THROW MECHANISM!\n");
2809628059 // call ParseToken from initfrom
28097- stack[base + 14LLU] = 2308LLU/*throw to this address*/;
28098- stack[base + 15LLU] = base;
28099- stack[base + 16LLU] = 2309LLU;
28060+ stack[base + 15LLU] = 2304LLU/*throw to this address*/;
28061+ stack[base + 16LLU] = base;
28062+ stack[base + 17LLU] = 2305LLU;
2810028063 // arguments for call to ParseToken
28101- stack[base + 19LLU] = stack[base + 6]/*lookahead*/;
28064+ stack[base + 20LLU] = stack[base + 7]/*lookahead*/;
2810228065 // set stack-base & callee-address
28103- base += 17LLU;
28066+ base += 18LLU;
2810428067 label = 3LLU; // ParseToken
2810528068 break;
2810628069 }
28107- case 2308LLU: // copy-back deleter (ParseToken to initfrom)
28070+ case 2304LLU: // copy-back deleter (ParseToken to initfrom)
2810828071 {
2810928072 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2811028073 // copy mutable arguments back from call to ParseToken
28111- stack[base + 6]/*lookahead*/ = stack[base + 19LLU];
28112- label = 2263LLU; // continue to roll stack
28074+ stack[base + 7]/*lookahead*/ = stack[base + 20LLU];
28075+ label = 2259LLU; // continue to roll stack
2811328076 break;
2811428077 }
28115- case 2309LLU: // return from ParseToken to initfrom
28078+ case 2305LLU: // return from ParseToken to initfrom
2811628079 {
2811728080 // copy mutable arguments back from call to ParseToken
28118- stack[base + 6]/*lookahead*/ = stack[base + 19LLU];
28081+ stack[base + 7]/*lookahead*/ = stack[base + 20LLU];
2811928082 // copy back results provided by call to ParseToken
28120- stack[base + 10] = stack[base + 17LLU];
28121- stack[base + 11] = stack[base + 18LLU];
28122- label = 2305LLU; // consequent complete
28083+ stack[base + 12] = stack[base + 18LLU];
28084+ stack[base + 13] = stack[base + 19LLU];
28085+ label = 2301LLU; // consequent complete
2812328086 break;
2812428087 }
28125- case 2304LLU: // alternative
28088+ case 2300LLU: // alternative
2812628089 {
28127- label = 2305LLU; // alternative complete
28090+ label = 2301LLU; // alternative complete
2812828091 break;
2812928092 }
28130- case 2305LLU: // completed if-then-else
28093+ case 2301LLU: // completed if-then-else
2813128094 {
2813228095 // call equ from initfrom
28133- stack[base + 14LLU] = 2310LLU/*throw to this address*/;
28134- stack[base + 15LLU] = base;
28135- stack[base + 16LLU] = 2311LLU;
28096+ stack[base + 15LLU] = 2306LLU/*throw to this address*/;
28097+ stack[base + 16LLU] = base;
28098+ stack[base + 17LLU] = 2307LLU;
2813628099 // arguments for call to equ
28137- stack[base + 18LLU] = stack[base + 10]/*variant*/;
28138- stack[base + 19LLU] = 4LLU;
28100+ stack[base + 19LLU] = stack[base + 12]/*variant*/;
28101+ stack[base + 20LLU] = 4LLU;
2813928102 // set stack-base & callee-address
28140- base += 17LLU;
28103+ base += 18LLU;
2814128104 label = 18446744073709551600LLU; // equ
2814228105 break;
2814328106 }
28144- case 2310LLU: // copy-back deleter (equ to initfrom)
28107+ case 2306LLU: // copy-back deleter (equ to initfrom)
2814528108 {
2814628109 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2814728110 // copy mutable arguments back from call to equ
28148- label = 2263LLU; // continue to roll stack
28111+ label = 2259LLU; // continue to roll stack
2814928112 break;
2815028113 }
28151- case 2311LLU: // return from equ to initfrom
28114+ case 2307LLU: // return from equ to initfrom
2815228115 {
2815328116 // copy mutable arguments back from call to equ
2815428117 // copy back results provided by call to equ
28155- stack[base + 9] = stack[base + 17LLU];
28156- if(!stack[base + 9]/*isequal*/)
28118+ stack[base + 10] = stack[base + 18LLU];
28119+ if(!stack[base + 10]/*isequal*/)
2815728120 {
28158- label = 2312LLU; // jump to alternative
28121+ label = 2308LLU; // jump to alternative
2815928122 break;
2816028123 }
2816128124
2816228125 // consequent
2816328126 // call skipwscmnt from initfrom
28164- stack[base + 14LLU] = 2314LLU/*throw to this address*/;
28165- stack[base + 15LLU] = base;
28166- stack[base + 16LLU] = 2315LLU;
28127+ stack[base + 15LLU] = 2310LLU/*throw to this address*/;
28128+ stack[base + 16LLU] = base;
28129+ stack[base + 17LLU] = 2311LLU;
2816728130 // arguments for call to skipwscmnt
28168- stack[base + 18LLU] = stack[base + 6]/*lookahead*/;
28131+ stack[base + 19LLU] = stack[base + 7]/*lookahead*/;
2816928132 // set stack-base & callee-address
28170- base += 17LLU;
28133+ base += 18LLU;
2817128134 label = 18446744073709551580LLU; // skipwscmnt
2817228135 break;
2817328136 }
28174- case 2314LLU: // copy-back deleter (skipwscmnt to initfrom)
28137+ case 2310LLU: // copy-back deleter (skipwscmnt to initfrom)
2817528138 {
2817628139 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (skipwscmnt to initfrom)\n");
2817728140 // copy mutable arguments back from call to skipwscmnt
28178- label = 2263LLU; // continue to roll stack
28141+ label = 2259LLU; // continue to roll stack
2817928142 break;
2818028143 }
28181- case 2315LLU: // return from skipwscmnt to initfrom
28144+ case 2311LLU: // return from skipwscmnt to initfrom
2818228145 {
2818328146 // copy mutable arguments back from call to skipwscmnt
2818428147 // copy back results provided by call to skipwscmnt
28185- stack[base + 6] = stack[base + 17LLU];
28148+ stack[base + 7] = stack[base + 18LLU];
2818628149 // call equ from initfrom
28187- stack[base + 15LLU] = 2316LLU/*throw to this address*/;
28188- stack[base + 16LLU] = base;
28189- stack[base + 17LLU] = 2317LLU;
28150+ stack[base + 16LLU] = 2312LLU/*throw to this address*/;
28151+ stack[base + 17LLU] = base;
28152+ stack[base + 18LLU] = 2313LLU;
2819028153 // arguments for call to equ
28191- stack[base + 19LLU] = stack[base + 6]/*lookahead*/;
28192- stack[base + 20LLU] = 46LLU;
28154+ stack[base + 20LLU] = stack[base + 7]/*lookahead*/;
28155+ stack[base + 21LLU] = 46LLU;
2819328156 // set stack-base & callee-address
28194- base += 18LLU;
28157+ base += 19LLU;
2819528158 label = 18446744073709551600LLU; // equ
2819628159 break;
2819728160 }
28198- case 2316LLU: // copy-back deleter (equ to initfrom)
28161+ case 2312LLU: // copy-back deleter (equ to initfrom)
2819928162 {
2820028163 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2820128164 // copy mutable arguments back from call to equ
28202- label = 2263LLU; // continue to roll stack
28165+ label = 2259LLU; // continue to roll stack
2820328166 break;
2820428167 }
28205- case 2317LLU: // return from equ to initfrom
28168+ case 2313LLU: // return from equ to initfrom
2820628169 {
2820728170 // copy mutable arguments back from call to equ
2820828171 // copy back results provided by call to equ
28209- stack[base + 14] = stack[base + 18LLU];
28210- if(!stack[base + 14]/*namespace*/)
28172+ stack[base + 15] = stack[base + 19LLU];
28173+ if(!stack[base + 15]/*namespace*/)
2821128174 {
28212- label = 2318LLU; // jump to alternative
28175+ label = 2314LLU; // jump to alternative
2821328176 break;
2821428177 }
2821528178
2821628179 // consequent
28217- label = 2321LLU; // skip deleter
28180+ label = 2317LLU; // skip deleter
2821828181 break;
2821928182 }
28220- case 2320LLU: // deleter
28183+ case 2316LLU: // deleter
2822128184 {
2822228185 // throw from initfrom
28223- if(!stack[base + 15])
28186+ if(!stack[base + 16])
2822428187 {
28225- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28226- label = 2263LLU; // skip, variable already deleted/unscoped
28188+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 typename\n");
28189+ label = 2259LLU; // skip, variable already deleted/unscoped
2822728190 break;
2822828191 }
28229- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28230- label = 2263LLU; // continue unrolling stack, delete next variable
28192+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 typename\n");
28193+ label = 2259LLU; // continue unrolling stack, delete next variable
2823128194 break;
2823228195 }
28233- case 2321LLU: // skipped deleter
28196+ case 2317LLU: // skipped deleter
2823428197 {
28235- stack[base + 15] = stack[base + 11]/*content*/;
28236- label = 2323LLU; // skip deleter
28198+ stack[base + 16] = stack[base + 13]/*content*/;
28199+ label = 2319LLU; // skip deleter
2823728200 break;
2823828201 }
28239- case 2322LLU: // deleter
28202+ case 2318LLU: // deleter
2824028203 {
2824128204 // throw from initfrom
28242- if(!stack[base + 16])
28205+ if(!stack[base + 17])
2824328206 {
28244- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type \n");
28245- label = 2320LLU; // skip, variable already deleted/unscoped
28207+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type assigntype\n");
28208+ label = 2316LLU; // skip, variable already deleted/unscoped
2824628209 break;
2824728210 }
28248- fprintf(stderr, "in function initfrom: unrolling stack, variable type \n");
28211+ fprintf(stderr, "in function initfrom: unrolling stack, variable type assigntype\n");
2824928212
28250- uint64_t *newstack = (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4);
28213+ uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
2825128214 // call ~type from initfrom
2825228215 newstack[0] = (uint64_t)stack; // backup stack location
2825328216 newstack[1] = 1234567890;
2825428217 newstack[2] = base;
28255- newstack[3] = 2324LLU;
28218+ newstack[3] = 2320LLU;
2825628219 stack = newstack;
2825728220 // set stack-base & callee-address
2825828221 base = 4/*deloffset*/;
@@ -28259,31 +28222,31 @@
2825928222 label = 296LLU; // ~type
2826028223 break;
2826128224 }
28262- case 2324LLU: // return from ~type to initfrom
28225+ case 2320LLU: // return from ~type to initfrom
2826328226 {
2826428227 stack = (uint64_t *)stack[0];
2826528228 // releasing toplevel container
28266- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
28229+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2826728230
28268- label = 2320LLU; // continue unrolling stack, delete next variable
28231+ label = 2316LLU; // continue unrolling stack, delete next variable
2826928232 break;
2827028233 }
28271- case 2323LLU: // skipped deleter
28234+ case 2319LLU: // skipped deleter
2827228235 {
2827328236 // construct type.typename
28274- if(!(stack[base + 16] = construct(1)))
28237+ if(!(stack[base + 17] = construct(1)))
2827528238 {
28276- label = 2320LLU; // throw: begin to unroll stack
28239+ label = 2316LLU; // throw: begin to unroll stack
2827728240 break;
2827828241 }
2827928242
2828028243 // consequent
28281- ((uint64_t *)stack[base + 16])[0] = 0;
28282- (((uint64_t **)(stack[base + 16]))[1][0]) = stack[base + 11]/*content*/;
28244+ ((uint64_t *)stack[base + 17])[0] = 0;
28245+ (((uint64_t **)(stack[base + 17]))[1][0]) = stack[base + 13]/*content*/;
2828328246 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2828428247 if(!newstack)
2828528248 {
28286- label = 2322LLU; // throw: begin to unroll stack
28249+ label = 2318LLU; // throw: begin to unroll stack
2828728250 break;
2828828251 }
2828928252
@@ -28290,12 +28253,12 @@
2829028253 newstack[15LLU] = 9876543210LLU; // overflow-marker
2829128254 // call equtype from initfrom
2829228255 newstack[0] = (uint64_t)stack; // backup stack location
28293- newstack[1] = 2325LLU;
28256+ newstack[1] = 2321LLU;
2829428257 newstack[2] = base;
28295- newstack[3] = 2326LLU;
28258+ newstack[3] = 2322LLU;
2829628259 // arguments for call to equtype
2829728260 newstack[5LLU] = stack[base + 1]/*dsttype*/;
28298- newstack[6LLU] = stack[base + 16]/*assigntype*/;
28261+ newstack[6LLU] = stack[base + 17]/*assigntype*/;
2829928262 stack = newstack;
2830028263 // set stack-base & callee-address
2830128264 base = 4/*deloffset*/;
@@ -28302,7 +28265,7 @@
2830228265 label = 342LLU; // equtype
2830328266 break;
2830428267 }
28305- case 2325LLU: // copy-back deleter (equtype to initfrom)
28268+ case 2321LLU: // copy-back deleter (equtype to initfrom)
2830628269 {
2830728270 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2830828271 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28314,15 +28277,15 @@
2831428277 }
2831528278 Free(15LLU + 1, sizeof(uint64_t), stack);
2831628279 stack = oldstack;
28317- label = 2322LLU; // continue to unroll stack
28280+ label = 2318LLU; // continue to unroll stack
2831828281 break;
2831928282 }
28320- case 2326LLU: // return from equtype to initfrom
28283+ case 2322LLU: // return from equtype to initfrom
2832128284 {
2832228285 uint64_t *oldstack = (uint64_t *)stack[0];
2832328286 // copy mutable arguments back from call to equtype
2832428287 // copy back results provided by call to equtype
28325- oldstack[base + 9] = stack[4LLU];
28288+ oldstack[base + 10] = stack[4LLU];
2832628289 if(stack[15LLU] != 9876543210LLU)
2832728290 {
2832828291 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -28330,38 +28293,38 @@
2833028293 }
2833128294 Free(15LLU + 1, sizeof(uint64_t), stack);
2833228295 stack = oldstack;
28333- if(!stack[base + 9]/*isequal*/)
28296+ if(!stack[base + 10]/*isequal*/)
2833428297 {
28335- label = 2327LLU; // jump to alternative
28298+ label = 2323LLU; // jump to alternative
2833628299 break;
2833728300 }
2833828301
2833928302 // consequent
28340- label = 2328LLU; // consequent complete
28303+ label = 2324LLU; // consequent complete
2834128304 break;
2834228305 }
28343- case 2327LLU: // alternative
28306+ case 2323LLU: // alternative
2834428307 {
2834528308 fprintf(stderr, "%s", "in function ");
2834628309 // call reportid from initfrom
28347- stack[base + 17LLU] = 2329LLU/*throw to this address*/;
28348- stack[base + 18LLU] = base;
28349- stack[base + 19LLU] = 2330LLU;
28310+ stack[base + 18LLU] = 2325LLU/*throw to this address*/;
28311+ stack[base + 19LLU] = base;
28312+ stack[base + 20LLU] = 2326LLU;
2835028313 // arguments for call to reportid
28351- stack[base + 20LLU] = stack[base + 0]/*fnid*/;
28314+ stack[base + 21LLU] = stack[base + 0]/*fnid*/;
2835228315 // set stack-base & callee-address
28353- base += 20LLU;
28316+ base += 21LLU;
2835428317 label = 18446744073709551586LLU; // reportid
2835528318 break;
2835628319 }
28357- case 2329LLU: // copy-back deleter (reportid to initfrom)
28320+ case 2325LLU: // copy-back deleter (reportid to initfrom)
2835828321 {
2835928322 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2836028323 // copy mutable arguments back from call to reportid
28361- label = 2322LLU; // continue to roll stack
28324+ label = 2318LLU; // continue to roll stack
2836228325 break;
2836328326 }
28364- case 2330LLU: // return from reportid to initfrom
28327+ case 2326LLU: // return from reportid to initfrom
2836528328 {
2836628329 // copy mutable arguments back from call to reportid
2836728330 fprintf(stderr, "%s", ": can't construct type ");
@@ -28368,7 +28331,7 @@
2836828331 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2836928332 if(!newstack)
2837028333 {
28371- label = 2322LLU; // throw: begin to unroll stack
28334+ label = 2318LLU; // throw: begin to unroll stack
2837228335 break;
2837328336 }
2837428337
@@ -28375,9 +28338,9 @@
2837528338 newstack[10LLU] = 9876543210LLU; // overflow-marker
2837628339 // call reporttype from initfrom
2837728340 newstack[0] = (uint64_t)stack; // backup stack location
28378- newstack[1] = 2331LLU;
28341+ newstack[1] = 2327LLU;
2837928342 newstack[2] = base;
28380- newstack[3] = 2332LLU;
28343+ newstack[3] = 2328LLU;
2838128344 // arguments for call to reporttype
2838228345 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2838328346 stack = newstack;
@@ -28386,7 +28349,7 @@
2838628349 label = 316LLU; // reporttype
2838728350 break;
2838828351 }
28389- case 2331LLU: // copy-back deleter (reporttype to initfrom)
28352+ case 2327LLU: // copy-back deleter (reporttype to initfrom)
2839028353 {
2839128354 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2839228355 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28398,10 +28361,10 @@
2839828361 }
2839928362 Free(10LLU + 1, sizeof(uint64_t), stack);
2840028363 stack = oldstack;
28401- label = 2322LLU; // continue to unroll stack
28364+ label = 2318LLU; // continue to unroll stack
2840228365 break;
2840328366 }
28404- case 2332LLU: // return from reporttype to initfrom
28367+ case 2328LLU: // return from reporttype to initfrom
2840528368 {
2840628369 uint64_t *oldstack = (uint64_t *)stack[0];
2840728370 // copy mutable arguments back from call to reporttype
@@ -28416,7 +28379,7 @@
2841628379 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2841728380 if(!newstack)
2841828381 {
28419- label = 2322LLU; // throw: begin to unroll stack
28382+ label = 2318LLU; // throw: begin to unroll stack
2842028383 break;
2842128384 }
2842228385
@@ -28423,11 +28386,11 @@
2842328386 newstack[10LLU] = 9876543210LLU; // overflow-marker
2842428387 // call reporttype from initfrom
2842528388 newstack[0] = (uint64_t)stack; // backup stack location
28426- newstack[1] = 2333LLU;
28389+ newstack[1] = 2329LLU;
2842728390 newstack[2] = base;
28428- newstack[3] = 2334LLU;
28391+ newstack[3] = 2330LLU;
2842928392 // arguments for call to reporttype
28430- newstack[4LLU] = stack[base + 16]/*assigntype*/;
28393+ newstack[4LLU] = stack[base + 17]/*assigntype*/;
2843128394 stack = newstack;
2843228395 // set stack-base & callee-address
2843328396 base = 4/*deloffset*/;
@@ -28434,7 +28397,7 @@
2843428397 label = 316LLU; // reporttype
2843528398 break;
2843628399 }
28437- case 2333LLU: // copy-back deleter (reporttype to initfrom)
28400+ case 2329LLU: // copy-back deleter (reporttype to initfrom)
2843828401 {
2843928402 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2844028403 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28446,10 +28409,10 @@
2844628409 }
2844728410 Free(10LLU + 1, sizeof(uint64_t), stack);
2844828411 stack = oldstack;
28449- label = 2322LLU; // continue to unroll stack
28412+ label = 2318LLU; // continue to unroll stack
2845028413 break;
2845128414 }
28452- case 2334LLU: // return from reporttype to initfrom
28415+ case 2330LLU: // return from reporttype to initfrom
2845328416 {
2845428417 uint64_t *oldstack = (uint64_t *)stack[0];
2845528418 // copy mutable arguments back from call to reporttype
@@ -28462,18 +28425,18 @@
2846228425 stack = oldstack;
2846328426 fprintf(stderr, "%s", "\n");
2846428427 exit(-1);
28465- label = 2328LLU; // alternative complete
28428+ label = 2324LLU; // alternative complete
2846628429 break;
2846728430 }
28468- case 2328LLU: // completed if-then-else
28431+ case 2324LLU: // completed if-then-else
2846928432 {
2847028433
28471- uint64_t *newstack = (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4);
28434+ uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
2847228435 // call ~type from initfrom
2847328436 newstack[0] = (uint64_t)stack; // backup stack location
2847428437 newstack[1] = 1234567890;
2847528438 newstack[2] = base;
28476- newstack[3] = 2335LLU;
28439+ newstack[3] = 2331LLU;
2847728440 stack = newstack;
2847828441 // set stack-base & callee-address
2847928442 base = 4/*deloffset*/;
@@ -28480,330 +28443,330 @@
2848028443 label = 296LLU; // ~type
2848128444 break;
2848228445 }
28483- case 2335LLU: // return from ~type to initfrom
28446+ case 2331LLU: // return from ~type to initfrom
2848428447 {
2848528448 stack = (uint64_t *)stack[0];
2848628449 // releasing toplevel container
28487- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
28450+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2848828451
2848928452 // call matchsym from initfrom
28490- stack[base + 16LLU] = 2336LLU/*throw to this address*/;
28491- stack[base + 17LLU] = base;
28492- stack[base + 18LLU] = 2337LLU;
28453+ stack[base + 17LLU] = 2332LLU/*throw to this address*/;
28454+ stack[base + 18LLU] = base;
28455+ stack[base + 19LLU] = 2333LLU;
2849328456 // arguments for call to matchsym
28494- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
28495- stack[base + 20LLU] = 46LLU;
28496- stack[base + 21LLU] = stack[base + 6]/*lookahead*/;
28457+ stack[base + 20LLU] = stack[base + 0]/*fnid*/;
28458+ stack[base + 21LLU] = 46LLU;
28459+ stack[base + 22LLU] = stack[base + 7]/*lookahead*/;
2849728460 // set stack-base & callee-address
28498- base += 19LLU;
28461+ base += 20LLU;
2849928462 label = 212LLU; // matchsym
2850028463 break;
2850128464 }
28502- case 2336LLU: // copy-back deleter (matchsym to initfrom)
28465+ case 2332LLU: // copy-back deleter (matchsym to initfrom)
2850328466 {
2850428467 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2850528468 // copy mutable arguments back from call to matchsym
28506- stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28507- label = 2320LLU; // continue to roll stack
28469+ stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
28470+ label = 2316LLU; // continue to roll stack
2850828471 break;
2850928472 }
28510- case 2337LLU: // return from matchsym to initfrom
28473+ case 2333LLU: // return from matchsym to initfrom
2851128474 {
2851228475 // copy mutable arguments back from call to matchsym
28513- stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28476+ stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
2851428477 // call ParseToken from initfrom
28515- stack[base + 16LLU] = 2338LLU/*throw to this address*/;
28516- stack[base + 17LLU] = base;
28517- stack[base + 18LLU] = 2339LLU;
28478+ stack[base + 17LLU] = 2334LLU/*throw to this address*/;
28479+ stack[base + 18LLU] = base;
28480+ stack[base + 19LLU] = 2335LLU;
2851828481 // arguments for call to ParseToken
28519- stack[base + 21LLU] = stack[base + 6]/*lookahead*/;
28482+ stack[base + 22LLU] = stack[base + 7]/*lookahead*/;
2852028483 // set stack-base & callee-address
28521- base += 19LLU;
28484+ base += 20LLU;
2852228485 label = 3LLU; // ParseToken
2852328486 break;
2852428487 }
28525- case 2338LLU: // copy-back deleter (ParseToken to initfrom)
28488+ case 2334LLU: // copy-back deleter (ParseToken to initfrom)
2852628489 {
2852728490 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2852828491 // copy mutable arguments back from call to ParseToken
28529- stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28530- label = 2320LLU; // continue to roll stack
28492+ stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
28493+ label = 2316LLU; // continue to roll stack
2853128494 break;
2853228495 }
28533- case 2339LLU: // return from ParseToken to initfrom
28496+ case 2335LLU: // return from ParseToken to initfrom
2853428497 {
2853528498 // copy mutable arguments back from call to ParseToken
28536- stack[base + 6]/*lookahead*/ = stack[base + 21LLU];
28499+ stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
2853728500 // copy back results provided by call to ParseToken
28538- stack[base + 10] = stack[base + 19LLU];
28539- stack[base + 11] = stack[base + 20LLU];
28501+ stack[base + 12] = stack[base + 20LLU];
28502+ stack[base + 13] = stack[base + 21LLU];
2854028503 // call equ from initfrom
28541- stack[base + 16LLU] = 2340LLU/*throw to this address*/;
28542- stack[base + 17LLU] = base;
28543- stack[base + 18LLU] = 2341LLU;
28504+ stack[base + 17LLU] = 2336LLU/*throw to this address*/;
28505+ stack[base + 18LLU] = base;
28506+ stack[base + 19LLU] = 2337LLU;
2854428507 // arguments for call to equ
28545- stack[base + 20LLU] = stack[base + 10]/*variant*/;
28546- stack[base + 21LLU] = 4LLU;
28508+ stack[base + 21LLU] = stack[base + 12]/*variant*/;
28509+ stack[base + 22LLU] = 4LLU;
2854728510 // set stack-base & callee-address
28548- base += 19LLU;
28511+ base += 20LLU;
2854928512 label = 18446744073709551600LLU; // equ
2855028513 break;
2855128514 }
28552- case 2340LLU: // copy-back deleter (equ to initfrom)
28515+ case 2336LLU: // copy-back deleter (equ to initfrom)
2855328516 {
2855428517 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2855528518 // copy mutable arguments back from call to equ
28556- label = 2320LLU; // continue to roll stack
28519+ label = 2316LLU; // continue to roll stack
2855728520 break;
2855828521 }
28559- case 2341LLU: // return from equ to initfrom
28522+ case 2337LLU: // return from equ to initfrom
2856028523 {
2856128524 // copy mutable arguments back from call to equ
2856228525 // copy back results provided by call to equ
28563- stack[base + 9] = stack[base + 19LLU];
28564- if(!stack[base + 9]/*isequal*/)
28526+ stack[base + 10] = stack[base + 20LLU];
28527+ if(!stack[base + 10]/*isequal*/)
2856528528 {
28566- label = 2342LLU; // jump to alternative
28529+ label = 2338LLU; // jump to alternative
2856728530 break;
2856828531 }
2856928532
2857028533 // consequent
28571- label = 2343LLU; // consequent complete
28534+ label = 2339LLU; // consequent complete
2857228535 break;
2857328536 }
28574- case 2342LLU: // alternative
28537+ case 2338LLU: // alternative
2857528538 {
2857628539 fprintf(stderr, "%s", "construct requires constructor but found ");
2857728540 // call reporttok from initfrom
28578- stack[base + 16LLU] = 2344LLU/*throw to this address*/;
28579- stack[base + 17LLU] = base;
28580- stack[base + 18LLU] = 2345LLU;
28541+ stack[base + 17LLU] = 2340LLU/*throw to this address*/;
28542+ stack[base + 18LLU] = base;
28543+ stack[base + 19LLU] = 2341LLU;
2858128544 // arguments for call to reporttok
28582- stack[base + 19LLU] = stack[base + 10]/*variant*/;
28583- stack[base + 20LLU] = stack[base + 11]/*content*/;
28545+ stack[base + 20LLU] = stack[base + 12]/*variant*/;
28546+ stack[base + 21LLU] = stack[base + 13]/*content*/;
2858428547 // set stack-base & callee-address
28585- base += 19LLU;
28548+ base += 20LLU;
2858628549 label = 18446744073709551582LLU; // reporttok
2858728550 break;
2858828551 }
28589- case 2344LLU: // copy-back deleter (reporttok to initfrom)
28552+ case 2340LLU: // copy-back deleter (reporttok to initfrom)
2859028553 {
2859128554 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2859228555 // copy mutable arguments back from call to reporttok
28593- label = 2320LLU; // continue to roll stack
28556+ label = 2316LLU; // continue to roll stack
2859428557 break;
2859528558 }
28596- case 2345LLU: // return from reporttok to initfrom
28559+ case 2341LLU: // return from reporttok to initfrom
2859728560 {
2859828561 // copy mutable arguments back from call to reporttok
2859928562 fprintf(stderr, "%s", "\n");
2860028563 exit(-1);
28601- label = 2343LLU; // alternative complete
28564+ label = 2339LLU; // alternative complete
2860228565 break;
2860328566 }
28604- case 2343LLU: // completed if-then-else
28567+ case 2339LLU: // completed if-then-else
2860528568 {
28606- if(!stack[base + 8]/*fncanthrow*/)
28569+ if(!stack[base + 9]/*fncanthrow*/)
2860728570 {
28608- label = 2346LLU; // jump to alternative
28571+ label = 2342LLU; // jump to alternative
2860928572 break;
2861028573 }
2861128574
2861228575 // consequent
28613- label = 2347LLU; // consequent complete
28576+ label = 2343LLU; // consequent complete
2861428577 break;
2861528578 }
28616- case 2346LLU: // alternative
28579+ case 2342LLU: // alternative
2861728580 {
2861828581 fprintf(stderr, "%s", "in function ");
2861928582 // call reportid from initfrom
28620- stack[base + 16LLU] = 2348LLU/*throw to this address*/;
28621- stack[base + 17LLU] = base;
28622- stack[base + 18LLU] = 2349LLU;
28583+ stack[base + 17LLU] = 2344LLU/*throw to this address*/;
28584+ stack[base + 18LLU] = base;
28585+ stack[base + 19LLU] = 2345LLU;
2862328586 // arguments for call to reportid
28624- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
28587+ stack[base + 20LLU] = stack[base + 0]/*fnid*/;
2862528588 // set stack-base & callee-address
28626- base += 19LLU;
28589+ base += 20LLU;
2862728590 label = 18446744073709551586LLU; // reportid
2862828591 break;
2862928592 }
28630- case 2348LLU: // copy-back deleter (reportid to initfrom)
28593+ case 2344LLU: // copy-back deleter (reportid to initfrom)
2863128594 {
2863228595 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2863328596 // copy mutable arguments back from call to reportid
28634- label = 2320LLU; // continue to roll stack
28597+ label = 2316LLU; // continue to roll stack
2863528598 break;
2863628599 }
28637- case 2349LLU: // return from reportid to initfrom
28600+ case 2345LLU: // return from reportid to initfrom
2863828601 {
2863928602 // copy mutable arguments back from call to reportid
2864028603 fprintf(stderr, "%s", ": construction of data ");
2864128604 // call reportid from initfrom
28642- stack[base + 16LLU] = 2350LLU/*throw to this address*/;
28643- stack[base + 17LLU] = base;
28644- stack[base + 18LLU] = 2351LLU;
28605+ stack[base + 17LLU] = 2346LLU/*throw to this address*/;
28606+ stack[base + 18LLU] = base;
28607+ stack[base + 19LLU] = 2347LLU;
2864528608 // arguments for call to reportid
28646- stack[base + 19LLU] = stack[base + 15]/*typename*/;
28609+ stack[base + 20LLU] = stack[base + 16]/*typename*/;
2864728610 // set stack-base & callee-address
28648- base += 19LLU;
28611+ base += 20LLU;
2864928612 label = 18446744073709551586LLU; // reportid
2865028613 break;
2865128614 }
28652- case 2350LLU: // copy-back deleter (reportid to initfrom)
28615+ case 2346LLU: // copy-back deleter (reportid to initfrom)
2865328616 {
2865428617 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2865528618 // copy mutable arguments back from call to reportid
28656- label = 2320LLU; // continue to roll stack
28619+ label = 2316LLU; // continue to roll stack
2865728620 break;
2865828621 }
28659- case 2351LLU: // return from reportid to initfrom
28622+ case 2347LLU: // return from reportid to initfrom
2866028623 {
2866128624 // copy mutable arguments back from call to reportid
2866228625 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2866328626 exit(-1);
28664- label = 2347LLU; // alternative complete
28627+ label = 2343LLU; // alternative complete
2866528628 break;
2866628629 }
28667- case 2347LLU: // completed if-then-else
28630+ case 2343LLU: // completed if-then-else
2866828631 {
2866928632 printf("%s", "\n // construct ");
2867028633 // call printid from initfrom
28671- stack[base + 16LLU] = 2352LLU/*throw to this address*/;
28672- stack[base + 17LLU] = base;
28673- stack[base + 18LLU] = 2353LLU;
28634+ stack[base + 17LLU] = 2348LLU/*throw to this address*/;
28635+ stack[base + 18LLU] = base;
28636+ stack[base + 19LLU] = 2349LLU;
2867428637 // arguments for call to printid
28675- stack[base + 19LLU] = stack[base + 15]/*typename*/;
28638+ stack[base + 20LLU] = stack[base + 16]/*typename*/;
2867628639 // set stack-base & callee-address
28677- base += 19LLU;
28640+ base += 20LLU;
2867828641 label = 18446744073709551587LLU; // printid
2867928642 break;
2868028643 }
28681- case 2352LLU: // copy-back deleter (printid to initfrom)
28644+ case 2348LLU: // copy-back deleter (printid to initfrom)
2868228645 {
2868328646 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2868428647 // copy mutable arguments back from call to printid
28685- label = 2320LLU; // continue to roll stack
28648+ label = 2316LLU; // continue to roll stack
2868628649 break;
2868728650 }
28688- case 2353LLU: // return from printid to initfrom
28651+ case 2349LLU: // return from printid to initfrom
2868928652 {
2869028653 // copy mutable arguments back from call to printid
2869128654 printf("%s", ".");
2869228655 // call printid from initfrom
28693- stack[base + 16LLU] = 2354LLU/*throw to this address*/;
28694- stack[base + 17LLU] = base;
28695- stack[base + 18LLU] = 2355LLU;
28656+ stack[base + 17LLU] = 2350LLU/*throw to this address*/;
28657+ stack[base + 18LLU] = base;
28658+ stack[base + 19LLU] = 2351LLU;
2869628659 // arguments for call to printid
28697- stack[base + 19LLU] = stack[base + 11]/*content*/;
28660+ stack[base + 20LLU] = stack[base + 13]/*content*/;
2869828661 // set stack-base & callee-address
28699- base += 19LLU;
28662+ base += 20LLU;
2870028663 label = 18446744073709551587LLU; // printid
2870128664 break;
2870228665 }
28703- case 2354LLU: // copy-back deleter (printid to initfrom)
28666+ case 2350LLU: // copy-back deleter (printid to initfrom)
2870428667 {
2870528668 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2870628669 // copy mutable arguments back from call to printid
28707- label = 2320LLU; // continue to roll stack
28670+ label = 2316LLU; // continue to roll stack
2870828671 break;
2870928672 }
28710- case 2355LLU: // return from printid to initfrom
28673+ case 2351LLU: // return from printid to initfrom
2871128674 {
2871228675 // copy mutable arguments back from call to printid
2871328676 // call FindData from initfrom
28714- stack[base + 17LLU] = 2356LLU/*throw to this address*/;
28715- stack[base + 18LLU] = base;
28716- stack[base + 19LLU] = 2357LLU;
28677+ stack[base + 18LLU] = 2352LLU/*throw to this address*/;
28678+ stack[base + 19LLU] = base;
28679+ stack[base + 20LLU] = 2353LLU;
2871728680 // arguments for call to FindData
28718- stack[base + 21LLU] = stack[base + 3]/*typedefs*/;
28719- stack[base + 22LLU] = stack[base + 15]/*typename*/;
28681+ stack[base + 22LLU] = stack[base + 4]/*typedefs*/;
28682+ stack[base + 23LLU] = stack[base + 16]/*typename*/;
2872028683 // set stack-base & callee-address
28721- base += 20LLU;
28684+ base += 21LLU;
2872228685 label = 1004LLU; // FindData
2872328686 break;
2872428687 }
28725- case 2356LLU: // copy-back deleter (FindData to initfrom)
28688+ case 2352LLU: // copy-back deleter (FindData to initfrom)
2872628689 {
2872728690 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
2872828691 // copy mutable arguments back from call to FindData
28729- label = 2320LLU; // continue to roll stack
28692+ label = 2316LLU; // continue to roll stack
2873028693 break;
2873128694 }
28732- case 2357LLU: // return from FindData to initfrom
28695+ case 2353LLU: // return from FindData to initfrom
2873328696 {
2873428697 // copy mutable arguments back from call to FindData
2873528698 // copy back results provided by call to FindData
28736- stack[base + 16] = stack[base + 20LLU];
28737- if(/*datadef*/0 != ((uint64_t *)(stack[base + 16]/*reftypedef*/))[0])
28699+ stack[base + 17] = stack[base + 21LLU];
28700+ if(/*datadef*/0 != ((uint64_t *)(stack[base + 17]/*reftypedef*/))[0])
2873828701 {
28739- label = 2359LLU; // jump to alternative
28702+ label = 2355LLU; // jump to alternative
2874028703 break;
2874128704 }
2874228705
28743- /*dummyid*/stack[base + 17] = ((uint64_t **)(stack[base + 16]/*reftypedef*/))[1][0]/*id*/;
28744- /*variants*/stack[base + 18] = ((uint64_t **)(stack[base + 16]/*reftypedef*/))[1][1]/*variants*/;
28745- /*destrlabel*/stack[base + 19] = ((uint64_t **)(stack[base + 16]/*reftypedef*/))[1][2]/*destrlabel*/;
28706+ /*dummyid*/stack[base + 18] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][0]/*id*/;
28707+ /*variants*/stack[base + 19] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][1]/*variants*/;
28708+ /*destrlabel*/stack[base + 20] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][2]/*destrlabel*/;
2874628709
2874728710 // case
2874828711 // call GetVariant from initfrom
28749- stack[base + 22LLU] = 2361LLU/*throw to this address*/;
28750- stack[base + 23LLU] = base;
28751- stack[base + 24LLU] = 2362LLU;
28712+ stack[base + 23LLU] = 2357LLU/*throw to this address*/;
28713+ stack[base + 24LLU] = base;
28714+ stack[base + 25LLU] = 2358LLU;
2875228715 // arguments for call to GetVariant
28753- stack[base + 27LLU] = stack[base + 0]/*fnid*/;
28754- stack[base + 28LLU] = stack[base + 18]/*variants*/;
28755- stack[base + 29LLU] = stack[base + 11]/*content*/;
28716+ stack[base + 28LLU] = stack[base + 0]/*fnid*/;
28717+ stack[base + 29LLU] = stack[base + 19]/*variants*/;
28718+ stack[base + 30LLU] = stack[base + 13]/*content*/;
2875628719 // set stack-base & callee-address
28757- base += 25LLU;
28720+ base += 26LLU;
2875828721 label = 907LLU; // GetVariant
2875928722 break;
2876028723 }
28761- case 2361LLU: // copy-back deleter (GetVariant to initfrom)
28724+ case 2357LLU: // copy-back deleter (GetVariant to initfrom)
2876228725 {
2876328726 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
2876428727 // copy mutable arguments back from call to GetVariant
28765- label = 2360LLU; // continue to roll stack
28728+ label = 2356LLU; // continue to roll stack
2876628729 break;
2876728730 }
28768- case 2362LLU: // return from GetVariant to initfrom
28731+ case 2358LLU: // return from GetVariant to initfrom
2876928732 {
2877028733 // copy mutable arguments back from call to GetVariant
2877128734 // copy back results provided by call to GetVariant
28772- stack[base + 20] = stack[base + 25LLU];
2877328735 stack[base + 21] = stack[base + 26LLU];
28774- if(/*variant*/0 != ((uint64_t *)(stack[base + 21]/*constr*/))[0])
28736+ stack[base + 22] = stack[base + 27LLU];
28737+ if(/*variant*/0 != ((uint64_t *)(stack[base + 22]/*constr*/))[0])
2877528738 {
28776- label = 2364LLU; // jump to alternative
28739+ label = 2360LLU; // jump to alternative
2877728740 break;
2877828741 }
2877928742
28780- /*dummy*/stack[base + 22] = ((uint64_t **)(stack[base + 21]/*constr*/))[1][0]/*id*/;
28781- /*TYPEIDS*/stack[base + 23] = ((uint64_t **)(stack[base + 21]/*constr*/))[1][1]/*elements*/;
28743+ /*dummy*/stack[base + 23] = ((uint64_t **)(stack[base + 22]/*constr*/))[1][0]/*id*/;
28744+ /*TYPEIDS*/stack[base + 24] = ((uint64_t **)(stack[base + 22]/*constr*/))[1][1]/*elements*/;
2878228745
2878328746 // case
28784- label = 2367LLU; // skip deleter
28747+ label = 2363LLU; // skip deleter
2878528748 break;
2878628749 }
28787- case 2366LLU: // deleter
28750+ case 2362LLU: // deleter
2878828751 {
2878928752 // throw from initfrom
28790- if(!stack[base + 24])
28753+ if(!stack[base + 25])
2879128754 {
28792- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28793- label = 2365LLU; // skip, variable already deleted/unscoped
28755+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
28756+ label = 2361LLU; // skip, variable already deleted/unscoped
2879428757 break;
2879528758 }
28796- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28797- label = 2365LLU; // continue unrolling stack, delete next variable
28759+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
28760+ label = 2361LLU; // continue unrolling stack, delete next variable
2879828761 break;
2879928762 }
28800- case 2367LLU: // skipped deleter
28763+ case 2363LLU: // skipped deleter
2880128764 {
28802- stack[base + 24] = 0;
28803- stack[base + 24]/*size*/ = list_size(((struct listnode *)(stack[base + 23]/*TYPEIDS*/)));
28804- if(!stack[base + 13]/*forceerror*/)
28765+ stack[base + 25] = 0;
28766+ stack[base + 25]/*size*/ = list_size(((struct listnode *)(stack[base + 24]/*TYPEIDS*/)));
28767+ if(!stack[base + 14]/*forceerror*/)
2880528768 {
28806- label = 2368LLU; // jump to alternative
28769+ label = 2364LLU; // jump to alternative
2880728770 break;
2880828771 }
2880928772
@@ -28810,405 +28773,405 @@
2881028773 // consequent
2881128774 printf("%s", "\n // if(!(");
2881228775 // call emitvaridx from initfrom
28813- stack[base + 25LLU] = 2370LLU/*throw to this address*/;
28814- stack[base + 26LLU] = base;
28815- stack[base + 27LLU] = 2371LLU;
28776+ stack[base + 26LLU] = 2366LLU/*throw to this address*/;
28777+ stack[base + 27LLU] = base;
28778+ stack[base + 28LLU] = 2367LLU;
2881628779 // arguments for call to emitvaridx
28817- stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
28780+ stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2881828781 // set stack-base & callee-address
28819- base += 28LLU;
28782+ base += 29LLU;
2882028783 label = 691LLU; // emitvaridx
2882128784 break;
2882228785 }
28823- case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
28786+ case 2366LLU: // copy-back deleter (emitvaridx to initfrom)
2882428787 {
2882528788 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2882628789 // copy mutable arguments back from call to emitvaridx
28827- label = 2366LLU; // continue to roll stack
28790+ label = 2362LLU; // continue to roll stack
2882828791 break;
2882928792 }
28830- case 2371LLU: // return from emitvaridx to initfrom
28793+ case 2367LLU: // return from emitvaridx to initfrom
2883128794 {
2883228795 // copy mutable arguments back from call to emitvaridx
2883328796 printf("%s", " = construct(");
2883428797 // call printnr from initfrom
28835- stack[base + 25LLU] = 2372LLU/*throw to this address*/;
28836- stack[base + 26LLU] = base;
28837- stack[base + 27LLU] = 2373LLU;
28798+ stack[base + 26LLU] = 2368LLU/*throw to this address*/;
28799+ stack[base + 27LLU] = base;
28800+ stack[base + 28LLU] = 2369LLU;
2883828801 // arguments for call to printnr
28839- stack[base + 28LLU] = stack[base + 24]/*size*/;
28802+ stack[base + 29LLU] = stack[base + 25]/*size*/;
2884028803 // set stack-base & callee-address
28841- base += 28LLU;
28804+ base += 29LLU;
2884228805 label = 18446744073709551590LLU; // printnr
2884328806 break;
2884428807 }
28845- case 2372LLU: // copy-back deleter (printnr to initfrom)
28808+ case 2368LLU: // copy-back deleter (printnr to initfrom)
2884628809 {
2884728810 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2884828811 // copy mutable arguments back from call to printnr
28849- label = 2366LLU; // continue to roll stack
28812+ label = 2362LLU; // continue to roll stack
2885028813 break;
2885128814 }
28852- case 2373LLU: // return from printnr to initfrom
28815+ case 2369LLU: // return from printnr to initfrom
2885328816 {
2885428817 // copy mutable arguments back from call to printnr
2885528818 printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
28856- label = 2369LLU; // consequent complete
28819+ label = 2365LLU; // consequent complete
2885728820 break;
2885828821 }
28859- case 2368LLU: // alternative
28822+ case 2364LLU: // alternative
2886028823 {
2886128824 printf("%s", "\n if(!(");
2886228825 // call emitvaridx from initfrom
28863- stack[base + 25LLU] = 2374LLU/*throw to this address*/;
28864- stack[base + 26LLU] = base;
28865- stack[base + 27LLU] = 2375LLU;
28826+ stack[base + 26LLU] = 2370LLU/*throw to this address*/;
28827+ stack[base + 27LLU] = base;
28828+ stack[base + 28LLU] = 2371LLU;
2886628829 // arguments for call to emitvaridx
28867- stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
28830+ stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2886828831 // set stack-base & callee-address
28869- base += 28LLU;
28832+ base += 29LLU;
2887028833 label = 691LLU; // emitvaridx
2887128834 break;
2887228835 }
28873- case 2374LLU: // copy-back deleter (emitvaridx to initfrom)
28836+ case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
2887428837 {
2887528838 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2887628839 // copy mutable arguments back from call to emitvaridx
28877- label = 2366LLU; // continue to roll stack
28840+ label = 2362LLU; // continue to roll stack
2887828841 break;
2887928842 }
28880- case 2375LLU: // return from emitvaridx to initfrom
28843+ case 2371LLU: // return from emitvaridx to initfrom
2888128844 {
2888228845 // copy mutable arguments back from call to emitvaridx
2888328846 printf("%s", " = construct(");
2888428847 // call printnr from initfrom
28885- stack[base + 25LLU] = 2376LLU/*throw to this address*/;
28886- stack[base + 26LLU] = base;
28887- stack[base + 27LLU] = 2377LLU;
28848+ stack[base + 26LLU] = 2372LLU/*throw to this address*/;
28849+ stack[base + 27LLU] = base;
28850+ stack[base + 28LLU] = 2373LLU;
2888828851 // arguments for call to printnr
28889- stack[base + 28LLU] = stack[base + 24]/*size*/;
28852+ stack[base + 29LLU] = stack[base + 25]/*size*/;
2889028853 // set stack-base & callee-address
28891- base += 28LLU;
28854+ base += 29LLU;
2889228855 label = 18446744073709551590LLU; // printnr
2889328856 break;
2889428857 }
28895- case 2376LLU: // copy-back deleter (printnr to initfrom)
28858+ case 2372LLU: // copy-back deleter (printnr to initfrom)
2889628859 {
2889728860 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2889828861 // copy mutable arguments back from call to printnr
28899- label = 2366LLU; // continue to roll stack
28862+ label = 2362LLU; // continue to roll stack
2890028863 break;
2890128864 }
28902- case 2377LLU: // return from printnr to initfrom
28865+ case 2373LLU: // return from printnr to initfrom
2890328866 {
2890428867 // copy mutable arguments back from call to printnr
2890528868 printf("%s", ")))");
28906- label = 2369LLU; // alternative complete
28869+ label = 2365LLU; // alternative complete
2890728870 break;
2890828871 }
28909- case 2369LLU: // completed if-then-else
28872+ case 2365LLU: // completed if-then-else
2891028873 {
2891128874 // call emitthrow from initfrom
28912- stack[base + 25LLU] = 2378LLU/*throw to this address*/;
28913- stack[base + 26LLU] = base;
28914- stack[base + 27LLU] = 2379LLU;
28875+ stack[base + 26LLU] = 2374LLU/*throw to this address*/;
28876+ stack[base + 27LLU] = base;
28877+ stack[base + 28LLU] = 2375LLU;
2891528878 // arguments for call to emitthrow
28916- stack[base + 28LLU] = stack[base + 5]/*scope*/;
28879+ stack[base + 29LLU] = stack[base + 6]/*scope*/;
2891728880 // set stack-base & callee-address
28918- base += 28LLU;
28881+ base += 29LLU;
2891928882 label = 1559LLU; // emitthrow
2892028883 break;
2892128884 }
28922- case 2378LLU: // copy-back deleter (emitthrow to initfrom)
28885+ case 2374LLU: // copy-back deleter (emitthrow to initfrom)
2892328886 {
2892428887 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
2892528888 // copy mutable arguments back from call to emitthrow
28926- label = 2366LLU; // continue to roll stack
28889+ label = 2362LLU; // continue to roll stack
2892728890 break;
2892828891 }
28929- case 2379LLU: // return from emitthrow to initfrom
28892+ case 2375LLU: // return from emitthrow to initfrom
2893028893 {
2893128894 // copy mutable arguments back from call to emitthrow
2893228895 printf("%s", "\n // consequent");
2893328896 printf("%s", "\n ((uint64_t *)");
2893428897 // call emitvaridx from initfrom
28935- stack[base + 25LLU] = 2380LLU/*throw to this address*/;
28936- stack[base + 26LLU] = base;
28937- stack[base + 27LLU] = 2381LLU;
28898+ stack[base + 26LLU] = 2376LLU/*throw to this address*/;
28899+ stack[base + 27LLU] = base;
28900+ stack[base + 28LLU] = 2377LLU;
2893828901 // arguments for call to emitvaridx
28939- stack[base + 28LLU] = stack[base + 2]/*dstindex*/;
28902+ stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2894028903 // set stack-base & callee-address
28941- base += 28LLU;
28904+ base += 29LLU;
2894228905 label = 691LLU; // emitvaridx
2894328906 break;
2894428907 }
28945- case 2380LLU: // copy-back deleter (emitvaridx to initfrom)
28908+ case 2376LLU: // copy-back deleter (emitvaridx to initfrom)
2894628909 {
2894728910 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2894828911 // copy mutable arguments back from call to emitvaridx
28949- label = 2366LLU; // continue to roll stack
28912+ label = 2362LLU; // continue to roll stack
2895028913 break;
2895128914 }
28952- case 2381LLU: // return from emitvaridx to initfrom
28915+ case 2377LLU: // return from emitvaridx to initfrom
2895328916 {
2895428917 // copy mutable arguments back from call to emitvaridx
2895528918 printf("%s", ")[0] = ");
2895628919 // call printnr from initfrom
28957- stack[base + 25LLU] = 2382LLU/*throw to this address*/;
28958- stack[base + 26LLU] = base;
28959- stack[base + 27LLU] = 2383LLU;
28920+ stack[base + 26LLU] = 2378LLU/*throw to this address*/;
28921+ stack[base + 27LLU] = base;
28922+ stack[base + 28LLU] = 2379LLU;
2896028923 // arguments for call to printnr
28961- stack[base + 28LLU] = stack[base + 20]/*varnr*/;
28924+ stack[base + 29LLU] = stack[base + 21]/*varnr*/;
2896228925 // set stack-base & callee-address
28963- base += 28LLU;
28926+ base += 29LLU;
2896428927 label = 18446744073709551590LLU; // printnr
2896528928 break;
2896628929 }
28967- case 2382LLU: // copy-back deleter (printnr to initfrom)
28930+ case 2378LLU: // copy-back deleter (printnr to initfrom)
2896828931 {
2896928932 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2897028933 // copy mutable arguments back from call to printnr
28971- label = 2366LLU; // continue to roll stack
28934+ label = 2362LLU; // continue to roll stack
2897228935 break;
2897328936 }
28974- case 2383LLU: // return from printnr to initfrom
28937+ case 2379LLU: // return from printnr to initfrom
2897528938 {
2897628939 // copy mutable arguments back from call to printnr
2897728940 printf("%s", ";");
2897828941 // call matchsym from initfrom
28979- stack[base + 25LLU] = 2384LLU/*throw to this address*/;
28980- stack[base + 26LLU] = base;
28981- stack[base + 27LLU] = 2385LLU;
28942+ stack[base + 26LLU] = 2380LLU/*throw to this address*/;
28943+ stack[base + 27LLU] = base;
28944+ stack[base + 28LLU] = 2381LLU;
2898228945 // arguments for call to matchsym
28983- stack[base + 28LLU] = stack[base + 0]/*fnid*/;
28984- stack[base + 29LLU] = 40LLU;
28985- stack[base + 30LLU] = stack[base + 6]/*lookahead*/;
28946+ stack[base + 29LLU] = stack[base + 0]/*fnid*/;
28947+ stack[base + 30LLU] = 40LLU;
28948+ stack[base + 31LLU] = stack[base + 7]/*lookahead*/;
2898628949 // set stack-base & callee-address
28987- base += 28LLU;
28950+ base += 29LLU;
2898828951 label = 212LLU; // matchsym
2898928952 break;
2899028953 }
28991- case 2384LLU: // copy-back deleter (matchsym to initfrom)
28954+ case 2380LLU: // copy-back deleter (matchsym to initfrom)
2899228955 {
2899328956 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2899428957 // copy mutable arguments back from call to matchsym
28995- stack[base + 6]/*lookahead*/ = stack[base + 30LLU];
28996- label = 2366LLU; // continue to roll stack
28958+ stack[base + 7]/*lookahead*/ = stack[base + 31LLU];
28959+ label = 2362LLU; // continue to roll stack
2899728960 break;
2899828961 }
28999- case 2385LLU: // return from matchsym to initfrom
28962+ case 2381LLU: // return from matchsym to initfrom
2900028963 {
2900128964 // copy mutable arguments back from call to matchsym
29002- stack[base + 6]/*lookahead*/ = stack[base + 30LLU];
29003- label = 2387LLU; // skip deleter
28965+ stack[base + 7]/*lookahead*/ = stack[base + 31LLU];
28966+ label = 2383LLU; // skip deleter
2900428967 break;
2900528968 }
29006- case 2386LLU: // deleter
28969+ case 2382LLU: // deleter
2900728970 {
2900828971 // throw from initfrom
29009- if(!stack[base + 25])
28972+ if(!stack[base + 26])
2901028973 {
29011- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
29012- label = 2366LLU; // skip, variable already deleted/unscoped
28974+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
28975+ label = 2362LLU; // skip, variable already deleted/unscoped
2901328976 break;
2901428977 }
29015- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
29016- label = 2366LLU; // continue unrolling stack, delete next variable
28978+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
28979+ label = 2362LLU; // continue unrolling stack, delete next variable
2901728980 break;
2901828981 }
29019- case 2387LLU: // skipped deleter
28982+ case 2383LLU: // skipped deleter
2902028983 {
29021- stack[base + 25] = 0;
29022- flippedassign(stack[base + 23]/*TYPEIDS*/, &stack[base + 26]);
29023- label = 2388LLU; // start to repeat
28984+ stack[base + 26] = 0;
28985+ flippedassign(stack[base + 24]/*TYPEIDS*/, &stack[base + 27]);
28986+ label = 2384LLU; // start to repeat
2902428987 break;
2902528988 }
29026- case 2388LLU: // repeat from here
28989+ case 2384LLU: // repeat from here
2902728990 {
29028- if(!stack[base + 26])
28991+ if(!stack[base + 27])
2902928992 {
29030- label = 2389LLU; // break loop
28993+ label = 2385LLU; // break loop
2903128994 break;
2903228995 }
2903328996
2903428997 // loop body
29035- stack[base + 27] = (uint64_t)(((const struct listnode *)(stack[base + 26]))->data);
29036- stack[base + 28]/*previous*/ = stack[base + 26];
29037- stack[base + 26] = (uint64_t)(((const struct listnode *)(stack[base + 26]))->next);
29038- if(/*typeid*/0 != ((uint64_t *)(stack[base + 27]/*typeid*/))[0])
28998+ stack[base + 28] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->data);
28999+ stack[base + 29]/*previous*/ = stack[base + 27];
29000+ stack[base + 27] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->next);
29001+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 28]/*typeid*/))[0])
2903929002 {
29040- label = 2392LLU; // jump to alternative
29003+ label = 2388LLU; // jump to alternative
2904129004 break;
2904229005 }
2904329006
29044- /*dsttype*/stack[base + 29] = ((uint64_t **)(stack[base + 27]/*typeid*/))[1][0]/*type*/;
29045- /*elemid*/stack[base + 30] = ((uint64_t **)(stack[base + 27]/*typeid*/))[1][1]/*id*/;
29007+ /*dsttype*/stack[base + 30] = ((uint64_t **)(stack[base + 28]/*typeid*/))[1][0]/*type*/;
29008+ /*elemid*/stack[base + 31] = ((uint64_t **)(stack[base + 28]/*typeid*/))[1][1]/*id*/;
2904629009
2904729010 // case
29048- if(!stack[base + 25]/*elemindex*/)
29011+ if(!stack[base + 26]/*elemindex*/)
2904929012 {
29050- label = 2394LLU; // jump to alternative
29013+ label = 2390LLU; // jump to alternative
2905129014 break;
2905229015 }
2905329016
2905429017 // consequent
2905529018 // call matchsym from initfrom
29056- stack[base + 31LLU] = 2396LLU/*throw to this address*/;
29057- stack[base + 32LLU] = base;
29058- stack[base + 33LLU] = 2397LLU;
29019+ stack[base + 32LLU] = 2392LLU/*throw to this address*/;
29020+ stack[base + 33LLU] = base;
29021+ stack[base + 34LLU] = 2393LLU;
2905929022 // arguments for call to matchsym
29060- stack[base + 34LLU] = stack[base + 0]/*fnid*/;
29061- stack[base + 35LLU] = 44LLU;
29062- stack[base + 36LLU] = stack[base + 6]/*lookahead*/;
29023+ stack[base + 35LLU] = stack[base + 0]/*fnid*/;
29024+ stack[base + 36LLU] = 44LLU;
29025+ stack[base + 37LLU] = stack[base + 7]/*lookahead*/;
2906329026 // set stack-base & callee-address
29064- base += 34LLU;
29027+ base += 35LLU;
2906529028 label = 212LLU; // matchsym
2906629029 break;
2906729030 }
29068- case 2396LLU: // copy-back deleter (matchsym to initfrom)
29031+ case 2392LLU: // copy-back deleter (matchsym to initfrom)
2906929032 {
2907029033 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2907129034 // copy mutable arguments back from call to matchsym
29072- stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29073- label = 2393LLU; // continue to roll stack
29035+ stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29036+ label = 2389LLU; // continue to roll stack
2907429037 break;
2907529038 }
29076- case 2397LLU: // return from matchsym to initfrom
29039+ case 2393LLU: // return from matchsym to initfrom
2907729040 {
2907829041 // copy mutable arguments back from call to matchsym
29079- stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29080- label = 2395LLU; // consequent complete
29042+ stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29043+ label = 2391LLU; // consequent complete
2908129044 break;
2908229045 }
29083- case 2394LLU: // alternative
29046+ case 2390LLU: // alternative
2908429047 {
29085- label = 2395LLU; // alternative complete
29048+ label = 2391LLU; // alternative complete
2908629049 break;
2908729050 }
29088- case 2395LLU: // completed if-then-else
29051+ case 2391LLU: // completed if-then-else
2908929052 {
2909029053 // call ParseToken from initfrom
29091- stack[base + 31LLU] = 2398LLU/*throw to this address*/;
29092- stack[base + 32LLU] = base;
29093- stack[base + 33LLU] = 2399LLU;
29054+ stack[base + 32LLU] = 2394LLU/*throw to this address*/;
29055+ stack[base + 33LLU] = base;
29056+ stack[base + 34LLU] = 2395LLU;
2909429057 // arguments for call to ParseToken
29095- stack[base + 36LLU] = stack[base + 6]/*lookahead*/;
29058+ stack[base + 37LLU] = stack[base + 7]/*lookahead*/;
2909629059 // set stack-base & callee-address
29097- base += 34LLU;
29060+ base += 35LLU;
2909829061 label = 3LLU; // ParseToken
2909929062 break;
2910029063 }
29101- case 2398LLU: // copy-back deleter (ParseToken to initfrom)
29064+ case 2394LLU: // copy-back deleter (ParseToken to initfrom)
2910229065 {
2910329066 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2910429067 // copy mutable arguments back from call to ParseToken
29105- stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29106- label = 2393LLU; // continue to roll stack
29068+ stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29069+ label = 2389LLU; // continue to roll stack
2910729070 break;
2910829071 }
29109- case 2399LLU: // return from ParseToken to initfrom
29072+ case 2395LLU: // return from ParseToken to initfrom
2911029073 {
2911129074 // copy mutable arguments back from call to ParseToken
29112- stack[base + 6]/*lookahead*/ = stack[base + 36LLU];
29075+ stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
2911329076 // copy back results provided by call to ParseToken
29114- stack[base + 10] = stack[base + 34LLU];
29115- stack[base + 11] = stack[base + 35LLU];
29077+ stack[base + 12] = stack[base + 35LLU];
29078+ stack[base + 13] = stack[base + 36LLU];
2911629079 // call equ from initfrom
29117- stack[base + 31LLU] = 2400LLU/*throw to this address*/;
29118- stack[base + 32LLU] = base;
29119- stack[base + 33LLU] = 2401LLU;
29080+ stack[base + 32LLU] = 2396LLU/*throw to this address*/;
29081+ stack[base + 33LLU] = base;
29082+ stack[base + 34LLU] = 2397LLU;
2912029083 // arguments for call to equ
29121- stack[base + 35LLU] = stack[base + 10]/*variant*/;
29122- stack[base + 36LLU] = 4LLU;
29084+ stack[base + 36LLU] = stack[base + 12]/*variant*/;
29085+ stack[base + 37LLU] = 4LLU;
2912329086 // set stack-base & callee-address
29124- base += 34LLU;
29087+ base += 35LLU;
2912529088 label = 18446744073709551600LLU; // equ
2912629089 break;
2912729090 }
29128- case 2400LLU: // copy-back deleter (equ to initfrom)
29091+ case 2396LLU: // copy-back deleter (equ to initfrom)
2912929092 {
2913029093 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2913129094 // copy mutable arguments back from call to equ
29132- label = 2393LLU; // continue to roll stack
29095+ label = 2389LLU; // continue to roll stack
2913329096 break;
2913429097 }
29135- case 2401LLU: // return from equ to initfrom
29098+ case 2397LLU: // return from equ to initfrom
2913629099 {
2913729100 // copy mutable arguments back from call to equ
2913829101 // copy back results provided by call to equ
29139- stack[base + 9] = stack[base + 34LLU];
29140- if(!stack[base + 9]/*isequal*/)
29102+ stack[base + 10] = stack[base + 35LLU];
29103+ if(!stack[base + 10]/*isequal*/)
2914129104 {
29142- label = 2402LLU; // jump to alternative
29105+ label = 2398LLU; // jump to alternative
2914329106 break;
2914429107 }
2914529108
2914629109 // consequent
29147- label = 2403LLU; // consequent complete
29110+ label = 2399LLU; // consequent complete
2914829111 break;
2914929112 }
29150- case 2402LLU: // alternative
29113+ case 2398LLU: // alternative
2915129114 {
2915229115 fprintf(stderr, "%s", "constructor requires variables but found ");
2915329116 // call reporttok from initfrom
29154- stack[base + 31LLU] = 2404LLU/*throw to this address*/;
29155- stack[base + 32LLU] = base;
29156- stack[base + 33LLU] = 2405LLU;
29117+ stack[base + 32LLU] = 2400LLU/*throw to this address*/;
29118+ stack[base + 33LLU] = base;
29119+ stack[base + 34LLU] = 2401LLU;
2915729120 // arguments for call to reporttok
29158- stack[base + 34LLU] = stack[base + 10]/*variant*/;
29159- stack[base + 35LLU] = stack[base + 11]/*content*/;
29121+ stack[base + 35LLU] = stack[base + 12]/*variant*/;
29122+ stack[base + 36LLU] = stack[base + 13]/*content*/;
2916029123 // set stack-base & callee-address
29161- base += 34LLU;
29124+ base += 35LLU;
2916229125 label = 18446744073709551582LLU; // reporttok
2916329126 break;
2916429127 }
29165- case 2404LLU: // copy-back deleter (reporttok to initfrom)
29128+ case 2400LLU: // copy-back deleter (reporttok to initfrom)
2916629129 {
2916729130 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2916829131 // copy mutable arguments back from call to reporttok
29169- label = 2393LLU; // continue to roll stack
29132+ label = 2389LLU; // continue to roll stack
2917029133 break;
2917129134 }
29172- case 2405LLU: // return from reporttok to initfrom
29135+ case 2401LLU: // return from reporttok to initfrom
2917329136 {
2917429137 // copy mutable arguments back from call to reporttok
2917529138 fprintf(stderr, "%s", "\n");
2917629139 exit(-1);
29177- label = 2403LLU; // alternative complete
29140+ label = 2399LLU; // alternative complete
2917829141 break;
2917929142 }
29180- case 2403LLU: // completed if-then-else
29143+ case 2399LLU: // completed if-then-else
2918129144 {
2918229145 // call getlettype from initfrom
29183- stack[base + 32LLU] = 2406LLU/*throw to this address*/;
29184- stack[base + 33LLU] = base;
29185- stack[base + 34LLU] = 2407LLU;
29146+ stack[base + 33LLU] = 2402LLU/*throw to this address*/;
29147+ stack[base + 34LLU] = base;
29148+ stack[base + 35LLU] = 2403LLU;
2918629149 // arguments for call to getlettype
29187- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29188- stack[base + 37LLU] = stack[base + 11]/*content*/;
29189- stack[base + 38LLU] = stack[base + 4]/*scopes*/;
29190- stack[base + 39LLU] = stack[base + 5]/*scope*/;
29150+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
29151+ stack[base + 38LLU] = stack[base + 13]/*content*/;
29152+ stack[base + 39LLU] = stack[base + 5]/*scopes*/;
29153+ stack[base + 40LLU] = stack[base + 6]/*scope*/;
2919129154 // set stack-base & callee-address
29192- base += 35LLU;
29155+ base += 36LLU;
2919329156 label = 651LLU; // getlettype
2919429157 break;
2919529158 }
29196- case 2406LLU: // copy-back deleter (getlettype to initfrom)
29159+ case 2402LLU: // copy-back deleter (getlettype to initfrom)
2919729160 {
2919829161 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
2919929162 // copy mutable arguments back from call to getlettype
29200- label = 2393LLU; // continue to roll stack
29163+ label = 2389LLU; // continue to roll stack
2920129164 break;
2920229165 }
29203- case 2407LLU: // return from getlettype to initfrom
29166+ case 2403LLU: // return from getlettype to initfrom
2920429167 {
2920529168 // copy mutable arguments back from call to getlettype
2920629169 // copy back results provided by call to getlettype
29207- stack[base + 31] = stack[base + 35LLU];
29170+ stack[base + 32] = stack[base + 36LLU];
2920829171 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2920929172 if(!newstack)
2921029173 {
29211- label = 2393LLU; // throw: begin to unroll stack
29174+ label = 2389LLU; // throw: begin to unroll stack
2921229175 break;
2921329176 }
2921429177
@@ -29215,12 +29178,12 @@
2921529178 newstack[15LLU] = 9876543210LLU; // overflow-marker
2921629179 // call equtype from initfrom
2921729180 newstack[0] = (uint64_t)stack; // backup stack location
29218- newstack[1] = 2408LLU;
29181+ newstack[1] = 2404LLU;
2921929182 newstack[2] = base;
29220- newstack[3] = 2409LLU;
29183+ newstack[3] = 2405LLU;
2922129184 // arguments for call to equtype
29222- newstack[5LLU] = stack[base + 29]/*dsttype*/;
29223- newstack[6LLU] = stack[base + 31]/*srctype*/;
29185+ newstack[5LLU] = stack[base + 30]/*dsttype*/;
29186+ newstack[6LLU] = stack[base + 32]/*srctype*/;
2922429187 stack = newstack;
2922529188 // set stack-base & callee-address
2922629189 base = 4/*deloffset*/;
@@ -29227,7 +29190,7 @@
2922729190 label = 342LLU; // equtype
2922829191 break;
2922929192 }
29230- case 2408LLU: // copy-back deleter (equtype to initfrom)
29193+ case 2404LLU: // copy-back deleter (equtype to initfrom)
2923129194 {
2923229195 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2923329196 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29239,15 +29202,15 @@
2923929202 }
2924029203 Free(15LLU + 1, sizeof(uint64_t), stack);
2924129204 stack = oldstack;
29242- label = 2393LLU; // continue to unroll stack
29205+ label = 2389LLU; // continue to unroll stack
2924329206 break;
2924429207 }
29245- case 2409LLU: // return from equtype to initfrom
29208+ case 2405LLU: // return from equtype to initfrom
2924629209 {
2924729210 uint64_t *oldstack = (uint64_t *)stack[0];
2924829211 // copy mutable arguments back from call to equtype
2924929212 // copy back results provided by call to equtype
29250- oldstack[base + 9] = stack[4LLU];
29213+ oldstack[base + 10] = stack[4LLU];
2925129214 if(stack[15LLU] != 9876543210LLU)
2925229215 {
2925329216 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -29255,49 +29218,49 @@
2925529218 }
2925629219 Free(15LLU + 1, sizeof(uint64_t), stack);
2925729220 stack = oldstack;
29258- if(!stack[base + 9]/*isequal*/)
29221+ if(!stack[base + 10]/*isequal*/)
2925929222 {
29260- label = 2410LLU; // jump to alternative
29223+ label = 2406LLU; // jump to alternative
2926129224 break;
2926229225 }
2926329226
2926429227 // consequent
29265- if(/*typename*/0 != ((uint64_t *)(stack[base + 29]/*dsttype*/))[0])
29228+ if(/*typename*/0 != ((uint64_t *)(stack[base + 30]/*dsttype*/))[0])
2926629229 {
29267- label = 2413LLU; // jump to alternative
29230+ label = 2409LLU; // jump to alternative
2926829231 break;
2926929232 }
2927029233
29271- /*name*/stack[base + 32] = ((uint64_t **)(stack[base + 29]/*dsttype*/))[1][0]/*name*/;
29234+ /*name*/stack[base + 33] = ((uint64_t **)(stack[base + 30]/*dsttype*/))[1][0]/*name*/;
2927229235
2927329236 // case
2927429237 // call equ from initfrom
29275- stack[base + 33LLU] = 2415LLU/*throw to this address*/;
29276- stack[base + 34LLU] = base;
29277- stack[base + 35LLU] = 2416LLU;
29238+ stack[base + 34LLU] = 2411LLU/*throw to this address*/;
29239+ stack[base + 35LLU] = base;
29240+ stack[base + 36LLU] = 2412LLU;
2927829241 // arguments for call to equ
29279- stack[base + 37LLU] = 881834713755418624LLU;
29280- stack[base + 38LLU] = stack[base + 32]/*name*/;
29242+ stack[base + 38LLU] = 881834713755418624LLU;
29243+ stack[base + 39LLU] = stack[base + 33]/*name*/;
2928129244 // set stack-base & callee-address
29282- base += 36LLU;
29245+ base += 37LLU;
2928329246 label = 18446744073709551600LLU; // equ
2928429247 break;
2928529248 }
29286- case 2415LLU: // copy-back deleter (equ to initfrom)
29249+ case 2411LLU: // copy-back deleter (equ to initfrom)
2928729250 {
2928829251 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2928929252 // copy mutable arguments back from call to equ
29290- label = 2414LLU; // continue to roll stack
29253+ label = 2410LLU; // continue to roll stack
2929129254 break;
2929229255 }
29293- case 2416LLU: // return from equ to initfrom
29256+ case 2412LLU: // return from equ to initfrom
2929429257 {
2929529258 // copy mutable arguments back from call to equ
2929629259 // copy back results provided by call to equ
29297- stack[base + 9] = stack[base + 36LLU];
29298- if(!stack[base + 9]/*isequal*/)
29260+ stack[base + 10] = stack[base + 37LLU];
29261+ if(!stack[base + 10]/*isequal*/)
2929929262 {
29300- label = 2417LLU; // jump to alternative
29263+ label = 2413LLU; // jump to alternative
2930129264 break;
2930229265 }
2930329266
@@ -29304,317 +29267,317 @@
2930429267 // consequent
2930529268 printf("%s", "\n (((uint64_t **)(");
2930629269 // call emitvaridx from initfrom
29307- stack[base + 33LLU] = 2419LLU/*throw to this address*/;
29308- stack[base + 34LLU] = base;
29309- stack[base + 35LLU] = 2420LLU;
29270+ stack[base + 34LLU] = 2415LLU/*throw to this address*/;
29271+ stack[base + 35LLU] = base;
29272+ stack[base + 36LLU] = 2416LLU;
2931029273 // arguments for call to emitvaridx
29311- stack[base + 36LLU] = stack[base + 2]/*dstindex*/;
29274+ stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
2931229275 // set stack-base & callee-address
29313- base += 36LLU;
29276+ base += 37LLU;
2931429277 label = 691LLU; // emitvaridx
2931529278 break;
2931629279 }
29317- case 2419LLU: // copy-back deleter (emitvaridx to initfrom)
29280+ case 2415LLU: // copy-back deleter (emitvaridx to initfrom)
2931829281 {
2931929282 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2932029283 // copy mutable arguments back from call to emitvaridx
29321- label = 2414LLU; // continue to roll stack
29284+ label = 2410LLU; // continue to roll stack
2932229285 break;
2932329286 }
29324- case 2420LLU: // return from emitvaridx to initfrom
29287+ case 2416LLU: // return from emitvaridx to initfrom
2932529288 {
2932629289 // copy mutable arguments back from call to emitvaridx
2932729290 printf("%s", "))[1][");
2932829291 // call printnr from initfrom
29329- stack[base + 33LLU] = 2421LLU/*throw to this address*/;
29330- stack[base + 34LLU] = base;
29331- stack[base + 35LLU] = 2422LLU;
29292+ stack[base + 34LLU] = 2417LLU/*throw to this address*/;
29293+ stack[base + 35LLU] = base;
29294+ stack[base + 36LLU] = 2418LLU;
2933229295 // arguments for call to printnr
29333- stack[base + 36LLU] = stack[base + 25]/*elemindex*/;
29296+ stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
2933429297 // set stack-base & callee-address
29335- base += 36LLU;
29298+ base += 37LLU;
2933629299 label = 18446744073709551590LLU; // printnr
2933729300 break;
2933829301 }
29339- case 2421LLU: // copy-back deleter (printnr to initfrom)
29302+ case 2417LLU: // copy-back deleter (printnr to initfrom)
2934029303 {
2934129304 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2934229305 // copy mutable arguments back from call to printnr
29343- label = 2414LLU; // continue to roll stack
29306+ label = 2410LLU; // continue to roll stack
2934429307 break;
2934529308 }
29346- case 2422LLU: // return from printnr to initfrom
29309+ case 2418LLU: // return from printnr to initfrom
2934729310 {
2934829311 // copy mutable arguments back from call to printnr
2934929312 printf("%s", "]) = ");
2935029313 // call emitvar from initfrom
29351- stack[base + 33LLU] = 2423LLU/*throw to this address*/;
29352- stack[base + 34LLU] = base;
29353- stack[base + 35LLU] = 2424LLU;
29314+ stack[base + 34LLU] = 2419LLU/*throw to this address*/;
29315+ stack[base + 35LLU] = base;
29316+ stack[base + 36LLU] = 2420LLU;
2935429317 // arguments for call to emitvar
29355- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29356- stack[base + 37LLU] = stack[base + 11]/*content*/;
29357- stack[base + 38LLU] = stack[base + 4]/*scopes*/;
29358- stack[base + 39LLU] = stack[base + 5]/*scope*/;
29318+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
29319+ stack[base + 38LLU] = stack[base + 13]/*content*/;
29320+ stack[base + 39LLU] = stack[base + 5]/*scopes*/;
29321+ stack[base + 40LLU] = stack[base + 6]/*scope*/;
2935929322 // set stack-base & callee-address
29360- base += 36LLU;
29323+ base += 37LLU;
2936129324 label = 695LLU; // emitvar
2936229325 break;
2936329326 }
29364- case 2423LLU: // copy-back deleter (emitvar to initfrom)
29327+ case 2419LLU: // copy-back deleter (emitvar to initfrom)
2936529328 {
2936629329 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2936729330 // copy mutable arguments back from call to emitvar
29368- label = 2414LLU; // continue to roll stack
29331+ label = 2410LLU; // continue to roll stack
2936929332 break;
2937029333 }
29371- case 2424LLU: // return from emitvar to initfrom
29334+ case 2420LLU: // return from emitvar to initfrom
2937229335 {
2937329336 // copy mutable arguments back from call to emitvar
2937429337 printf("%s", ";");
29375- label = 2418LLU; // consequent complete
29338+ label = 2414LLU; // consequent complete
2937629339 break;
2937729340 }
29378- case 2417LLU: // alternative
29341+ case 2413LLU: // alternative
2937929342 {
2938029343 printf("%s", "\n INIT(&(((uint64_t **)(");
2938129344 // call emitvaridx from initfrom
29382- stack[base + 33LLU] = 2425LLU/*throw to this address*/;
29383- stack[base + 34LLU] = base;
29384- stack[base + 35LLU] = 2426LLU;
29345+ stack[base + 34LLU] = 2421LLU/*throw to this address*/;
29346+ stack[base + 35LLU] = base;
29347+ stack[base + 36LLU] = 2422LLU;
2938529348 // arguments for call to emitvaridx
29386- stack[base + 36LLU] = stack[base + 2]/*dstindex*/;
29349+ stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
2938729350 // set stack-base & callee-address
29388- base += 36LLU;
29351+ base += 37LLU;
2938929352 label = 691LLU; // emitvaridx
2939029353 break;
2939129354 }
29392- case 2425LLU: // copy-back deleter (emitvaridx to initfrom)
29355+ case 2421LLU: // copy-back deleter (emitvaridx to initfrom)
2939329356 {
2939429357 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2939529358 // copy mutable arguments back from call to emitvaridx
29396- label = 2414LLU; // continue to roll stack
29359+ label = 2410LLU; // continue to roll stack
2939729360 break;
2939829361 }
29399- case 2426LLU: // return from emitvaridx to initfrom
29362+ case 2422LLU: // return from emitvaridx to initfrom
2940029363 {
2940129364 // copy mutable arguments back from call to emitvaridx
2940229365 printf("%s", "))[1][");
2940329366 // call printnr from initfrom
29404- stack[base + 33LLU] = 2427LLU/*throw to this address*/;
29405- stack[base + 34LLU] = base;
29406- stack[base + 35LLU] = 2428LLU;
29367+ stack[base + 34LLU] = 2423LLU/*throw to this address*/;
29368+ stack[base + 35LLU] = base;
29369+ stack[base + 36LLU] = 2424LLU;
2940729370 // arguments for call to printnr
29408- stack[base + 36LLU] = stack[base + 25]/*elemindex*/;
29371+ stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
2940929372 // set stack-base & callee-address
29410- base += 36LLU;
29373+ base += 37LLU;
2941129374 label = 18446744073709551590LLU; // printnr
2941229375 break;
2941329376 }
29414- case 2427LLU: // copy-back deleter (printnr to initfrom)
29377+ case 2423LLU: // copy-back deleter (printnr to initfrom)
2941529378 {
2941629379 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2941729380 // copy mutable arguments back from call to printnr
29418- label = 2414LLU; // continue to roll stack
29381+ label = 2410LLU; // continue to roll stack
2941929382 break;
2942029383 }
29421- case 2428LLU: // return from printnr to initfrom
29384+ case 2424LLU: // return from printnr to initfrom
2942229385 {
2942329386 // copy mutable arguments back from call to printnr
2942429387 printf("%s", "]), &");
2942529388 // call emitvar from initfrom
29426- stack[base + 33LLU] = 2429LLU/*throw to this address*/;
29427- stack[base + 34LLU] = base;
29428- stack[base + 35LLU] = 2430LLU;
29389+ stack[base + 34LLU] = 2425LLU/*throw to this address*/;
29390+ stack[base + 35LLU] = base;
29391+ stack[base + 36LLU] = 2426LLU;
2942929392 // arguments for call to emitvar
29430- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29431- stack[base + 37LLU] = stack[base + 11]/*content*/;
29432- stack[base + 38LLU] = stack[base + 4]/*scopes*/;
29433- stack[base + 39LLU] = stack[base + 5]/*scope*/;
29393+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
29394+ stack[base + 38LLU] = stack[base + 13]/*content*/;
29395+ stack[base + 39LLU] = stack[base + 5]/*scopes*/;
29396+ stack[base + 40LLU] = stack[base + 6]/*scope*/;
2943429397 // set stack-base & callee-address
29435- base += 36LLU;
29398+ base += 37LLU;
2943629399 label = 695LLU; // emitvar
2943729400 break;
2943829401 }
29439- case 2429LLU: // copy-back deleter (emitvar to initfrom)
29402+ case 2425LLU: // copy-back deleter (emitvar to initfrom)
2944029403 {
2944129404 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2944229405 // copy mutable arguments back from call to emitvar
29443- label = 2414LLU; // continue to roll stack
29406+ label = 2410LLU; // continue to roll stack
2944429407 break;
2944529408 }
29446- case 2430LLU: // return from emitvar to initfrom
29409+ case 2426LLU: // return from emitvar to initfrom
2944729410 {
2944829411 // copy mutable arguments back from call to emitvar
2944929412 printf("%s", ");");
2945029413 // call unscopelet from initfrom
29451- stack[base + 33LLU] = 2431LLU/*throw to this address*/;
29452- stack[base + 34LLU] = base;
29453- stack[base + 35LLU] = 2432LLU;
29414+ stack[base + 34LLU] = 2427LLU/*throw to this address*/;
29415+ stack[base + 35LLU] = base;
29416+ stack[base + 36LLU] = 2428LLU;
2945429417 // arguments for call to unscopelet
29455- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29456- stack[base + 37LLU] = stack[base + 5]/*scope*/;
29457- stack[base + 38LLU] = stack[base + 11]/*content*/;
29418+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
29419+ stack[base + 38LLU] = stack[base + 6]/*scope*/;
29420+ stack[base + 39LLU] = stack[base + 13]/*content*/;
2945829421 // set stack-base & callee-address
29459- base += 36LLU;
29422+ base += 37LLU;
2946029423 label = 761LLU; // unscopelet
2946129424 break;
2946229425 }
29463- case 2431LLU: // copy-back deleter (unscopelet to initfrom)
29426+ case 2427LLU: // copy-back deleter (unscopelet to initfrom)
2946429427 {
2946529428 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2946629429 // copy mutable arguments back from call to unscopelet
29467- stack[base + 5]/*scope*/ = stack[base + 37LLU];
29468- label = 2414LLU; // continue to roll stack
29430+ stack[base + 6]/*scope*/ = stack[base + 38LLU];
29431+ label = 2410LLU; // continue to roll stack
2946929432 break;
2947029433 }
29471- case 2432LLU: // return from unscopelet to initfrom
29434+ case 2428LLU: // return from unscopelet to initfrom
2947229435 {
2947329436 // copy mutable arguments back from call to unscopelet
29474- stack[base + 5]/*scope*/ = stack[base + 37LLU];
29475- label = 2418LLU; // alternative complete
29437+ stack[base + 6]/*scope*/ = stack[base + 38LLU];
29438+ label = 2414LLU; // alternative complete
2947629439 break;
2947729440 }
29478- case 2418LLU: // completed if-then-else
29441+ case 2414LLU: // completed if-then-else
2947929442 {
29480- ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29481- label = 2412LLU; // case complete
29443+ ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29444+ label = 2408LLU; // case complete
2948229445 break;
2948329446 }
29484- case 2414LLU: // copy-back deleter (switch)
29447+ case 2410LLU: // copy-back deleter (switch)
2948529448 {
29486- ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29487- label = 2393LLU; // continue to unroll stack
29449+ ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29450+ label = 2389LLU; // continue to unroll stack
2948829451 break;
2948929452 }
29490- case 2413LLU: // try next case
29453+ case 2409LLU: // try next case
2949129454 {
2949229455 // default
2949329456 printf("%s", "\n INIT(&(((uint64_t **)(");
2949429457 // call emitvaridx from initfrom
29495- stack[base + 32LLU] = 2433LLU/*throw to this address*/;
29496- stack[base + 33LLU] = base;
29497- stack[base + 34LLU] = 2434LLU;
29458+ stack[base + 33LLU] = 2429LLU/*throw to this address*/;
29459+ stack[base + 34LLU] = base;
29460+ stack[base + 35LLU] = 2430LLU;
2949829461 // arguments for call to emitvaridx
29499- stack[base + 35LLU] = stack[base + 2]/*dstindex*/;
29462+ stack[base + 36LLU] = stack[base + 3]/*dstindex*/;
2950029463 // set stack-base & callee-address
29501- base += 35LLU;
29464+ base += 36LLU;
2950229465 label = 691LLU; // emitvaridx
2950329466 break;
2950429467 }
29505- case 2433LLU: // copy-back deleter (emitvaridx to initfrom)
29468+ case 2429LLU: // copy-back deleter (emitvaridx to initfrom)
2950629469 {
2950729470 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2950829471 // copy mutable arguments back from call to emitvaridx
29509- label = 2393LLU; // continue to roll stack
29472+ label = 2389LLU; // continue to roll stack
2951029473 break;
2951129474 }
29512- case 2434LLU: // return from emitvaridx to initfrom
29475+ case 2430LLU: // return from emitvaridx to initfrom
2951329476 {
2951429477 // copy mutable arguments back from call to emitvaridx
2951529478 printf("%s", "))[1][");
2951629479 // call printnr from initfrom
29517- stack[base + 32LLU] = 2435LLU/*throw to this address*/;
29518- stack[base + 33LLU] = base;
29519- stack[base + 34LLU] = 2436LLU;
29480+ stack[base + 33LLU] = 2431LLU/*throw to this address*/;
29481+ stack[base + 34LLU] = base;
29482+ stack[base + 35LLU] = 2432LLU;
2952029483 // arguments for call to printnr
29521- stack[base + 35LLU] = stack[base + 25]/*elemindex*/;
29484+ stack[base + 36LLU] = stack[base + 26]/*elemindex*/;
2952229485 // set stack-base & callee-address
29523- base += 35LLU;
29486+ base += 36LLU;
2952429487 label = 18446744073709551590LLU; // printnr
2952529488 break;
2952629489 }
29527- case 2435LLU: // copy-back deleter (printnr to initfrom)
29490+ case 2431LLU: // copy-back deleter (printnr to initfrom)
2952829491 {
2952929492 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2953029493 // copy mutable arguments back from call to printnr
29531- label = 2393LLU; // continue to roll stack
29494+ label = 2389LLU; // continue to roll stack
2953229495 break;
2953329496 }
29534- case 2436LLU: // return from printnr to initfrom
29497+ case 2432LLU: // return from printnr to initfrom
2953529498 {
2953629499 // copy mutable arguments back from call to printnr
2953729500 printf("%s", "]), &");
2953829501 // call emitvar from initfrom
29539- stack[base + 32LLU] = 2437LLU/*throw to this address*/;
29540- stack[base + 33LLU] = base;
29541- stack[base + 34LLU] = 2438LLU;
29502+ stack[base + 33LLU] = 2433LLU/*throw to this address*/;
29503+ stack[base + 34LLU] = base;
29504+ stack[base + 35LLU] = 2434LLU;
2954229505 // arguments for call to emitvar
29543- stack[base + 35LLU] = stack[base + 0]/*fnid*/;
29544- stack[base + 36LLU] = stack[base + 11]/*content*/;
29545- stack[base + 37LLU] = stack[base + 4]/*scopes*/;
29546- stack[base + 38LLU] = stack[base + 5]/*scope*/;
29506+ stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29507+ stack[base + 37LLU] = stack[base + 13]/*content*/;
29508+ stack[base + 38LLU] = stack[base + 5]/*scopes*/;
29509+ stack[base + 39LLU] = stack[base + 6]/*scope*/;
2954729510 // set stack-base & callee-address
29548- base += 35LLU;
29511+ base += 36LLU;
2954929512 label = 695LLU; // emitvar
2955029513 break;
2955129514 }
29552- case 2437LLU: // copy-back deleter (emitvar to initfrom)
29515+ case 2433LLU: // copy-back deleter (emitvar to initfrom)
2955329516 {
2955429517 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2955529518 // copy mutable arguments back from call to emitvar
29556- label = 2393LLU; // continue to roll stack
29519+ label = 2389LLU; // continue to roll stack
2955729520 break;
2955829521 }
29559- case 2438LLU: // return from emitvar to initfrom
29522+ case 2434LLU: // return from emitvar to initfrom
2956029523 {
2956129524 // copy mutable arguments back from call to emitvar
2956229525 printf("%s", ");");
2956329526 // call unscopelet from initfrom
29564- stack[base + 32LLU] = 2439LLU/*throw to this address*/;
29565- stack[base + 33LLU] = base;
29566- stack[base + 34LLU] = 2440LLU;
29527+ stack[base + 33LLU] = 2435LLU/*throw to this address*/;
29528+ stack[base + 34LLU] = base;
29529+ stack[base + 35LLU] = 2436LLU;
2956729530 // arguments for call to unscopelet
29568- stack[base + 35LLU] = stack[base + 0]/*fnid*/;
29569- stack[base + 36LLU] = stack[base + 5]/*scope*/;
29570- stack[base + 37LLU] = stack[base + 11]/*content*/;
29531+ stack[base + 36LLU] = stack[base + 0]/*fnid*/;
29532+ stack[base + 37LLU] = stack[base + 6]/*scope*/;
29533+ stack[base + 38LLU] = stack[base + 13]/*content*/;
2957129534 // set stack-base & callee-address
29572- base += 35LLU;
29535+ base += 36LLU;
2957329536 label = 761LLU; // unscopelet
2957429537 break;
2957529538 }
29576- case 2439LLU: // copy-back deleter (unscopelet to initfrom)
29539+ case 2435LLU: // copy-back deleter (unscopelet to initfrom)
2957729540 {
2957829541 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2957929542 // copy mutable arguments back from call to unscopelet
29580- stack[base + 5]/*scope*/ = stack[base + 36LLU];
29581- label = 2393LLU; // continue to roll stack
29543+ stack[base + 6]/*scope*/ = stack[base + 37LLU];
29544+ label = 2389LLU; // continue to roll stack
2958229545 break;
2958329546 }
29584- case 2440LLU: // return from unscopelet to initfrom
29547+ case 2436LLU: // return from unscopelet to initfrom
2958529548 {
2958629549 // copy mutable arguments back from call to unscopelet
29587- stack[base + 5]/*scope*/ = stack[base + 36LLU];
29588- label = 2412LLU; // default complete
29550+ stack[base + 6]/*scope*/ = stack[base + 37LLU];
29551+ label = 2408LLU; // default complete
2958929552 break;
2959029553 }
29591- case 2412LLU: // completed switch
29554+ case 2408LLU: // completed switch
2959229555 {
29593- label = 2411LLU; // consequent complete
29556+ label = 2407LLU; // consequent complete
2959429557 break;
2959529558 }
29596- case 2410LLU: // alternative
29559+ case 2406LLU: // alternative
2959729560 {
2959829561 fprintf(stderr, "%s", "in function ");
2959929562 // call reportid from initfrom
29600- stack[base + 32LLU] = 2441LLU/*throw to this address*/;
29601- stack[base + 33LLU] = base;
29602- stack[base + 34LLU] = 2442LLU;
29563+ stack[base + 33LLU] = 2437LLU/*throw to this address*/;
29564+ stack[base + 34LLU] = base;
29565+ stack[base + 35LLU] = 2438LLU;
2960329566 // arguments for call to reportid
29604- stack[base + 35LLU] = stack[base + 0]/*fnid*/;
29567+ stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2960529568 // set stack-base & callee-address
29606- base += 35LLU;
29569+ base += 36LLU;
2960729570 label = 18446744073709551586LLU; // reportid
2960829571 break;
2960929572 }
29610- case 2441LLU: // copy-back deleter (reportid to initfrom)
29573+ case 2437LLU: // copy-back deleter (reportid to initfrom)
2961129574 {
2961229575 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2961329576 // copy mutable arguments back from call to reportid
29614- label = 2393LLU; // continue to roll stack
29577+ label = 2389LLU; // continue to roll stack
2961529578 break;
2961629579 }
29617- case 2442LLU: // return from reportid to initfrom
29580+ case 2438LLU: // return from reportid to initfrom
2961829581 {
2961929582 // copy mutable arguments back from call to reportid
2962029583 fprintf(stderr, "%s", ": constructor of type ");
@@ -29621,7 +29584,7 @@
2962129584 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2962229585 if(!newstack)
2962329586 {
29624- label = 2393LLU; // throw: begin to unroll stack
29587+ label = 2389LLU; // throw: begin to unroll stack
2962529588 break;
2962629589 }
2962729590
@@ -29628,11 +29591,11 @@
2962829591 newstack[10LLU] = 9876543210LLU; // overflow-marker
2962929592 // call reporttype from initfrom
2963029593 newstack[0] = (uint64_t)stack; // backup stack location
29631- newstack[1] = 2443LLU;
29594+ newstack[1] = 2439LLU;
2963229595 newstack[2] = base;
29633- newstack[3] = 2444LLU;
29596+ newstack[3] = 2440LLU;
2963429597 // arguments for call to reporttype
29635- newstack[4LLU] = stack[base + 29]/*dsttype*/;
29598+ newstack[4LLU] = stack[base + 30]/*dsttype*/;
2963629599 stack = newstack;
2963729600 // set stack-base & callee-address
2963829601 base = 4/*deloffset*/;
@@ -29639,7 +29602,7 @@
2963929602 label = 316LLU; // reporttype
2964029603 break;
2964129604 }
29642- case 2443LLU: // copy-back deleter (reporttype to initfrom)
29605+ case 2439LLU: // copy-back deleter (reporttype to initfrom)
2964329606 {
2964429607 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2964529608 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29651,10 +29614,10 @@
2965129614 }
2965229615 Free(10LLU + 1, sizeof(uint64_t), stack);
2965329616 stack = oldstack;
29654- label = 2393LLU; // continue to unroll stack
29617+ label = 2389LLU; // continue to unroll stack
2965529618 break;
2965629619 }
29657- case 2444LLU: // return from reporttype to initfrom
29620+ case 2440LLU: // return from reporttype to initfrom
2965829621 {
2965929622 uint64_t *oldstack = (uint64_t *)stack[0];
2966029623 // copy mutable arguments back from call to reporttype
@@ -29669,7 +29632,7 @@
2966929632 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2967029633 if(!newstack)
2967129634 {
29672- label = 2393LLU; // throw: begin to unroll stack
29635+ label = 2389LLU; // throw: begin to unroll stack
2967329636 break;
2967429637 }
2967529638
@@ -29676,11 +29639,11 @@
2967629639 newstack[10LLU] = 9876543210LLU; // overflow-marker
2967729640 // call reporttype from initfrom
2967829641 newstack[0] = (uint64_t)stack; // backup stack location
29679- newstack[1] = 2445LLU;
29642+ newstack[1] = 2441LLU;
2968029643 newstack[2] = base;
29681- newstack[3] = 2446LLU;
29644+ newstack[3] = 2442LLU;
2968229645 // arguments for call to reporttype
29683- newstack[4LLU] = stack[base + 29]/*dsttype*/;
29646+ newstack[4LLU] = stack[base + 30]/*dsttype*/;
2968429647 stack = newstack;
2968529648 // set stack-base & callee-address
2968629649 base = 4/*deloffset*/;
@@ -29687,7 +29650,7 @@
2968729650 label = 316LLU; // reporttype
2968829651 break;
2968929652 }
29690- case 2445LLU: // copy-back deleter (reporttype to initfrom)
29653+ case 2441LLU: // copy-back deleter (reporttype to initfrom)
2969129654 {
2969229655 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2969329656 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29699,10 +29662,10 @@
2969929662 }
2970029663 Free(10LLU + 1, sizeof(uint64_t), stack);
2970129664 stack = oldstack;
29702- label = 2393LLU; // continue to unroll stack
29665+ label = 2389LLU; // continue to unroll stack
2970329666 break;
2970429667 }
29705- case 2446LLU: // return from reporttype to initfrom
29668+ case 2442LLU: // return from reporttype to initfrom
2970629669 {
2970729670 uint64_t *oldstack = (uint64_t *)stack[0];
2970829671 // copy mutable arguments back from call to reporttype
@@ -29717,7 +29680,7 @@
2971729680 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2971829681 if(!newstack)
2971929682 {
29720- label = 2393LLU; // throw: begin to unroll stack
29683+ label = 2389LLU; // throw: begin to unroll stack
2972129684 break;
2972229685 }
2972329686
@@ -29724,11 +29687,11 @@
2972429687 newstack[10LLU] = 9876543210LLU; // overflow-marker
2972529688 // call reporttype from initfrom
2972629689 newstack[0] = (uint64_t)stack; // backup stack location
29727- newstack[1] = 2447LLU;
29690+ newstack[1] = 2443LLU;
2972829691 newstack[2] = base;
29729- newstack[3] = 2448LLU;
29692+ newstack[3] = 2444LLU;
2973029693 // arguments for call to reporttype
29731- newstack[4LLU] = stack[base + 31]/*srctype*/;
29694+ newstack[4LLU] = stack[base + 32]/*srctype*/;
2973229695 stack = newstack;
2973329696 // set stack-base & callee-address
2973429697 base = 4/*deloffset*/;
@@ -29735,7 +29698,7 @@
2973529698 label = 316LLU; // reporttype
2973629699 break;
2973729700 }
29738- case 2447LLU: // copy-back deleter (reporttype to initfrom)
29701+ case 2443LLU: // copy-back deleter (reporttype to initfrom)
2973929702 {
2974029703 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2974129704 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29747,10 +29710,10 @@
2974729710 }
2974829711 Free(10LLU + 1, sizeof(uint64_t), stack);
2974929712 stack = oldstack;
29750- label = 2393LLU; // continue to unroll stack
29713+ label = 2389LLU; // continue to unroll stack
2975129714 break;
2975229715 }
29753- case 2448LLU: // return from reporttype to initfrom
29716+ case 2444LLU: // return from reporttype to initfrom
2975429717 {
2975529718 uint64_t *oldstack = (uint64_t *)stack[0];
2975629719 // copy mutable arguments back from call to reporttype
@@ -29763,40 +29726,40 @@
2976329726 stack = oldstack;
2976429727 fprintf(stderr, "%s", " ");
2976529728 // call reportid from initfrom
29766- stack[base + 32LLU] = 2449LLU/*throw to this address*/;
29767- stack[base + 33LLU] = base;
29768- stack[base + 34LLU] = 2450LLU;
29729+ stack[base + 33LLU] = 2445LLU/*throw to this address*/;
29730+ stack[base + 34LLU] = base;
29731+ stack[base + 35LLU] = 2446LLU;
2976929732 // arguments for call to reportid
29770- stack[base + 35LLU] = stack[base + 11]/*content*/;
29733+ stack[base + 36LLU] = stack[base + 13]/*content*/;
2977129734 // set stack-base & callee-address
29772- base += 35LLU;
29735+ base += 36LLU;
2977329736 label = 18446744073709551586LLU; // reportid
2977429737 break;
2977529738 }
29776- case 2449LLU: // copy-back deleter (reportid to initfrom)
29739+ case 2445LLU: // copy-back deleter (reportid to initfrom)
2977729740 {
2977829741 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2977929742 // copy mutable arguments back from call to reportid
29780- label = 2393LLU; // continue to roll stack
29743+ label = 2389LLU; // continue to roll stack
2978129744 break;
2978229745 }
29783- case 2450LLU: // return from reportid to initfrom
29746+ case 2446LLU: // return from reportid to initfrom
2978429747 {
2978529748 // copy mutable arguments back from call to reportid
2978629749 fprintf(stderr, "%s", "\n");
2978729750 exit(-1);
29788- label = 2411LLU; // alternative complete
29751+ label = 2407LLU; // alternative complete
2978929752 break;
2979029753 }
29791- case 2411LLU: // completed if-then-else
29754+ case 2407LLU: // completed if-then-else
2979229755 {
2979329756
29794- uint64_t *newstack = (uint64_t *)(stack[base + 31] - sizeof(uint64_t) * 4);
29757+ uint64_t *newstack = (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 4);
2979529758 // call ~type from initfrom
2979629759 newstack[0] = (uint64_t)stack; // backup stack location
2979729760 newstack[1] = 1234567890;
2979829761 newstack[2] = base;
29799- newstack[3] = 2451LLU;
29762+ newstack[3] = 2447LLU;
2980029763 stack = newstack;
2980129764 // set stack-base & callee-address
2980229765 base = 4/*deloffset*/;
@@ -29803,118 +29766,118 @@
2980329766 label = 296LLU; // ~type
2980429767 break;
2980529768 }
29806- case 2451LLU: // return from ~type to initfrom
29769+ case 2447LLU: // return from ~type to initfrom
2980729770 {
2980829771 stack = (uint64_t *)stack[0];
2980929772 // releasing toplevel container
29810- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 31] - sizeof(uint64_t) * 4));
29773+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 4));
2981129774
29812- ((uint64_t **)(stack[base + 27]))[1][1] = stack[base + 30];
29813- ((uint64_t **)(stack[base + 27]))[1][0] = stack[base + 29];
29814- label = 2391LLU; // case complete
29775+ ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
29776+ ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29777+ label = 2387LLU; // case complete
2981529778 break;
2981629779 }
29817- case 2393LLU: // copy-back deleter (switch)
29780+ case 2389LLU: // copy-back deleter (switch)
2981829781 {
29819- ((uint64_t **)(stack[base + 27]))[1][1] = stack[base + 30];
29820- ((uint64_t **)(stack[base + 27]))[1][0] = stack[base + 29];
29821- label = 2390LLU; // continue to unroll stack
29782+ ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
29783+ ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29784+ label = 2386LLU; // continue to unroll stack
2982229785 break;
2982329786 }
29824- case 2392LLU: // try next case
29787+ case 2388LLU: // try next case
2982529788 {
2982629789 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2982729790 exit(-1);
2982829791 }
29829- case 2391LLU: // completed switch
29792+ case 2387LLU: // completed switch
2983029793 {
2983129794 // call add from initfrom
29832- stack[base + 29LLU] = 2452LLU/*throw to this address*/;
29833- stack[base + 30LLU] = base;
29834- stack[base + 31LLU] = 2453LLU;
29795+ stack[base + 30LLU] = 2448LLU/*throw to this address*/;
29796+ stack[base + 31LLU] = base;
29797+ stack[base + 32LLU] = 2449LLU;
2983529798 // arguments for call to add
29836- stack[base + 33LLU] = stack[base + 25]/*elemindex*/;
29837- stack[base + 34LLU] = 1LLU;
29799+ stack[base + 34LLU] = stack[base + 26]/*elemindex*/;
29800+ stack[base + 35LLU] = 1LLU;
2983829801 // set stack-base & callee-address
29839- base += 32LLU;
29802+ base += 33LLU;
2984029803 label = 18446744073709551605LLU; // add
2984129804 break;
2984229805 }
29843- case 2452LLU: // copy-back deleter (add to initfrom)
29806+ case 2448LLU: // copy-back deleter (add to initfrom)
2984429807 {
2984529808 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2984629809 // copy mutable arguments back from call to add
29847- label = 2390LLU; // continue to roll stack
29810+ label = 2386LLU; // continue to roll stack
2984829811 break;
2984929812 }
29850- case 2453LLU: // return from add to initfrom
29813+ case 2449LLU: // return from add to initfrom
2985129814 {
2985229815 // copy mutable arguments back from call to add
2985329816 // copy back results provided by call to add
29854- stack[base + 25] = stack[base + 32LLU];
29855- ((struct listnode *)(stack[base + 28]/*previous*/))->data = stack[base + 27];
29856- label = 2388LLU; // repeat
29817+ stack[base + 26] = stack[base + 33LLU];
29818+ ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
29819+ label = 2384LLU; // repeat
2985729820 break;
2985829821 }
29859- case 2390LLU: // copy-back deleter for while next
29822+ case 2386LLU: // copy-back deleter for while next
2986029823 {
29861- ((struct listnode *)(stack[base + 28]/*previous*/))->data = stack[base + 27];
29862- label = 2386LLU; // continue to unroll stack
29824+ ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
29825+ label = 2382LLU; // continue to unroll stack
2986329826 break;
2986429827 }
29865- case 2389LLU: // loop finished
29828+ case 2385LLU: // loop finished
2986629829 {
2986729830 // call matchsym from initfrom
29868- stack[base + 29LLU] = 2454LLU/*throw to this address*/;
29869- stack[base + 30LLU] = base;
29870- stack[base + 31LLU] = 2455LLU;
29831+ stack[base + 30LLU] = 2450LLU/*throw to this address*/;
29832+ stack[base + 31LLU] = base;
29833+ stack[base + 32LLU] = 2451LLU;
2987129834 // arguments for call to matchsym
29872- stack[base + 32LLU] = stack[base + 0]/*fnid*/;
29873- stack[base + 33LLU] = 41LLU;
29874- stack[base + 34LLU] = stack[base + 6]/*lookahead*/;
29835+ stack[base + 33LLU] = stack[base + 0]/*fnid*/;
29836+ stack[base + 34LLU] = 41LLU;
29837+ stack[base + 35LLU] = stack[base + 7]/*lookahead*/;
2987529838 // set stack-base & callee-address
29876- base += 32LLU;
29839+ base += 33LLU;
2987729840 label = 212LLU; // matchsym
2987829841 break;
2987929842 }
29880- case 2454LLU: // copy-back deleter (matchsym to initfrom)
29843+ case 2450LLU: // copy-back deleter (matchsym to initfrom)
2988129844 {
2988229845 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2988329846 // copy mutable arguments back from call to matchsym
29884- stack[base + 6]/*lookahead*/ = stack[base + 34LLU];
29885- label = 2386LLU; // continue to roll stack
29847+ stack[base + 7]/*lookahead*/ = stack[base + 35LLU];
29848+ label = 2382LLU; // continue to roll stack
2988629849 break;
2988729850 }
29888- case 2455LLU: // return from matchsym to initfrom
29851+ case 2451LLU: // return from matchsym to initfrom
2988929852 {
2989029853 // copy mutable arguments back from call to matchsym
29891- stack[base + 6]/*lookahead*/ = stack[base + 34LLU];
29892- ((uint64_t **)(stack[base + 21]))[1][1] = stack[base + 23];
29893- ((uint64_t **)(stack[base + 21]))[1][0] = stack[base + 22];
29894- label = 2363LLU; // case complete
29854+ stack[base + 7]/*lookahead*/ = stack[base + 35LLU];
29855+ ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
29856+ ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29857+ label = 2359LLU; // case complete
2989529858 break;
2989629859 }
29897- case 2365LLU: // copy-back deleter (switch)
29860+ case 2361LLU: // copy-back deleter (switch)
2989829861 {
29899- ((uint64_t **)(stack[base + 21]))[1][1] = stack[base + 23];
29900- ((uint64_t **)(stack[base + 21]))[1][0] = stack[base + 22];
29901- label = 2360LLU; // continue to unroll stack
29862+ ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
29863+ ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29864+ label = 2356LLU; // continue to unroll stack
2990229865 break;
2990329866 }
29904- case 2364LLU: // try next case
29867+ case 2360LLU: // try next case
2990529868 {
2990629869 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2990729870 exit(-1);
2990829871 }
29909- case 2363LLU: // completed switch
29872+ case 2359LLU: // completed switch
2991029873 {
2991129874
29912- uint64_t *newstack = (uint64_t *)(stack[base + 21] - sizeof(uint64_t) * 4);
29875+ uint64_t *newstack = (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4);
2991329876 // call ~variant from initfrom
2991429877 newstack[0] = (uint64_t)stack; // backup stack location
2991529878 newstack[1] = 1234567890;
2991629879 newstack[2] = base;
29917- newstack[3] = 2456LLU;
29880+ newstack[3] = 2452LLU;
2991829881 stack = newstack;
2991929882 // set stack-base & callee-address
2992029883 base = 4/*deloffset*/;
@@ -29921,40 +29884,40 @@
2992129884 label = 870LLU; // ~variant
2992229885 break;
2992329886 }
29924- case 2456LLU: // return from ~variant to initfrom
29887+ case 2452LLU: // return from ~variant to initfrom
2992529888 {
2992629889 stack = (uint64_t *)stack[0];
2992729890 // releasing toplevel container
29928- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 21] - sizeof(uint64_t) * 4));
29891+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
2992929892
29930- ((uint64_t **)(stack[base + 16]))[1][2] = stack[base + 19];
29931- ((uint64_t **)(stack[base + 16]))[1][1] = stack[base + 18];
29932- ((uint64_t **)(stack[base + 16]))[1][0] = stack[base + 17];
29933- label = 2358LLU; // case complete
29893+ ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
29894+ ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
29895+ ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29896+ label = 2354LLU; // case complete
2993429897 break;
2993529898 }
29936- case 2360LLU: // copy-back deleter (switch)
29899+ case 2356LLU: // copy-back deleter (switch)
2993729900 {
29938- ((uint64_t **)(stack[base + 16]))[1][2] = stack[base + 19];
29939- ((uint64_t **)(stack[base + 16]))[1][1] = stack[base + 18];
29940- ((uint64_t **)(stack[base + 16]))[1][0] = stack[base + 17];
29941- label = 2320LLU; // continue to unroll stack
29901+ ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
29902+ ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
29903+ ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29904+ label = 2316LLU; // continue to unroll stack
2994229905 break;
2994329906 }
29944- case 2359LLU: // try next case
29907+ case 2355LLU: // try next case
2994529908 {
2994629909 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2994729910 exit(-1);
2994829911 }
29949- case 2358LLU: // completed switch
29912+ case 2354LLU: // completed switch
2995029913 {
2995129914
29952- uint64_t *newstack = (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4);
29915+ uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
2995329916 // call ~datadef from initfrom
2995429917 newstack[0] = (uint64_t)stack; // backup stack location
2995529918 newstack[1] = 1234567890;
2995629919 newstack[2] = base;
29957- newstack[3] = 2457LLU;
29920+ newstack[3] = 2453LLU;
2995829921 stack = newstack;
2995929922 // set stack-base & callee-address
2996029923 base = 4/*deloffset*/;
@@ -29961,44 +29924,44 @@
2996129924 label = 945LLU; // ~datadef
2996229925 break;
2996329926 }
29964- case 2457LLU: // return from ~datadef to initfrom
29927+ case 2453LLU: // return from ~datadef to initfrom
2996529928 {
2996629929 stack = (uint64_t *)stack[0];
2996729930 // releasing toplevel container
29968- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 16] - sizeof(uint64_t) * 4));
29931+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2996929932
29970- label = 2319LLU; // consequent complete
29933+ label = 2315LLU; // consequent complete
2997129934 break;
2997229935 }
29973- case 2318LLU: // alternative
29936+ case 2314LLU: // alternative
2997429937 {
2997529938 // call equ from initfrom
29976- stack[base + 16LLU] = 2458LLU/*throw to this address*/;
29977- stack[base + 17LLU] = base;
29978- stack[base + 18LLU] = 2459LLU;
29939+ stack[base + 17LLU] = 2454LLU/*throw to this address*/;
29940+ stack[base + 18LLU] = base;
29941+ stack[base + 19LLU] = 2455LLU;
2997929942 // arguments for call to equ
29980- stack[base + 20LLU] = stack[base + 6]/*lookahead*/;
29981- stack[base + 21LLU] = 40LLU;
29943+ stack[base + 21LLU] = stack[base + 7]/*lookahead*/;
29944+ stack[base + 22LLU] = 40LLU;
2998229945 // set stack-base & callee-address
29983- base += 19LLU;
29946+ base += 20LLU;
2998429947 label = 18446744073709551600LLU; // equ
2998529948 break;
2998629949 }
29987- case 2458LLU: // copy-back deleter (equ to initfrom)
29950+ case 2454LLU: // copy-back deleter (equ to initfrom)
2998829951 {
2998929952 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2999029953 // copy mutable arguments back from call to equ
29991- label = 2263LLU; // continue to roll stack
29954+ label = 2259LLU; // continue to roll stack
2999229955 break;
2999329956 }
29994- case 2459LLU: // return from equ to initfrom
29957+ case 2455LLU: // return from equ to initfrom
2999529958 {
2999629959 // copy mutable arguments back from call to equ
2999729960 // copy back results provided by call to equ
29998- stack[base + 15] = stack[base + 19LLU];
29999- if(!stack[base + 15]/*construct*/)
29961+ stack[base + 16] = stack[base + 20LLU];
29962+ if(!stack[base + 16]/*construct*/)
3000029963 {
30001- label = 2460LLU; // jump to alternative
29964+ label = 2456LLU; // jump to alternative
3000229965 break;
3000329966 }
3000429967
@@ -30005,214 +29968,214 @@
3000529968 // consequent
3000629969 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*dsttype*/))[0])
3000729970 {
30008- label = 2463LLU; // jump to alternative
29971+ label = 2459LLU; // jump to alternative
3000929972 break;
3001029973 }
3001129974
30012- /*typename*/stack[base + 16] = ((uint64_t **)(stack[base + 1]/*dsttype*/))[1][0]/*name*/;
29975+ /*typename*/stack[base + 17] = ((uint64_t **)(stack[base + 1]/*dsttype*/))[1][0]/*name*/;
3001329976
3001429977 // case
30015- if(!stack[base + 8]/*fncanthrow*/)
29978+ if(!stack[base + 9]/*fncanthrow*/)
3001629979 {
30017- label = 2465LLU; // jump to alternative
29980+ label = 2461LLU; // jump to alternative
3001829981 break;
3001929982 }
3002029983
3002129984 // consequent
30022- label = 2466LLU; // consequent complete
29985+ label = 2462LLU; // consequent complete
3002329986 break;
3002429987 }
30025- case 2465LLU: // alternative
29988+ case 2461LLU: // alternative
3002629989 {
3002729990 fprintf(stderr, "%s", "in function ");
3002829991 // call reportid from initfrom
30029- stack[base + 17LLU] = 2467LLU/*throw to this address*/;
30030- stack[base + 18LLU] = base;
30031- stack[base + 19LLU] = 2468LLU;
29992+ stack[base + 18LLU] = 2463LLU/*throw to this address*/;
29993+ stack[base + 19LLU] = base;
29994+ stack[base + 20LLU] = 2464LLU;
3003229995 // arguments for call to reportid
30033- stack[base + 20LLU] = stack[base + 0]/*fnid*/;
29996+ stack[base + 21LLU] = stack[base + 0]/*fnid*/;
3003429997 // set stack-base & callee-address
30035- base += 20LLU;
29998+ base += 21LLU;
3003629999 label = 18446744073709551586LLU; // reportid
3003730000 break;
3003830001 }
30039- case 2467LLU: // copy-back deleter (reportid to initfrom)
30002+ case 2463LLU: // copy-back deleter (reportid to initfrom)
3004030003 {
3004130004 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3004230005 // copy mutable arguments back from call to reportid
30043- label = 2464LLU; // continue to roll stack
30006+ label = 2460LLU; // continue to roll stack
3004430007 break;
3004530008 }
30046- case 2468LLU: // return from reportid to initfrom
30009+ case 2464LLU: // return from reportid to initfrom
3004730010 {
3004830011 // copy mutable arguments back from call to reportid
3004930012 fprintf(stderr, "%s", ": construction of data ");
3005030013 // call reportid from initfrom
30051- stack[base + 17LLU] = 2469LLU/*throw to this address*/;
30052- stack[base + 18LLU] = base;
30053- stack[base + 19LLU] = 2470LLU;
30014+ stack[base + 18LLU] = 2465LLU/*throw to this address*/;
30015+ stack[base + 19LLU] = base;
30016+ stack[base + 20LLU] = 2466LLU;
3005430017 // arguments for call to reportid
30055- stack[base + 20LLU] = stack[base + 16]/*typename*/;
30018+ stack[base + 21LLU] = stack[base + 17]/*typename*/;
3005630019 // set stack-base & callee-address
30057- base += 20LLU;
30020+ base += 21LLU;
3005830021 label = 18446744073709551586LLU; // reportid
3005930022 break;
3006030023 }
30061- case 2469LLU: // copy-back deleter (reportid to initfrom)
30024+ case 2465LLU: // copy-back deleter (reportid to initfrom)
3006230025 {
3006330026 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3006430027 // copy mutable arguments back from call to reportid
30065- label = 2464LLU; // continue to roll stack
30028+ label = 2460LLU; // continue to roll stack
3006630029 break;
3006730030 }
30068- case 2470LLU: // return from reportid to initfrom
30031+ case 2466LLU: // return from reportid to initfrom
3006930032 {
3007030033 // copy mutable arguments back from call to reportid
3007130034 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
3007230035 exit(-1);
30073- label = 2466LLU; // alternative complete
30036+ label = 2462LLU; // alternative complete
3007430037 break;
3007530038 }
30076- case 2466LLU: // completed if-then-else
30039+ case 2462LLU: // completed if-then-else
3007730040 {
3007830041 printf("%s", "\n // construct ");
3007930042 // call printid from initfrom
30080- stack[base + 17LLU] = 2471LLU/*throw to this address*/;
30081- stack[base + 18LLU] = base;
30082- stack[base + 19LLU] = 2472LLU;
30043+ stack[base + 18LLU] = 2467LLU/*throw to this address*/;
30044+ stack[base + 19LLU] = base;
30045+ stack[base + 20LLU] = 2468LLU;
3008330046 // arguments for call to printid
30084- stack[base + 20LLU] = stack[base + 16]/*typename*/;
30047+ stack[base + 21LLU] = stack[base + 17]/*typename*/;
3008530048 // set stack-base & callee-address
30086- base += 20LLU;
30049+ base += 21LLU;
3008730050 label = 18446744073709551587LLU; // printid
3008830051 break;
3008930052 }
30090- case 2471LLU: // copy-back deleter (printid to initfrom)
30053+ case 2467LLU: // copy-back deleter (printid to initfrom)
3009130054 {
3009230055 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
3009330056 // copy mutable arguments back from call to printid
30094- label = 2464LLU; // continue to roll stack
30057+ label = 2460LLU; // continue to roll stack
3009530058 break;
3009630059 }
30097- case 2472LLU: // return from printid to initfrom
30060+ case 2468LLU: // return from printid to initfrom
3009830061 {
3009930062 // copy mutable arguments back from call to printid
3010030063 printf("%s", ".");
3010130064 // call printid from initfrom
30102- stack[base + 17LLU] = 2473LLU/*throw to this address*/;
30103- stack[base + 18LLU] = base;
30104- stack[base + 19LLU] = 2474LLU;
30065+ stack[base + 18LLU] = 2469LLU/*throw to this address*/;
30066+ stack[base + 19LLU] = base;
30067+ stack[base + 20LLU] = 2470LLU;
3010530068 // arguments for call to printid
30106- stack[base + 20LLU] = stack[base + 11]/*content*/;
30069+ stack[base + 21LLU] = stack[base + 13]/*content*/;
3010730070 // set stack-base & callee-address
30108- base += 20LLU;
30071+ base += 21LLU;
3010930072 label = 18446744073709551587LLU; // printid
3011030073 break;
3011130074 }
30112- case 2473LLU: // copy-back deleter (printid to initfrom)
30075+ case 2469LLU: // copy-back deleter (printid to initfrom)
3011330076 {
3011430077 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
3011530078 // copy mutable arguments back from call to printid
30116- label = 2464LLU; // continue to roll stack
30079+ label = 2460LLU; // continue to roll stack
3011730080 break;
3011830081 }
30119- case 2474LLU: // return from printid to initfrom
30082+ case 2470LLU: // return from printid to initfrom
3012030083 {
3012130084 // copy mutable arguments back from call to printid
3012230085 // call FindData from initfrom
30123- stack[base + 18LLU] = 2475LLU/*throw to this address*/;
30124- stack[base + 19LLU] = base;
30125- stack[base + 20LLU] = 2476LLU;
30086+ stack[base + 19LLU] = 2471LLU/*throw to this address*/;
30087+ stack[base + 20LLU] = base;
30088+ stack[base + 21LLU] = 2472LLU;
3012630089 // arguments for call to FindData
30127- stack[base + 22LLU] = stack[base + 3]/*typedefs*/;
30128- stack[base + 23LLU] = stack[base + 16]/*typename*/;
30090+ stack[base + 23LLU] = stack[base + 4]/*typedefs*/;
30091+ stack[base + 24LLU] = stack[base + 17]/*typename*/;
3012930092 // set stack-base & callee-address
30130- base += 21LLU;
30093+ base += 22LLU;
3013130094 label = 1004LLU; // FindData
3013230095 break;
3013330096 }
30134- case 2475LLU: // copy-back deleter (FindData to initfrom)
30097+ case 2471LLU: // copy-back deleter (FindData to initfrom)
3013530098 {
3013630099 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
3013730100 // copy mutable arguments back from call to FindData
30138- label = 2464LLU; // continue to roll stack
30101+ label = 2460LLU; // continue to roll stack
3013930102 break;
3014030103 }
30141- case 2476LLU: // return from FindData to initfrom
30104+ case 2472LLU: // return from FindData to initfrom
3014230105 {
3014330106 // copy mutable arguments back from call to FindData
3014430107 // copy back results provided by call to FindData
30145- stack[base + 17] = stack[base + 21LLU];
30146- if(/*datadef*/0 != ((uint64_t *)(stack[base + 17]/*reftypedef*/))[0])
30108+ stack[base + 18] = stack[base + 22LLU];
30109+ if(/*datadef*/0 != ((uint64_t *)(stack[base + 18]/*reftypedef*/))[0])
3014730110 {
30148- label = 2478LLU; // jump to alternative
30111+ label = 2474LLU; // jump to alternative
3014930112 break;
3015030113 }
3015130114
30152- /*dummyid*/stack[base + 18] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][0]/*id*/;
30153- /*variants*/stack[base + 19] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][1]/*variants*/;
30154- /*destrlabel*/stack[base + 20] = ((uint64_t **)(stack[base + 17]/*reftypedef*/))[1][2]/*destrlabel*/;
30115+ /*dummyid*/stack[base + 19] = ((uint64_t **)(stack[base + 18]/*reftypedef*/))[1][0]/*id*/;
30116+ /*variants*/stack[base + 20] = ((uint64_t **)(stack[base + 18]/*reftypedef*/))[1][1]/*variants*/;
30117+ /*destrlabel*/stack[base + 21] = ((uint64_t **)(stack[base + 18]/*reftypedef*/))[1][2]/*destrlabel*/;
3015530118
3015630119 // case
3015730120 // call GetVariant from initfrom
30158- stack[base + 23LLU] = 2480LLU/*throw to this address*/;
30159- stack[base + 24LLU] = base;
30160- stack[base + 25LLU] = 2481LLU;
30121+ stack[base + 24LLU] = 2476LLU/*throw to this address*/;
30122+ stack[base + 25LLU] = base;
30123+ stack[base + 26LLU] = 2477LLU;
3016130124 // arguments for call to GetVariant
30162- stack[base + 28LLU] = stack[base + 0]/*fnid*/;
30163- stack[base + 29LLU] = stack[base + 19]/*variants*/;
30164- stack[base + 30LLU] = stack[base + 11]/*content*/;
30125+ stack[base + 29LLU] = stack[base + 0]/*fnid*/;
30126+ stack[base + 30LLU] = stack[base + 20]/*variants*/;
30127+ stack[base + 31LLU] = stack[base + 13]/*content*/;
3016530128 // set stack-base & callee-address
30166- base += 26LLU;
30129+ base += 27LLU;
3016730130 label = 907LLU; // GetVariant
3016830131 break;
3016930132 }
30170- case 2480LLU: // copy-back deleter (GetVariant to initfrom)
30133+ case 2476LLU: // copy-back deleter (GetVariant to initfrom)
3017130134 {
3017230135 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
3017330136 // copy mutable arguments back from call to GetVariant
30174- label = 2479LLU; // continue to roll stack
30137+ label = 2475LLU; // continue to roll stack
3017530138 break;
3017630139 }
30177- case 2481LLU: // return from GetVariant to initfrom
30140+ case 2477LLU: // return from GetVariant to initfrom
3017830141 {
3017930142 // copy mutable arguments back from call to GetVariant
3018030143 // copy back results provided by call to GetVariant
30181- stack[base + 21] = stack[base + 26LLU];
3018230144 stack[base + 22] = stack[base + 27LLU];
30183- if(/*variant*/0 != ((uint64_t *)(stack[base + 22]/*constr*/))[0])
30145+ stack[base + 23] = stack[base + 28LLU];
30146+ if(/*variant*/0 != ((uint64_t *)(stack[base + 23]/*constr*/))[0])
3018430147 {
30185- label = 2483LLU; // jump to alternative
30148+ label = 2479LLU; // jump to alternative
3018630149 break;
3018730150 }
3018830151
30189- /*dummy*/stack[base + 23] = ((uint64_t **)(stack[base + 22]/*constr*/))[1][0]/*id*/;
30190- /*TYPEIDS*/stack[base + 24] = ((uint64_t **)(stack[base + 22]/*constr*/))[1][1]/*elements*/;
30152+ /*dummy*/stack[base + 24] = ((uint64_t **)(stack[base + 23]/*constr*/))[1][0]/*id*/;
30153+ /*TYPEIDS*/stack[base + 25] = ((uint64_t **)(stack[base + 23]/*constr*/))[1][1]/*elements*/;
3019130154
3019230155 // case
30193- label = 2486LLU; // skip deleter
30156+ label = 2482LLU; // skip deleter
3019430157 break;
3019530158 }
30196- case 2485LLU: // deleter
30159+ case 2481LLU: // deleter
3019730160 {
3019830161 // throw from initfrom
30199- if(!stack[base + 25])
30162+ if(!stack[base + 26])
3020030163 {
30201- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
30202- label = 2484LLU; // skip, variable already deleted/unscoped
30164+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
30165+ label = 2480LLU; // skip, variable already deleted/unscoped
3020330166 break;
3020430167 }
30205- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
30206- label = 2484LLU; // continue unrolling stack, delete next variable
30168+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
30169+ label = 2480LLU; // continue unrolling stack, delete next variable
3020730170 break;
3020830171 }
30209- case 2486LLU: // skipped deleter
30172+ case 2482LLU: // skipped deleter
3021030173 {
30211- stack[base + 25] = 0;
30212- stack[base + 25]/*size*/ = list_size(((struct listnode *)(stack[base + 24]/*TYPEIDS*/)));
30213- if(!stack[base + 13]/*forceerror*/)
30174+ stack[base + 26] = 0;
30175+ stack[base + 26]/*size*/ = list_size(((struct listnode *)(stack[base + 25]/*TYPEIDS*/)));
30176+ if(!stack[base + 14]/*forceerror*/)
3021430177 {
30215- label = 2487LLU; // jump to alternative
30178+ label = 2483LLU; // jump to alternative
3021630179 break;
3021730180 }
3021830181
@@ -30219,405 +30182,405 @@
3021930182 // consequent
3022030183 printf("%s", "\n // if(!(");
3022130184 // call emitvaridx from initfrom
30222- stack[base + 26LLU] = 2489LLU/*throw to this address*/;
30223- stack[base + 27LLU] = base;
30224- stack[base + 28LLU] = 2490LLU;
30185+ stack[base + 27LLU] = 2485LLU/*throw to this address*/;
30186+ stack[base + 28LLU] = base;
30187+ stack[base + 29LLU] = 2486LLU;
3022530188 // arguments for call to emitvaridx
30226- stack[base + 29LLU] = stack[base + 2]/*dstindex*/;
30189+ stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3022730190 // set stack-base & callee-address
30228- base += 29LLU;
30191+ base += 30LLU;
3022930192 label = 691LLU; // emitvaridx
3023030193 break;
3023130194 }
30232- case 2489LLU: // copy-back deleter (emitvaridx to initfrom)
30195+ case 2485LLU: // copy-back deleter (emitvaridx to initfrom)
3023330196 {
3023430197 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3023530198 // copy mutable arguments back from call to emitvaridx
30236- label = 2485LLU; // continue to roll stack
30199+ label = 2481LLU; // continue to roll stack
3023730200 break;
3023830201 }
30239- case 2490LLU: // return from emitvaridx to initfrom
30202+ case 2486LLU: // return from emitvaridx to initfrom
3024030203 {
3024130204 // copy mutable arguments back from call to emitvaridx
3024230205 printf("%s", " = construct(");
3024330206 // call printnr from initfrom
30244- stack[base + 26LLU] = 2491LLU/*throw to this address*/;
30245- stack[base + 27LLU] = base;
30246- stack[base + 28LLU] = 2492LLU;
30207+ stack[base + 27LLU] = 2487LLU/*throw to this address*/;
30208+ stack[base + 28LLU] = base;
30209+ stack[base + 29LLU] = 2488LLU;
3024730210 // arguments for call to printnr
30248- stack[base + 29LLU] = stack[base + 25]/*size*/;
30211+ stack[base + 30LLU] = stack[base + 26]/*size*/;
3024930212 // set stack-base & callee-address
30250- base += 29LLU;
30213+ base += 30LLU;
3025130214 label = 18446744073709551590LLU; // printnr
3025230215 break;
3025330216 }
30254- case 2491LLU: // copy-back deleter (printnr to initfrom)
30217+ case 2487LLU: // copy-back deleter (printnr to initfrom)
3025530218 {
3025630219 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3025730220 // copy mutable arguments back from call to printnr
30258- label = 2485LLU; // continue to roll stack
30221+ label = 2481LLU; // continue to roll stack
3025930222 break;
3026030223 }
30261- case 2492LLU: // return from printnr to initfrom
30224+ case 2488LLU: // return from printnr to initfrom
3026230225 {
3026330226 // copy mutable arguments back from call to printnr
3026430227 printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
30265- label = 2488LLU; // consequent complete
30228+ label = 2484LLU; // consequent complete
3026630229 break;
3026730230 }
30268- case 2487LLU: // alternative
30231+ case 2483LLU: // alternative
3026930232 {
3027030233 printf("%s", "\n if(!(");
3027130234 // call emitvaridx from initfrom
30272- stack[base + 26LLU] = 2493LLU/*throw to this address*/;
30273- stack[base + 27LLU] = base;
30274- stack[base + 28LLU] = 2494LLU;
30235+ stack[base + 27LLU] = 2489LLU/*throw to this address*/;
30236+ stack[base + 28LLU] = base;
30237+ stack[base + 29LLU] = 2490LLU;
3027530238 // arguments for call to emitvaridx
30276- stack[base + 29LLU] = stack[base + 2]/*dstindex*/;
30239+ stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3027730240 // set stack-base & callee-address
30278- base += 29LLU;
30241+ base += 30LLU;
3027930242 label = 691LLU; // emitvaridx
3028030243 break;
3028130244 }
30282- case 2493LLU: // copy-back deleter (emitvaridx to initfrom)
30245+ case 2489LLU: // copy-back deleter (emitvaridx to initfrom)
3028330246 {
3028430247 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3028530248 // copy mutable arguments back from call to emitvaridx
30286- label = 2485LLU; // continue to roll stack
30249+ label = 2481LLU; // continue to roll stack
3028730250 break;
3028830251 }
30289- case 2494LLU: // return from emitvaridx to initfrom
30252+ case 2490LLU: // return from emitvaridx to initfrom
3029030253 {
3029130254 // copy mutable arguments back from call to emitvaridx
3029230255 printf("%s", " = construct(");
3029330256 // call printnr from initfrom
30294- stack[base + 26LLU] = 2495LLU/*throw to this address*/;
30295- stack[base + 27LLU] = base;
30296- stack[base + 28LLU] = 2496LLU;
30257+ stack[base + 27LLU] = 2491LLU/*throw to this address*/;
30258+ stack[base + 28LLU] = base;
30259+ stack[base + 29LLU] = 2492LLU;
3029730260 // arguments for call to printnr
30298- stack[base + 29LLU] = stack[base + 25]/*size*/;
30261+ stack[base + 30LLU] = stack[base + 26]/*size*/;
3029930262 // set stack-base & callee-address
30300- base += 29LLU;
30263+ base += 30LLU;
3030130264 label = 18446744073709551590LLU; // printnr
3030230265 break;
3030330266 }
30304- case 2495LLU: // copy-back deleter (printnr to initfrom)
30267+ case 2491LLU: // copy-back deleter (printnr to initfrom)
3030530268 {
3030630269 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3030730270 // copy mutable arguments back from call to printnr
30308- label = 2485LLU; // continue to roll stack
30271+ label = 2481LLU; // continue to roll stack
3030930272 break;
3031030273 }
30311- case 2496LLU: // return from printnr to initfrom
30274+ case 2492LLU: // return from printnr to initfrom
3031230275 {
3031330276 // copy mutable arguments back from call to printnr
3031430277 printf("%s", ")))");
30315- label = 2488LLU; // alternative complete
30278+ label = 2484LLU; // alternative complete
3031630279 break;
3031730280 }
30318- case 2488LLU: // completed if-then-else
30281+ case 2484LLU: // completed if-then-else
3031930282 {
3032030283 // call emitthrow from initfrom
30321- stack[base + 26LLU] = 2497LLU/*throw to this address*/;
30322- stack[base + 27LLU] = base;
30323- stack[base + 28LLU] = 2498LLU;
30284+ stack[base + 27LLU] = 2493LLU/*throw to this address*/;
30285+ stack[base + 28LLU] = base;
30286+ stack[base + 29LLU] = 2494LLU;
3032430287 // arguments for call to emitthrow
30325- stack[base + 29LLU] = stack[base + 5]/*scope*/;
30288+ stack[base + 30LLU] = stack[base + 6]/*scope*/;
3032630289 // set stack-base & callee-address
30327- base += 29LLU;
30290+ base += 30LLU;
3032830291 label = 1559LLU; // emitthrow
3032930292 break;
3033030293 }
30331- case 2497LLU: // copy-back deleter (emitthrow to initfrom)
30294+ case 2493LLU: // copy-back deleter (emitthrow to initfrom)
3033230295 {
3033330296 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
3033430297 // copy mutable arguments back from call to emitthrow
30335- label = 2485LLU; // continue to roll stack
30298+ label = 2481LLU; // continue to roll stack
3033630299 break;
3033730300 }
30338- case 2498LLU: // return from emitthrow to initfrom
30301+ case 2494LLU: // return from emitthrow to initfrom
3033930302 {
3034030303 // copy mutable arguments back from call to emitthrow
3034130304 printf("%s", "\n // consequent");
3034230305 printf("%s", "\n ((uint64_t *)");
3034330306 // call emitvaridx from initfrom
30344- stack[base + 26LLU] = 2499LLU/*throw to this address*/;
30345- stack[base + 27LLU] = base;
30346- stack[base + 28LLU] = 2500LLU;
30307+ stack[base + 27LLU] = 2495LLU/*throw to this address*/;
30308+ stack[base + 28LLU] = base;
30309+ stack[base + 29LLU] = 2496LLU;
3034730310 // arguments for call to emitvaridx
30348- stack[base + 29LLU] = stack[base + 2]/*dstindex*/;
30311+ stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3034930312 // set stack-base & callee-address
30350- base += 29LLU;
30313+ base += 30LLU;
3035130314 label = 691LLU; // emitvaridx
3035230315 break;
3035330316 }
30354- case 2499LLU: // copy-back deleter (emitvaridx to initfrom)
30317+ case 2495LLU: // copy-back deleter (emitvaridx to initfrom)
3035530318 {
3035630319 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3035730320 // copy mutable arguments back from call to emitvaridx
30358- label = 2485LLU; // continue to roll stack
30321+ label = 2481LLU; // continue to roll stack
3035930322 break;
3036030323 }
30361- case 2500LLU: // return from emitvaridx to initfrom
30324+ case 2496LLU: // return from emitvaridx to initfrom
3036230325 {
3036330326 // copy mutable arguments back from call to emitvaridx
3036430327 printf("%s", ")[0] = ");
3036530328 // call printnr from initfrom
30366- stack[base + 26LLU] = 2501LLU/*throw to this address*/;
30367- stack[base + 27LLU] = base;
30368- stack[base + 28LLU] = 2502LLU;
30329+ stack[base + 27LLU] = 2497LLU/*throw to this address*/;
30330+ stack[base + 28LLU] = base;
30331+ stack[base + 29LLU] = 2498LLU;
3036930332 // arguments for call to printnr
30370- stack[base + 29LLU] = stack[base + 21]/*varnr*/;
30333+ stack[base + 30LLU] = stack[base + 22]/*varnr*/;
3037130334 // set stack-base & callee-address
30372- base += 29LLU;
30335+ base += 30LLU;
3037330336 label = 18446744073709551590LLU; // printnr
3037430337 break;
3037530338 }
30376- case 2501LLU: // copy-back deleter (printnr to initfrom)
30339+ case 2497LLU: // copy-back deleter (printnr to initfrom)
3037730340 {
3037830341 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3037930342 // copy mutable arguments back from call to printnr
30380- label = 2485LLU; // continue to roll stack
30343+ label = 2481LLU; // continue to roll stack
3038130344 break;
3038230345 }
30383- case 2502LLU: // return from printnr to initfrom
30346+ case 2498LLU: // return from printnr to initfrom
3038430347 {
3038530348 // copy mutable arguments back from call to printnr
3038630349 printf("%s", ";");
3038730350 // call matchsym from initfrom
30388- stack[base + 26LLU] = 2503LLU/*throw to this address*/;
30389- stack[base + 27LLU] = base;
30390- stack[base + 28LLU] = 2504LLU;
30351+ stack[base + 27LLU] = 2499LLU/*throw to this address*/;
30352+ stack[base + 28LLU] = base;
30353+ stack[base + 29LLU] = 2500LLU;
3039130354 // arguments for call to matchsym
30392- stack[base + 29LLU] = stack[base + 0]/*fnid*/;
30393- stack[base + 30LLU] = 40LLU;
30394- stack[base + 31LLU] = stack[base + 6]/*lookahead*/;
30355+ stack[base + 30LLU] = stack[base + 0]/*fnid*/;
30356+ stack[base + 31LLU] = 40LLU;
30357+ stack[base + 32LLU] = stack[base + 7]/*lookahead*/;
3039530358 // set stack-base & callee-address
30396- base += 29LLU;
30359+ base += 30LLU;
3039730360 label = 212LLU; // matchsym
3039830361 break;
3039930362 }
30400- case 2503LLU: // copy-back deleter (matchsym to initfrom)
30363+ case 2499LLU: // copy-back deleter (matchsym to initfrom)
3040130364 {
3040230365 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3040330366 // copy mutable arguments back from call to matchsym
30404- stack[base + 6]/*lookahead*/ = stack[base + 31LLU];
30405- label = 2485LLU; // continue to roll stack
30367+ stack[base + 7]/*lookahead*/ = stack[base + 32LLU];
30368+ label = 2481LLU; // continue to roll stack
3040630369 break;
3040730370 }
30408- case 2504LLU: // return from matchsym to initfrom
30371+ case 2500LLU: // return from matchsym to initfrom
3040930372 {
3041030373 // copy mutable arguments back from call to matchsym
30411- stack[base + 6]/*lookahead*/ = stack[base + 31LLU];
30412- label = 2506LLU; // skip deleter
30374+ stack[base + 7]/*lookahead*/ = stack[base + 32LLU];
30375+ label = 2502LLU; // skip deleter
3041330376 break;
3041430377 }
30415- case 2505LLU: // deleter
30378+ case 2501LLU: // deleter
3041630379 {
3041730380 // throw from initfrom
30418- if(!stack[base + 26])
30381+ if(!stack[base + 27])
3041930382 {
30420- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
30421- label = 2485LLU; // skip, variable already deleted/unscoped
30383+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
30384+ label = 2481LLU; // skip, variable already deleted/unscoped
3042230385 break;
3042330386 }
30424- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
30425- label = 2485LLU; // continue unrolling stack, delete next variable
30387+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
30388+ label = 2481LLU; // continue unrolling stack, delete next variable
3042630389 break;
3042730390 }
30428- case 2506LLU: // skipped deleter
30391+ case 2502LLU: // skipped deleter
3042930392 {
30430- stack[base + 26] = 0;
30431- flippedassign(stack[base + 24]/*TYPEIDS*/, &stack[base + 27]);
30432- label = 2507LLU; // start to repeat
30393+ stack[base + 27] = 0;
30394+ flippedassign(stack[base + 25]/*TYPEIDS*/, &stack[base + 28]);
30395+ label = 2503LLU; // start to repeat
3043330396 break;
3043430397 }
30435- case 2507LLU: // repeat from here
30398+ case 2503LLU: // repeat from here
3043630399 {
30437- if(!stack[base + 27])
30400+ if(!stack[base + 28])
3043830401 {
30439- label = 2508LLU; // break loop
30402+ label = 2504LLU; // break loop
3044030403 break;
3044130404 }
3044230405
3044330406 // loop body
30444- stack[base + 28] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->data);
30445- stack[base + 29]/*previous*/ = stack[base + 27];
30446- stack[base + 27] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->next);
30447- if(/*typeid*/0 != ((uint64_t *)(stack[base + 28]/*typeid*/))[0])
30407+ stack[base + 29] = (uint64_t)(((const struct listnode *)(stack[base + 28]))->data);
30408+ stack[base + 30]/*previous*/ = stack[base + 28];
30409+ stack[base + 28] = (uint64_t)(((const struct listnode *)(stack[base + 28]))->next);
30410+ if(/*typeid*/0 != ((uint64_t *)(stack[base + 29]/*typeid*/))[0])
3044830411 {
30449- label = 2511LLU; // jump to alternative
30412+ label = 2507LLU; // jump to alternative
3045030413 break;
3045130414 }
3045230415
30453- /*dsttype*/stack[base + 30] = ((uint64_t **)(stack[base + 28]/*typeid*/))[1][0]/*type*/;
30454- /*elemid*/stack[base + 31] = ((uint64_t **)(stack[base + 28]/*typeid*/))[1][1]/*id*/;
30416+ /*dsttype*/stack[base + 31] = ((uint64_t **)(stack[base + 29]/*typeid*/))[1][0]/*type*/;
30417+ /*elemid*/stack[base + 32] = ((uint64_t **)(stack[base + 29]/*typeid*/))[1][1]/*id*/;
3045530418
3045630419 // case
30457- if(!stack[base + 26]/*elemindex*/)
30420+ if(!stack[base + 27]/*elemindex*/)
3045830421 {
30459- label = 2513LLU; // jump to alternative
30422+ label = 2509LLU; // jump to alternative
3046030423 break;
3046130424 }
3046230425
3046330426 // consequent
3046430427 // call matchsym from initfrom
30465- stack[base + 32LLU] = 2515LLU/*throw to this address*/;
30466- stack[base + 33LLU] = base;
30467- stack[base + 34LLU] = 2516LLU;
30428+ stack[base + 33LLU] = 2511LLU/*throw to this address*/;
30429+ stack[base + 34LLU] = base;
30430+ stack[base + 35LLU] = 2512LLU;
3046830431 // arguments for call to matchsym
30469- stack[base + 35LLU] = stack[base + 0]/*fnid*/;
30470- stack[base + 36LLU] = 44LLU;
30471- stack[base + 37LLU] = stack[base + 6]/*lookahead*/;
30432+ stack[base + 36LLU] = stack[base + 0]/*fnid*/;
30433+ stack[base + 37LLU] = 44LLU;
30434+ stack[base + 38LLU] = stack[base + 7]/*lookahead*/;
3047230435 // set stack-base & callee-address
30473- base += 35LLU;
30436+ base += 36LLU;
3047430437 label = 212LLU; // matchsym
3047530438 break;
3047630439 }
30477- case 2515LLU: // copy-back deleter (matchsym to initfrom)
30440+ case 2511LLU: // copy-back deleter (matchsym to initfrom)
3047830441 {
3047930442 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3048030443 // copy mutable arguments back from call to matchsym
30481- stack[base + 6]/*lookahead*/ = stack[base + 37LLU];
30482- label = 2512LLU; // continue to roll stack
30444+ stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30445+ label = 2508LLU; // continue to roll stack
3048330446 break;
3048430447 }
30485- case 2516LLU: // return from matchsym to initfrom
30448+ case 2512LLU: // return from matchsym to initfrom
3048630449 {
3048730450 // copy mutable arguments back from call to matchsym
30488- stack[base + 6]/*lookahead*/ = stack[base + 37LLU];
30489- label = 2514LLU; // consequent complete
30451+ stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30452+ label = 2510LLU; // consequent complete
3049030453 break;
3049130454 }
30492- case 2513LLU: // alternative
30455+ case 2509LLU: // alternative
3049330456 {
30494- label = 2514LLU; // alternative complete
30457+ label = 2510LLU; // alternative complete
3049530458 break;
3049630459 }
30497- case 2514LLU: // completed if-then-else
30460+ case 2510LLU: // completed if-then-else
3049830461 {
3049930462 // call ParseToken from initfrom
30500- stack[base + 32LLU] = 2517LLU/*throw to this address*/;
30501- stack[base + 33LLU] = base;
30502- stack[base + 34LLU] = 2518LLU;
30463+ stack[base + 33LLU] = 2513LLU/*throw to this address*/;
30464+ stack[base + 34LLU] = base;
30465+ stack[base + 35LLU] = 2514LLU;
3050330466 // arguments for call to ParseToken
30504- stack[base + 37LLU] = stack[base + 6]/*lookahead*/;
30467+ stack[base + 38LLU] = stack[base + 7]/*lookahead*/;
3050530468 // set stack-base & callee-address
30506- base += 35LLU;
30469+ base += 36LLU;
3050730470 label = 3LLU; // ParseToken
3050830471 break;
3050930472 }
30510- case 2517LLU: // copy-back deleter (ParseToken to initfrom)
30473+ case 2513LLU: // copy-back deleter (ParseToken to initfrom)
3051130474 {
3051230475 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
3051330476 // copy mutable arguments back from call to ParseToken
30514- stack[base + 6]/*lookahead*/ = stack[base + 37LLU];
30515- label = 2512LLU; // continue to roll stack
30477+ stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30478+ label = 2508LLU; // continue to roll stack
3051630479 break;
3051730480 }
30518- case 2518LLU: // return from ParseToken to initfrom
30481+ case 2514LLU: // return from ParseToken to initfrom
3051930482 {
3052030483 // copy mutable arguments back from call to ParseToken
30521- stack[base + 6]/*lookahead*/ = stack[base + 37LLU];
30484+ stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
3052230485 // copy back results provided by call to ParseToken
30523- stack[base + 10] = stack[base + 35LLU];
30524- stack[base + 11] = stack[base + 36LLU];
30486+ stack[base + 12] = stack[base + 36LLU];
30487+ stack[base + 13] = stack[base + 37LLU];
3052530488 // call equ from initfrom
30526- stack[base + 32LLU] = 2519LLU/*throw to this address*/;
30527- stack[base + 33LLU] = base;
30528- stack[base + 34LLU] = 2520LLU;
30489+ stack[base + 33LLU] = 2515LLU/*throw to this address*/;
30490+ stack[base + 34LLU] = base;
30491+ stack[base + 35LLU] = 2516LLU;
3052930492 // arguments for call to equ
30530- stack[base + 36LLU] = stack[base + 10]/*variant*/;
30531- stack[base + 37LLU] = 4LLU;
30493+ stack[base + 37LLU] = stack[base + 12]/*variant*/;
30494+ stack[base + 38LLU] = 4LLU;
3053230495 // set stack-base & callee-address
30533- base += 35LLU;
30496+ base += 36LLU;
3053430497 label = 18446744073709551600LLU; // equ
3053530498 break;
3053630499 }
30537- case 2519LLU: // copy-back deleter (equ to initfrom)
30500+ case 2515LLU: // copy-back deleter (equ to initfrom)
3053830501 {
3053930502 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3054030503 // copy mutable arguments back from call to equ
30541- label = 2512LLU; // continue to roll stack
30504+ label = 2508LLU; // continue to roll stack
3054230505 break;
3054330506 }
30544- case 2520LLU: // return from equ to initfrom
30507+ case 2516LLU: // return from equ to initfrom
3054530508 {
3054630509 // copy mutable arguments back from call to equ
3054730510 // copy back results provided by call to equ
30548- stack[base + 9] = stack[base + 35LLU];
30549- if(!stack[base + 9]/*isequal*/)
30511+ stack[base + 10] = stack[base + 36LLU];
30512+ if(!stack[base + 10]/*isequal*/)
3055030513 {
30551- label = 2521LLU; // jump to alternative
30514+ label = 2517LLU; // jump to alternative
3055230515 break;
3055330516 }
3055430517
3055530518 // consequent
30556- label = 2522LLU; // consequent complete
30519+ label = 2518LLU; // consequent complete
3055730520 break;
3055830521 }
30559- case 2521LLU: // alternative
30522+ case 2517LLU: // alternative
3056030523 {
3056130524 fprintf(stderr, "%s", "constructor requires variables but found ");
3056230525 // call reporttok from initfrom
30563- stack[base + 32LLU] = 2523LLU/*throw to this address*/;
30564- stack[base + 33LLU] = base;
30565- stack[base + 34LLU] = 2524LLU;
30526+ stack[base + 33LLU] = 2519LLU/*throw to this address*/;
30527+ stack[base + 34LLU] = base;
30528+ stack[base + 35LLU] = 2520LLU;
3056630529 // arguments for call to reporttok
30567- stack[base + 35LLU] = stack[base + 10]/*variant*/;
30568- stack[base + 36LLU] = stack[base + 11]/*content*/;
30530+ stack[base + 36LLU] = stack[base + 12]/*variant*/;
30531+ stack[base + 37LLU] = stack[base + 13]/*content*/;
3056930532 // set stack-base & callee-address
30570- base += 35LLU;
30533+ base += 36LLU;
3057130534 label = 18446744073709551582LLU; // reporttok
3057230535 break;
3057330536 }
30574- case 2523LLU: // copy-back deleter (reporttok to initfrom)
30537+ case 2519LLU: // copy-back deleter (reporttok to initfrom)
3057530538 {
3057630539 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
3057730540 // copy mutable arguments back from call to reporttok
30578- label = 2512LLU; // continue to roll stack
30541+ label = 2508LLU; // continue to roll stack
3057930542 break;
3058030543 }
30581- case 2524LLU: // return from reporttok to initfrom
30544+ case 2520LLU: // return from reporttok to initfrom
3058230545 {
3058330546 // copy mutable arguments back from call to reporttok
3058430547 fprintf(stderr, "%s", "\n");
3058530548 exit(-1);
30586- label = 2522LLU; // alternative complete
30549+ label = 2518LLU; // alternative complete
3058730550 break;
3058830551 }
30589- case 2522LLU: // completed if-then-else
30552+ case 2518LLU: // completed if-then-else
3059030553 {
3059130554 // call getlettype from initfrom
30592- stack[base + 33LLU] = 2525LLU/*throw to this address*/;
30593- stack[base + 34LLU] = base;
30594- stack[base + 35LLU] = 2526LLU;
30555+ stack[base + 34LLU] = 2521LLU/*throw to this address*/;
30556+ stack[base + 35LLU] = base;
30557+ stack[base + 36LLU] = 2522LLU;
3059530558 // arguments for call to getlettype
30596- stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30597- stack[base + 38LLU] = stack[base + 11]/*content*/;
30598- stack[base + 39LLU] = stack[base + 4]/*scopes*/;
30599- stack[base + 40LLU] = stack[base + 5]/*scope*/;
30559+ stack[base + 38LLU] = stack[base + 0]/*fnid*/;
30560+ stack[base + 39LLU] = stack[base + 13]/*content*/;
30561+ stack[base + 40LLU] = stack[base + 5]/*scopes*/;
30562+ stack[base + 41LLU] = stack[base + 6]/*scope*/;
3060030563 // set stack-base & callee-address
30601- base += 36LLU;
30564+ base += 37LLU;
3060230565 label = 651LLU; // getlettype
3060330566 break;
3060430567 }
30605- case 2525LLU: // copy-back deleter (getlettype to initfrom)
30568+ case 2521LLU: // copy-back deleter (getlettype to initfrom)
3060630569 {
3060730570 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
3060830571 // copy mutable arguments back from call to getlettype
30609- label = 2512LLU; // continue to roll stack
30572+ label = 2508LLU; // continue to roll stack
3061030573 break;
3061130574 }
30612- case 2526LLU: // return from getlettype to initfrom
30575+ case 2522LLU: // return from getlettype to initfrom
3061330576 {
3061430577 // copy mutable arguments back from call to getlettype
3061530578 // copy back results provided by call to getlettype
30616- stack[base + 32] = stack[base + 36LLU];
30579+ stack[base + 33] = stack[base + 37LLU];
3061730580 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
3061830581 if(!newstack)
3061930582 {
30620- label = 2512LLU; // throw: begin to unroll stack
30583+ label = 2508LLU; // throw: begin to unroll stack
3062130584 break;
3062230585 }
3062330586
@@ -30624,12 +30587,12 @@
3062430587 newstack[15LLU] = 9876543210LLU; // overflow-marker
3062530588 // call equtype from initfrom
3062630589 newstack[0] = (uint64_t)stack; // backup stack location
30627- newstack[1] = 2527LLU;
30590+ newstack[1] = 2523LLU;
3062830591 newstack[2] = base;
30629- newstack[3] = 2528LLU;
30592+ newstack[3] = 2524LLU;
3063030593 // arguments for call to equtype
30631- newstack[5LLU] = stack[base + 30]/*dsttype*/;
30632- newstack[6LLU] = stack[base + 32]/*srctype*/;
30594+ newstack[5LLU] = stack[base + 31]/*dsttype*/;
30595+ newstack[6LLU] = stack[base + 33]/*srctype*/;
3063330596 stack = newstack;
3063430597 // set stack-base & callee-address
3063530598 base = 4/*deloffset*/;
@@ -30636,7 +30599,7 @@
3063630599 label = 342LLU; // equtype
3063730600 break;
3063830601 }
30639- case 2527LLU: // copy-back deleter (equtype to initfrom)
30602+ case 2523LLU: // copy-back deleter (equtype to initfrom)
3064030603 {
3064130604 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
3064230605 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -30648,15 +30611,15 @@
3064830611 }
3064930612 Free(15LLU + 1, sizeof(uint64_t), stack);
3065030613 stack = oldstack;
30651- label = 2512LLU; // continue to unroll stack
30614+ label = 2508LLU; // continue to unroll stack
3065230615 break;
3065330616 }
30654- case 2528LLU: // return from equtype to initfrom
30617+ case 2524LLU: // return from equtype to initfrom
3065530618 {
3065630619 uint64_t *oldstack = (uint64_t *)stack[0];
3065730620 // copy mutable arguments back from call to equtype
3065830621 // copy back results provided by call to equtype
30659- oldstack[base + 9] = stack[4LLU];
30622+ oldstack[base + 10] = stack[4LLU];
3066030623 if(stack[15LLU] != 9876543210LLU)
3066130624 {
3066230625 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to equtype)!");
@@ -30664,49 +30627,49 @@
3066430627 }
3066530628 Free(15LLU + 1, sizeof(uint64_t), stack);
3066630629 stack = oldstack;
30667- if(!stack[base + 9]/*isequal*/)
30630+ if(!stack[base + 10]/*isequal*/)
3066830631 {
30669- label = 2529LLU; // jump to alternative
30632+ label = 2525LLU; // jump to alternative
3067030633 break;
3067130634 }
3067230635
3067330636 // consequent
30674- if(/*typename*/0 != ((uint64_t *)(stack[base + 30]/*dsttype*/))[0])
30637+ if(/*typename*/0 != ((uint64_t *)(stack[base + 31]/*dsttype*/))[0])
3067530638 {
30676- label = 2532LLU; // jump to alternative
30639+ label = 2528LLU; // jump to alternative
3067730640 break;
3067830641 }
3067930642
30680- /*name*/stack[base + 33] = ((uint64_t **)(stack[base + 30]/*dsttype*/))[1][0]/*name*/;
30643+ /*name*/stack[base + 34] = ((uint64_t **)(stack[base + 31]/*dsttype*/))[1][0]/*name*/;
3068130644
3068230645 // case
3068330646 // call equ from initfrom
30684- stack[base + 34LLU] = 2534LLU/*throw to this address*/;
30685- stack[base + 35LLU] = base;
30686- stack[base + 36LLU] = 2535LLU;
30647+ stack[base + 35LLU] = 2530LLU/*throw to this address*/;
30648+ stack[base + 36LLU] = base;
30649+ stack[base + 37LLU] = 2531LLU;
3068730650 // arguments for call to equ
30688- stack[base + 38LLU] = 881834713755418624LLU;
30689- stack[base + 39LLU] = stack[base + 33]/*name*/;
30651+ stack[base + 39LLU] = 881834713755418624LLU;
30652+ stack[base + 40LLU] = stack[base + 34]/*name*/;
3069030653 // set stack-base & callee-address
30691- base += 37LLU;
30654+ base += 38LLU;
3069230655 label = 18446744073709551600LLU; // equ
3069330656 break;
3069430657 }
30695- case 2534LLU: // copy-back deleter (equ to initfrom)
30658+ case 2530LLU: // copy-back deleter (equ to initfrom)
3069630659 {
3069730660 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3069830661 // copy mutable arguments back from call to equ
30699- label = 2533LLU; // continue to roll stack
30662+ label = 2529LLU; // continue to roll stack
3070030663 break;
3070130664 }
30702- case 2535LLU: // return from equ to initfrom
30665+ case 2531LLU: // return from equ to initfrom
3070330666 {
3070430667 // copy mutable arguments back from call to equ
3070530668 // copy back results provided by call to equ
30706- stack[base + 9] = stack[base + 37LLU];
30707- if(!stack[base + 9]/*isequal*/)
30669+ stack[base + 10] = stack[base + 38LLU];
30670+ if(!stack[base + 10]/*isequal*/)
3070830671 {
30709- label = 2536LLU; // jump to alternative
30672+ label = 2532LLU; // jump to alternative
3071030673 break;
3071130674 }
3071230675
@@ -30713,317 +30676,317 @@
3071330676 // consequent
3071430677 printf("%s", "\n (((uint64_t **)(");
3071530678 // call emitvaridx from initfrom
30716- stack[base + 34LLU] = 2538LLU/*throw to this address*/;
30717- stack[base + 35LLU] = base;
30718- stack[base + 36LLU] = 2539LLU;
30679+ stack[base + 35LLU] = 2534LLU/*throw to this address*/;
30680+ stack[base + 36LLU] = base;
30681+ stack[base + 37LLU] = 2535LLU;
3071930682 // arguments for call to emitvaridx
30720- stack[base + 37LLU] = stack[base + 2]/*dstindex*/;
30683+ stack[base + 38LLU] = stack[base + 3]/*dstindex*/;
3072130684 // set stack-base & callee-address
30722- base += 37LLU;
30685+ base += 38LLU;
3072330686 label = 691LLU; // emitvaridx
3072430687 break;
3072530688 }
30726- case 2538LLU: // copy-back deleter (emitvaridx to initfrom)
30689+ case 2534LLU: // copy-back deleter (emitvaridx to initfrom)
3072730690 {
3072830691 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3072930692 // copy mutable arguments back from call to emitvaridx
30730- label = 2533LLU; // continue to roll stack
30693+ label = 2529LLU; // continue to roll stack
3073130694 break;
3073230695 }
30733- case 2539LLU: // return from emitvaridx to initfrom
30696+ case 2535LLU: // return from emitvaridx to initfrom
3073430697 {
3073530698 // copy mutable arguments back from call to emitvaridx
3073630699 printf("%s", "))[1][");
3073730700 // call printnr from initfrom
30738- stack[base + 34LLU] = 2540LLU/*throw to this address*/;
30739- stack[base + 35LLU] = base;
30740- stack[base + 36LLU] = 2541LLU;
30701+ stack[base + 35LLU] = 2536LLU/*throw to this address*/;
30702+ stack[base + 36LLU] = base;
30703+ stack[base + 37LLU] = 2537LLU;
3074130704 // arguments for call to printnr
30742- stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
30705+ stack[base + 38LLU] = stack[base + 27]/*elemindex*/;
3074330706 // set stack-base & callee-address
30744- base += 37LLU;
30707+ base += 38LLU;
3074530708 label = 18446744073709551590LLU; // printnr
3074630709 break;
3074730710 }
30748- case 2540LLU: // copy-back deleter (printnr to initfrom)
30711+ case 2536LLU: // copy-back deleter (printnr to initfrom)
3074930712 {
3075030713 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3075130714 // copy mutable arguments back from call to printnr
30752- label = 2533LLU; // continue to roll stack
30715+ label = 2529LLU; // continue to roll stack
3075330716 break;
3075430717 }
30755- case 2541LLU: // return from printnr to initfrom
30718+ case 2537LLU: // return from printnr to initfrom
3075630719 {
3075730720 // copy mutable arguments back from call to printnr
3075830721 printf("%s", "]) = ");
3075930722 // call emitvar from initfrom
30760- stack[base + 34LLU] = 2542LLU/*throw to this address*/;
30761- stack[base + 35LLU] = base;
30762- stack[base + 36LLU] = 2543LLU;
30723+ stack[base + 35LLU] = 2538LLU/*throw to this address*/;
30724+ stack[base + 36LLU] = base;
30725+ stack[base + 37LLU] = 2539LLU;
3076330726 // arguments for call to emitvar
30764- stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30765- stack[base + 38LLU] = stack[base + 11]/*content*/;
30766- stack[base + 39LLU] = stack[base + 4]/*scopes*/;
30767- stack[base + 40LLU] = stack[base + 5]/*scope*/;
30727+ stack[base + 38LLU] = stack[base + 0]/*fnid*/;
30728+ stack[base + 39LLU] = stack[base + 13]/*content*/;
30729+ stack[base + 40LLU] = stack[base + 5]/*scopes*/;
30730+ stack[base + 41LLU] = stack[base + 6]/*scope*/;
3076830731 // set stack-base & callee-address
30769- base += 37LLU;
30732+ base += 38LLU;
3077030733 label = 695LLU; // emitvar
3077130734 break;
3077230735 }
30773- case 2542LLU: // copy-back deleter (emitvar to initfrom)
30736+ case 2538LLU: // copy-back deleter (emitvar to initfrom)
3077430737 {
3077530738 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3077630739 // copy mutable arguments back from call to emitvar
30777- label = 2533LLU; // continue to roll stack
30740+ label = 2529LLU; // continue to roll stack
3077830741 break;
3077930742 }
30780- case 2543LLU: // return from emitvar to initfrom
30743+ case 2539LLU: // return from emitvar to initfrom
3078130744 {
3078230745 // copy mutable arguments back from call to emitvar
3078330746 printf("%s", ";");
30784- label = 2537LLU; // consequent complete
30747+ label = 2533LLU; // consequent complete
3078530748 break;
3078630749 }
30787- case 2536LLU: // alternative
30750+ case 2532LLU: // alternative
3078830751 {
3078930752 printf("%s", "\n INIT(&(((uint64_t **)(");
3079030753 // call emitvaridx from initfrom
30791- stack[base + 34LLU] = 2544LLU/*throw to this address*/;
30792- stack[base + 35LLU] = base;
30793- stack[base + 36LLU] = 2545LLU;
30754+ stack[base + 35LLU] = 2540LLU/*throw to this address*/;
30755+ stack[base + 36LLU] = base;
30756+ stack[base + 37LLU] = 2541LLU;
3079430757 // arguments for call to emitvaridx
30795- stack[base + 37LLU] = stack[base + 2]/*dstindex*/;
30758+ stack[base + 38LLU] = stack[base + 3]/*dstindex*/;
3079630759 // set stack-base & callee-address
30797- base += 37LLU;
30760+ base += 38LLU;
3079830761 label = 691LLU; // emitvaridx
3079930762 break;
3080030763 }
30801- case 2544LLU: // copy-back deleter (emitvaridx to initfrom)
30764+ case 2540LLU: // copy-back deleter (emitvaridx to initfrom)
3080230765 {
3080330766 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3080430767 // copy mutable arguments back from call to emitvaridx
30805- label = 2533LLU; // continue to roll stack
30768+ label = 2529LLU; // continue to roll stack
3080630769 break;
3080730770 }
30808- case 2545LLU: // return from emitvaridx to initfrom
30771+ case 2541LLU: // return from emitvaridx to initfrom
3080930772 {
3081030773 // copy mutable arguments back from call to emitvaridx
3081130774 printf("%s", "))[1][");
3081230775 // call printnr from initfrom
30813- stack[base + 34LLU] = 2546LLU/*throw to this address*/;
30814- stack[base + 35LLU] = base;
30815- stack[base + 36LLU] = 2547LLU;
30776+ stack[base + 35LLU] = 2542LLU/*throw to this address*/;
30777+ stack[base + 36LLU] = base;
30778+ stack[base + 37LLU] = 2543LLU;
3081630779 // arguments for call to printnr
30817- stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
30780+ stack[base + 38LLU] = stack[base + 27]/*elemindex*/;
3081830781 // set stack-base & callee-address
30819- base += 37LLU;
30782+ base += 38LLU;
3082030783 label = 18446744073709551590LLU; // printnr
3082130784 break;
3082230785 }
30823- case 2546LLU: // copy-back deleter (printnr to initfrom)
30786+ case 2542LLU: // copy-back deleter (printnr to initfrom)
3082430787 {
3082530788 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3082630789 // copy mutable arguments back from call to printnr
30827- label = 2533LLU; // continue to roll stack
30790+ label = 2529LLU; // continue to roll stack
3082830791 break;
3082930792 }
30830- case 2547LLU: // return from printnr to initfrom
30793+ case 2543LLU: // return from printnr to initfrom
3083130794 {
3083230795 // copy mutable arguments back from call to printnr
3083330796 printf("%s", "]), &");
3083430797 // call emitvar from initfrom
30835- stack[base + 34LLU] = 2548LLU/*throw to this address*/;
30836- stack[base + 35LLU] = base;
30837- stack[base + 36LLU] = 2549LLU;
30798+ stack[base + 35LLU] = 2544LLU/*throw to this address*/;
30799+ stack[base + 36LLU] = base;
30800+ stack[base + 37LLU] = 2545LLU;
3083830801 // arguments for call to emitvar
30839- stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30840- stack[base + 38LLU] = stack[base + 11]/*content*/;
30841- stack[base + 39LLU] = stack[base + 4]/*scopes*/;
30842- stack[base + 40LLU] = stack[base + 5]/*scope*/;
30802+ stack[base + 38LLU] = stack[base + 0]/*fnid*/;
30803+ stack[base + 39LLU] = stack[base + 13]/*content*/;
30804+ stack[base + 40LLU] = stack[base + 5]/*scopes*/;
30805+ stack[base + 41LLU] = stack[base + 6]/*scope*/;
3084330806 // set stack-base & callee-address
30844- base += 37LLU;
30807+ base += 38LLU;
3084530808 label = 695LLU; // emitvar
3084630809 break;
3084730810 }
30848- case 2548LLU: // copy-back deleter (emitvar to initfrom)
30811+ case 2544LLU: // copy-back deleter (emitvar to initfrom)
3084930812 {
3085030813 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3085130814 // copy mutable arguments back from call to emitvar
30852- label = 2533LLU; // continue to roll stack
30815+ label = 2529LLU; // continue to roll stack
3085330816 break;
3085430817 }
30855- case 2549LLU: // return from emitvar to initfrom
30818+ case 2545LLU: // return from emitvar to initfrom
3085630819 {
3085730820 // copy mutable arguments back from call to emitvar
3085830821 printf("%s", ");");
3085930822 // call unscopelet from initfrom
30860- stack[base + 34LLU] = 2550LLU/*throw to this address*/;
30861- stack[base + 35LLU] = base;
30862- stack[base + 36LLU] = 2551LLU;
30823+ stack[base + 35LLU] = 2546LLU/*throw to this address*/;
30824+ stack[base + 36LLU] = base;
30825+ stack[base + 37LLU] = 2547LLU;
3086330826 // arguments for call to unscopelet
30864- stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30865- stack[base + 38LLU] = stack[base + 5]/*scope*/;
30866- stack[base + 39LLU] = stack[base + 11]/*content*/;
30827+ stack[base + 38LLU] = stack[base + 0]/*fnid*/;
30828+ stack[base + 39LLU] = stack[base + 6]/*scope*/;
30829+ stack[base + 40LLU] = stack[base + 13]/*content*/;
3086730830 // set stack-base & callee-address
30868- base += 37LLU;
30831+ base += 38LLU;
3086930832 label = 761LLU; // unscopelet
3087030833 break;
3087130834 }
30872- case 2550LLU: // copy-back deleter (unscopelet to initfrom)
30835+ case 2546LLU: // copy-back deleter (unscopelet to initfrom)
3087330836 {
3087430837 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3087530838 // copy mutable arguments back from call to unscopelet
30876- stack[base + 5]/*scope*/ = stack[base + 38LLU];
30877- label = 2533LLU; // continue to roll stack
30839+ stack[base + 6]/*scope*/ = stack[base + 39LLU];
30840+ label = 2529LLU; // continue to roll stack
3087830841 break;
3087930842 }
30880- case 2551LLU: // return from unscopelet to initfrom
30843+ case 2547LLU: // return from unscopelet to initfrom
3088130844 {
3088230845 // copy mutable arguments back from call to unscopelet
30883- stack[base + 5]/*scope*/ = stack[base + 38LLU];
30884- label = 2537LLU; // alternative complete
30846+ stack[base + 6]/*scope*/ = stack[base + 39LLU];
30847+ label = 2533LLU; // alternative complete
3088530848 break;
3088630849 }
30887- case 2537LLU: // completed if-then-else
30850+ case 2533LLU: // completed if-then-else
3088830851 {
30889- ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
30890- label = 2531LLU; // case complete
30852+ ((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30853+ label = 2527LLU; // case complete
3089130854 break;
3089230855 }
30893- case 2533LLU: // copy-back deleter (switch)
30856+ case 2529LLU: // copy-back deleter (switch)
3089430857 {
30895- ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
30896- label = 2512LLU; // continue to unroll stack
30858+ ((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30859+ label = 2508LLU; // continue to unroll stack
3089730860 break;
3089830861 }
30899- case 2532LLU: // try next case
30862+ case 2528LLU: // try next case
3090030863 {
3090130864 // default
3090230865 printf("%s", "\n INIT(&(((uint64_t **)(");
3090330866 // call emitvaridx from initfrom
30904- stack[base + 33LLU] = 2552LLU/*throw to this address*/;
30905- stack[base + 34LLU] = base;
30906- stack[base + 35LLU] = 2553LLU;
30867+ stack[base + 34LLU] = 2548LLU/*throw to this address*/;
30868+ stack[base + 35LLU] = base;
30869+ stack[base + 36LLU] = 2549LLU;
3090730870 // arguments for call to emitvaridx
30908- stack[base + 36LLU] = stack[base + 2]/*dstindex*/;
30871+ stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
3090930872 // set stack-base & callee-address
30910- base += 36LLU;
30873+ base += 37LLU;
3091130874 label = 691LLU; // emitvaridx
3091230875 break;
3091330876 }
30914- case 2552LLU: // copy-back deleter (emitvaridx to initfrom)
30877+ case 2548LLU: // copy-back deleter (emitvaridx to initfrom)
3091530878 {
3091630879 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3091730880 // copy mutable arguments back from call to emitvaridx
30918- label = 2512LLU; // continue to roll stack
30881+ label = 2508LLU; // continue to roll stack
3091930882 break;
3092030883 }
30921- case 2553LLU: // return from emitvaridx to initfrom
30884+ case 2549LLU: // return from emitvaridx to initfrom
3092230885 {
3092330886 // copy mutable arguments back from call to emitvaridx
3092430887 printf("%s", "))[1][");
3092530888 // call printnr from initfrom
30926- stack[base + 33LLU] = 2554LLU/*throw to this address*/;
30927- stack[base + 34LLU] = base;
30928- stack[base + 35LLU] = 2555LLU;
30889+ stack[base + 34LLU] = 2550LLU/*throw to this address*/;
30890+ stack[base + 35LLU] = base;
30891+ stack[base + 36LLU] = 2551LLU;
3092930892 // arguments for call to printnr
30930- stack[base + 36LLU] = stack[base + 26]/*elemindex*/;
30893+ stack[base + 37LLU] = stack[base + 27]/*elemindex*/;
3093130894 // set stack-base & callee-address
30932- base += 36LLU;
30895+ base += 37LLU;
3093330896 label = 18446744073709551590LLU; // printnr
3093430897 break;
3093530898 }
30936- case 2554LLU: // copy-back deleter (printnr to initfrom)
30899+ case 2550LLU: // copy-back deleter (printnr to initfrom)
3093730900 {
3093830901 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3093930902 // copy mutable arguments back from call to printnr
30940- label = 2512LLU; // continue to roll stack
30903+ label = 2508LLU; // continue to roll stack
3094130904 break;
3094230905 }
30943- case 2555LLU: // return from printnr to initfrom
30906+ case 2551LLU: // return from printnr to initfrom
3094430907 {
3094530908 // copy mutable arguments back from call to printnr
3094630909 printf("%s", "]), &");
3094730910 // call emitvar from initfrom
30948- stack[base + 33LLU] = 2556LLU/*throw to this address*/;
30949- stack[base + 34LLU] = base;
30950- stack[base + 35LLU] = 2557LLU;
30911+ stack[base + 34LLU] = 2552LLU/*throw to this address*/;
30912+ stack[base + 35LLU] = base;
30913+ stack[base + 36LLU] = 2553LLU;
3095130914 // arguments for call to emitvar
30952- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
30953- stack[base + 37LLU] = stack[base + 11]/*content*/;
30954- stack[base + 38LLU] = stack[base + 4]/*scopes*/;
30955- stack[base + 39LLU] = stack[base + 5]/*scope*/;
30915+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30916+ stack[base + 38LLU] = stack[base + 13]/*content*/;
30917+ stack[base + 39LLU] = stack[base + 5]/*scopes*/;
30918+ stack[base + 40LLU] = stack[base + 6]/*scope*/;
3095630919 // set stack-base & callee-address
30957- base += 36LLU;
30920+ base += 37LLU;
3095830921 label = 695LLU; // emitvar
3095930922 break;
3096030923 }
30961- case 2556LLU: // copy-back deleter (emitvar to initfrom)
30924+ case 2552LLU: // copy-back deleter (emitvar to initfrom)
3096230925 {
3096330926 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3096430927 // copy mutable arguments back from call to emitvar
30965- label = 2512LLU; // continue to roll stack
30928+ label = 2508LLU; // continue to roll stack
3096630929 break;
3096730930 }
30968- case 2557LLU: // return from emitvar to initfrom
30931+ case 2553LLU: // return from emitvar to initfrom
3096930932 {
3097030933 // copy mutable arguments back from call to emitvar
3097130934 printf("%s", ");");
3097230935 // call unscopelet from initfrom
30973- stack[base + 33LLU] = 2558LLU/*throw to this address*/;
30974- stack[base + 34LLU] = base;
30975- stack[base + 35LLU] = 2559LLU;
30936+ stack[base + 34LLU] = 2554LLU/*throw to this address*/;
30937+ stack[base + 35LLU] = base;
30938+ stack[base + 36LLU] = 2555LLU;
3097630939 // arguments for call to unscopelet
30977- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
30978- stack[base + 37LLU] = stack[base + 5]/*scope*/;
30979- stack[base + 38LLU] = stack[base + 11]/*content*/;
30940+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
30941+ stack[base + 38LLU] = stack[base + 6]/*scope*/;
30942+ stack[base + 39LLU] = stack[base + 13]/*content*/;
3098030943 // set stack-base & callee-address
30981- base += 36LLU;
30944+ base += 37LLU;
3098230945 label = 761LLU; // unscopelet
3098330946 break;
3098430947 }
30985- case 2558LLU: // copy-back deleter (unscopelet to initfrom)
30948+ case 2554LLU: // copy-back deleter (unscopelet to initfrom)
3098630949 {
3098730950 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3098830951 // copy mutable arguments back from call to unscopelet
30989- stack[base + 5]/*scope*/ = stack[base + 37LLU];
30990- label = 2512LLU; // continue to roll stack
30952+ stack[base + 6]/*scope*/ = stack[base + 38LLU];
30953+ label = 2508LLU; // continue to roll stack
3099130954 break;
3099230955 }
30993- case 2559LLU: // return from unscopelet to initfrom
30956+ case 2555LLU: // return from unscopelet to initfrom
3099430957 {
3099530958 // copy mutable arguments back from call to unscopelet
30996- stack[base + 5]/*scope*/ = stack[base + 37LLU];
30997- label = 2531LLU; // default complete
30959+ stack[base + 6]/*scope*/ = stack[base + 38LLU];
30960+ label = 2527LLU; // default complete
3099830961 break;
3099930962 }
31000- case 2531LLU: // completed switch
30963+ case 2527LLU: // completed switch
3100130964 {
31002- label = 2530LLU; // consequent complete
30965+ label = 2526LLU; // consequent complete
3100330966 break;
3100430967 }
31005- case 2529LLU: // alternative
30968+ case 2525LLU: // alternative
3100630969 {
3100730970 fprintf(stderr, "%s", "in function ");
3100830971 // call reportid from initfrom
31009- stack[base + 33LLU] = 2560LLU/*throw to this address*/;
31010- stack[base + 34LLU] = base;
31011- stack[base + 35LLU] = 2561LLU;
30972+ stack[base + 34LLU] = 2556LLU/*throw to this address*/;
30973+ stack[base + 35LLU] = base;
30974+ stack[base + 36LLU] = 2557LLU;
3101230975 // arguments for call to reportid
31013- stack[base + 36LLU] = stack[base + 0]/*fnid*/;
30976+ stack[base + 37LLU] = stack[base + 0]/*fnid*/;
3101430977 // set stack-base & callee-address
31015- base += 36LLU;
30978+ base += 37LLU;
3101630979 label = 18446744073709551586LLU; // reportid
3101730980 break;
3101830981 }
31019- case 2560LLU: // copy-back deleter (reportid to initfrom)
30982+ case 2556LLU: // copy-back deleter (reportid to initfrom)
3102030983 {
3102130984 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3102230985 // copy mutable arguments back from call to reportid
31023- label = 2512LLU; // continue to roll stack
30986+ label = 2508LLU; // continue to roll stack
3102430987 break;
3102530988 }
31026- case 2561LLU: // return from reportid to initfrom
30989+ case 2557LLU: // return from reportid to initfrom
3102730990 {
3102830991 // copy mutable arguments back from call to reportid
3102930992 fprintf(stderr, "%s", ": constructor of type ");
@@ -31030,7 +30993,7 @@
3103030993 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3103130994 if(!newstack)
3103230995 {
31033- label = 2512LLU; // throw: begin to unroll stack
30996+ label = 2508LLU; // throw: begin to unroll stack
3103430997 break;
3103530998 }
3103630999
@@ -31037,11 +31000,11 @@
3103731000 newstack[10LLU] = 9876543210LLU; // overflow-marker
3103831001 // call reporttype from initfrom
3103931002 newstack[0] = (uint64_t)stack; // backup stack location
31040- newstack[1] = 2562LLU;
31003+ newstack[1] = 2558LLU;
3104131004 newstack[2] = base;
31042- newstack[3] = 2563LLU;
31005+ newstack[3] = 2559LLU;
3104331006 // arguments for call to reporttype
31044- newstack[4LLU] = stack[base + 30]/*dsttype*/;
31007+ newstack[4LLU] = stack[base + 31]/*dsttype*/;
3104531008 stack = newstack;
3104631009 // set stack-base & callee-address
3104731010 base = 4/*deloffset*/;
@@ -31048,7 +31011,7 @@
3104831011 label = 316LLU; // reporttype
3104931012 break;
3105031013 }
31051- case 2562LLU: // copy-back deleter (reporttype to initfrom)
31014+ case 2558LLU: // copy-back deleter (reporttype to initfrom)
3105231015 {
3105331016 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3105431017 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31060,10 +31023,10 @@
3106031023 }
3106131024 Free(10LLU + 1, sizeof(uint64_t), stack);
3106231025 stack = oldstack;
31063- label = 2512LLU; // continue to unroll stack
31026+ label = 2508LLU; // continue to unroll stack
3106431027 break;
3106531028 }
31066- case 2563LLU: // return from reporttype to initfrom
31029+ case 2559LLU: // return from reporttype to initfrom
3106731030 {
3106831031 uint64_t *oldstack = (uint64_t *)stack[0];
3106931032 // copy mutable arguments back from call to reporttype
@@ -31078,7 +31041,7 @@
3107831041 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3107931042 if(!newstack)
3108031043 {
31081- label = 2512LLU; // throw: begin to unroll stack
31044+ label = 2508LLU; // throw: begin to unroll stack
3108231045 break;
3108331046 }
3108431047
@@ -31085,11 +31048,11 @@
3108531048 newstack[10LLU] = 9876543210LLU; // overflow-marker
3108631049 // call reporttype from initfrom
3108731050 newstack[0] = (uint64_t)stack; // backup stack location
31088- newstack[1] = 2564LLU;
31051+ newstack[1] = 2560LLU;
3108931052 newstack[2] = base;
31090- newstack[3] = 2565LLU;
31053+ newstack[3] = 2561LLU;
3109131054 // arguments for call to reporttype
31092- newstack[4LLU] = stack[base + 30]/*dsttype*/;
31055+ newstack[4LLU] = stack[base + 31]/*dsttype*/;
3109331056 stack = newstack;
3109431057 // set stack-base & callee-address
3109531058 base = 4/*deloffset*/;
@@ -31096,7 +31059,7 @@
3109631059 label = 316LLU; // reporttype
3109731060 break;
3109831061 }
31099- case 2564LLU: // copy-back deleter (reporttype to initfrom)
31062+ case 2560LLU: // copy-back deleter (reporttype to initfrom)
3110031063 {
3110131064 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3110231065 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31108,10 +31071,10 @@
3110831071 }
3110931072 Free(10LLU + 1, sizeof(uint64_t), stack);
3111031073 stack = oldstack;
31111- label = 2512LLU; // continue to unroll stack
31074+ label = 2508LLU; // continue to unroll stack
3111231075 break;
3111331076 }
31114- case 2565LLU: // return from reporttype to initfrom
31077+ case 2561LLU: // return from reporttype to initfrom
3111531078 {
3111631079 uint64_t *oldstack = (uint64_t *)stack[0];
3111731080 // copy mutable arguments back from call to reporttype
@@ -31126,7 +31089,7 @@
3112631089 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3112731090 if(!newstack)
3112831091 {
31129- label = 2512LLU; // throw: begin to unroll stack
31092+ label = 2508LLU; // throw: begin to unroll stack
3113031093 break;
3113131094 }
3113231095
@@ -31133,11 +31096,11 @@
3113331096 newstack[10LLU] = 9876543210LLU; // overflow-marker
3113431097 // call reporttype from initfrom
3113531098 newstack[0] = (uint64_t)stack; // backup stack location
31136- newstack[1] = 2566LLU;
31099+ newstack[1] = 2562LLU;
3113731100 newstack[2] = base;
31138- newstack[3] = 2567LLU;
31101+ newstack[3] = 2563LLU;
3113931102 // arguments for call to reporttype
31140- newstack[4LLU] = stack[base + 32]/*srctype*/;
31103+ newstack[4LLU] = stack[base + 33]/*srctype*/;
3114131104 stack = newstack;
3114231105 // set stack-base & callee-address
3114331106 base = 4/*deloffset*/;
@@ -31144,7 +31107,7 @@
3114431107 label = 316LLU; // reporttype
3114531108 break;
3114631109 }
31147- case 2566LLU: // copy-back deleter (reporttype to initfrom)
31110+ case 2562LLU: // copy-back deleter (reporttype to initfrom)
3114831111 {
3114931112 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3115031113 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31156,10 +31119,10 @@
3115631119 }
3115731120 Free(10LLU + 1, sizeof(uint64_t), stack);
3115831121 stack = oldstack;
31159- label = 2512LLU; // continue to unroll stack
31122+ label = 2508LLU; // continue to unroll stack
3116031123 break;
3116131124 }
31162- case 2567LLU: // return from reporttype to initfrom
31125+ case 2563LLU: // return from reporttype to initfrom
3116331126 {
3116431127 uint64_t *oldstack = (uint64_t *)stack[0];
3116531128 // copy mutable arguments back from call to reporttype
@@ -31172,40 +31135,40 @@
3117231135 stack = oldstack;
3117331136 fprintf(stderr, "%s", " ");
3117431137 // call reportid from initfrom
31175- stack[base + 33LLU] = 2568LLU/*throw to this address*/;
31176- stack[base + 34LLU] = base;
31177- stack[base + 35LLU] = 2569LLU;
31138+ stack[base + 34LLU] = 2564LLU/*throw to this address*/;
31139+ stack[base + 35LLU] = base;
31140+ stack[base + 36LLU] = 2565LLU;
3117831141 // arguments for call to reportid
31179- stack[base + 36LLU] = stack[base + 11]/*content*/;
31142+ stack[base + 37LLU] = stack[base + 13]/*content*/;
3118031143 // set stack-base & callee-address
31181- base += 36LLU;
31144+ base += 37LLU;
3118231145 label = 18446744073709551586LLU; // reportid
3118331146 break;
3118431147 }
31185- case 2568LLU: // copy-back deleter (reportid to initfrom)
31148+ case 2564LLU: // copy-back deleter (reportid to initfrom)
3118631149 {
3118731150 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3118831151 // copy mutable arguments back from call to reportid
31189- label = 2512LLU; // continue to roll stack
31152+ label = 2508LLU; // continue to roll stack
3119031153 break;
3119131154 }
31192- case 2569LLU: // return from reportid to initfrom
31155+ case 2565LLU: // return from reportid to initfrom
3119331156 {
3119431157 // copy mutable arguments back from call to reportid
3119531158 fprintf(stderr, "%s", "\n");
3119631159 exit(-1);
31197- label = 2530LLU; // alternative complete
31160+ label = 2526LLU; // alternative complete
3119831161 break;
3119931162 }
31200- case 2530LLU: // completed if-then-else
31163+ case 2526LLU: // completed if-then-else
3120131164 {
3120231165
31203- uint64_t *newstack = (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 4);
31166+ uint64_t *newstack = (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4);
3120431167 // call ~type from initfrom
3120531168 newstack[0] = (uint64_t)stack; // backup stack location
3120631169 newstack[1] = 1234567890;
3120731170 newstack[2] = base;
31208- newstack[3] = 2570LLU;
31171+ newstack[3] = 2566LLU;
3120931172 stack = newstack;
3121031173 // set stack-base & callee-address
3121131174 base = 4/*deloffset*/;
@@ -31212,118 +31175,118 @@
3121231175 label = 296LLU; // ~type
3121331176 break;
3121431177 }
31215- case 2570LLU: // return from ~type to initfrom
31178+ case 2566LLU: // return from ~type to initfrom
3121631179 {
3121731180 stack = (uint64_t *)stack[0];
3121831181 // releasing toplevel container
31219- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 4));
31182+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4));
3122031183
31221- ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
31222- ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
31223- label = 2510LLU; // case complete
31184+ ((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
31185+ ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31186+ label = 2506LLU; // case complete
3122431187 break;
3122531188 }
31226- case 2512LLU: // copy-back deleter (switch)
31189+ case 2508LLU: // copy-back deleter (switch)
3122731190 {
31228- ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
31229- ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
31230- label = 2509LLU; // continue to unroll stack
31191+ ((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
31192+ ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31193+ label = 2505LLU; // continue to unroll stack
3123131194 break;
3123231195 }
31233- case 2511LLU: // try next case
31196+ case 2507LLU: // try next case
3123431197 {
3123531198 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3123631199 exit(-1);
3123731200 }
31238- case 2510LLU: // completed switch
31201+ case 2506LLU: // completed switch
3123931202 {
3124031203 // call add from initfrom
31241- stack[base + 30LLU] = 2571LLU/*throw to this address*/;
31242- stack[base + 31LLU] = base;
31243- stack[base + 32LLU] = 2572LLU;
31204+ stack[base + 31LLU] = 2567LLU/*throw to this address*/;
31205+ stack[base + 32LLU] = base;
31206+ stack[base + 33LLU] = 2568LLU;
3124431207 // arguments for call to add
31245- stack[base + 34LLU] = stack[base + 26]/*elemindex*/;
31246- stack[base + 35LLU] = 1LLU;
31208+ stack[base + 35LLU] = stack[base + 27]/*elemindex*/;
31209+ stack[base + 36LLU] = 1LLU;
3124731210 // set stack-base & callee-address
31248- base += 33LLU;
31211+ base += 34LLU;
3124931212 label = 18446744073709551605LLU; // add
3125031213 break;
3125131214 }
31252- case 2571LLU: // copy-back deleter (add to initfrom)
31215+ case 2567LLU: // copy-back deleter (add to initfrom)
3125331216 {
3125431217 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
3125531218 // copy mutable arguments back from call to add
31256- label = 2509LLU; // continue to roll stack
31219+ label = 2505LLU; // continue to roll stack
3125731220 break;
3125831221 }
31259- case 2572LLU: // return from add to initfrom
31222+ case 2568LLU: // return from add to initfrom
3126031223 {
3126131224 // copy mutable arguments back from call to add
3126231225 // copy back results provided by call to add
31263- stack[base + 26] = stack[base + 33LLU];
31264- ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
31265- label = 2507LLU; // repeat
31226+ stack[base + 27] = stack[base + 34LLU];
31227+ ((struct listnode *)(stack[base + 30]/*previous*/))->data = stack[base + 29];
31228+ label = 2503LLU; // repeat
3126631229 break;
3126731230 }
31268- case 2509LLU: // copy-back deleter for while next
31231+ case 2505LLU: // copy-back deleter for while next
3126931232 {
31270- ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
31271- label = 2505LLU; // continue to unroll stack
31233+ ((struct listnode *)(stack[base + 30]/*previous*/))->data = stack[base + 29];
31234+ label = 2501LLU; // continue to unroll stack
3127231235 break;
3127331236 }
31274- case 2508LLU: // loop finished
31237+ case 2504LLU: // loop finished
3127531238 {
3127631239 // call matchsym from initfrom
31277- stack[base + 30LLU] = 2573LLU/*throw to this address*/;
31278- stack[base + 31LLU] = base;
31279- stack[base + 32LLU] = 2574LLU;
31240+ stack[base + 31LLU] = 2569LLU/*throw to this address*/;
31241+ stack[base + 32LLU] = base;
31242+ stack[base + 33LLU] = 2570LLU;
3128031243 // arguments for call to matchsym
31281- stack[base + 33LLU] = stack[base + 0]/*fnid*/;
31282- stack[base + 34LLU] = 41LLU;
31283- stack[base + 35LLU] = stack[base + 6]/*lookahead*/;
31244+ stack[base + 34LLU] = stack[base + 0]/*fnid*/;
31245+ stack[base + 35LLU] = 41LLU;
31246+ stack[base + 36LLU] = stack[base + 7]/*lookahead*/;
3128431247 // set stack-base & callee-address
31285- base += 33LLU;
31248+ base += 34LLU;
3128631249 label = 212LLU; // matchsym
3128731250 break;
3128831251 }
31289- case 2573LLU: // copy-back deleter (matchsym to initfrom)
31252+ case 2569LLU: // copy-back deleter (matchsym to initfrom)
3129031253 {
3129131254 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3129231255 // copy mutable arguments back from call to matchsym
31293- stack[base + 6]/*lookahead*/ = stack[base + 35LLU];
31294- label = 2505LLU; // continue to roll stack
31256+ stack[base + 7]/*lookahead*/ = stack[base + 36LLU];
31257+ label = 2501LLU; // continue to roll stack
3129531258 break;
3129631259 }
31297- case 2574LLU: // return from matchsym to initfrom
31260+ case 2570LLU: // return from matchsym to initfrom
3129831261 {
3129931262 // copy mutable arguments back from call to matchsym
31300- stack[base + 6]/*lookahead*/ = stack[base + 35LLU];
31301- ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
31302- ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
31303- label = 2482LLU; // case complete
31263+ stack[base + 7]/*lookahead*/ = stack[base + 36LLU];
31264+ ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
31265+ ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31266+ label = 2478LLU; // case complete
3130431267 break;
3130531268 }
31306- case 2484LLU: // copy-back deleter (switch)
31269+ case 2480LLU: // copy-back deleter (switch)
3130731270 {
31308- ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
31309- ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
31310- label = 2479LLU; // continue to unroll stack
31271+ ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
31272+ ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31273+ label = 2475LLU; // continue to unroll stack
3131131274 break;
3131231275 }
31313- case 2483LLU: // try next case
31276+ case 2479LLU: // try next case
3131431277 {
3131531278 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3131631279 exit(-1);
3131731280 }
31318- case 2482LLU: // completed switch
31281+ case 2478LLU: // completed switch
3131931282 {
3132031283
31321- uint64_t *newstack = (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4);
31284+ uint64_t *newstack = (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4);
3132231285 // call ~variant from initfrom
3132331286 newstack[0] = (uint64_t)stack; // backup stack location
3132431287 newstack[1] = 1234567890;
3132531288 newstack[2] = base;
31326- newstack[3] = 2575LLU;
31289+ newstack[3] = 2571LLU;
3132731290 stack = newstack;
3132831291 // set stack-base & callee-address
3132931292 base = 4/*deloffset*/;
@@ -31330,40 +31293,40 @@
3133031293 label = 870LLU; // ~variant
3133131294 break;
3133231295 }
31333- case 2575LLU: // return from ~variant to initfrom
31296+ case 2571LLU: // return from ~variant to initfrom
3133431297 {
3133531298 stack = (uint64_t *)stack[0];
3133631299 // releasing toplevel container
31337- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
31300+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4));
3133831301
31339- ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
31340- ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
31341- ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31342- label = 2477LLU; // case complete
31302+ ((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
31303+ ((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
31304+ ((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31305+ label = 2473LLU; // case complete
3134331306 break;
3134431307 }
31345- case 2479LLU: // copy-back deleter (switch)
31308+ case 2475LLU: // copy-back deleter (switch)
3134631309 {
31347- ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
31348- ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
31349- ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31350- label = 2464LLU; // continue to unroll stack
31310+ ((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
31311+ ((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
31312+ ((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31313+ label = 2460LLU; // continue to unroll stack
3135131314 break;
3135231315 }
31353- case 2478LLU: // try next case
31316+ case 2474LLU: // try next case
3135431317 {
3135531318 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3135631319 exit(-1);
3135731320 }
31358- case 2477LLU: // completed switch
31321+ case 2473LLU: // completed switch
3135931322 {
3136031323
31361- uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
31324+ uint64_t *newstack = (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4);
3136231325 // call ~datadef from initfrom
3136331326 newstack[0] = (uint64_t)stack; // backup stack location
3136431327 newstack[1] = 1234567890;
3136531328 newstack[2] = base;
31366- newstack[3] = 2576LLU;
31329+ newstack[3] = 2572LLU;
3136731330 stack = newstack;
3136831331 // set stack-base & callee-address
3136931332 base = 4/*deloffset*/;
@@ -31370,45 +31333,45 @@
3137031333 label = 945LLU; // ~datadef
3137131334 break;
3137231335 }
31373- case 2576LLU: // return from ~datadef to initfrom
31336+ case 2572LLU: // return from ~datadef to initfrom
3137431337 {
3137531338 stack = (uint64_t *)stack[0];
3137631339 // releasing toplevel container
31377- Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
31340+ Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
3137831341
31379- ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 16];
31380- label = 2462LLU; // case complete
31342+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31343+ label = 2458LLU; // case complete
3138131344 break;
3138231345 }
31383- case 2464LLU: // copy-back deleter (switch)
31346+ case 2460LLU: // copy-back deleter (switch)
3138431347 {
31385- ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 16];
31386- label = 2263LLU; // continue to unroll stack
31348+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31349+ label = 2259LLU; // continue to unroll stack
3138731350 break;
3138831351 }
31389- case 2463LLU: // try next case
31352+ case 2459LLU: // try next case
3139031353 {
3139131354 // default
3139231355 fprintf(stderr, "%s", "in function ");
3139331356 // call reportid from initfrom
31394- stack[base + 16LLU] = 2577LLU/*throw to this address*/;
31395- stack[base + 17LLU] = base;
31396- stack[base + 18LLU] = 2578LLU;
31357+ stack[base + 17LLU] = 2573LLU/*throw to this address*/;
31358+ stack[base + 18LLU] = base;
31359+ stack[base + 19LLU] = 2574LLU;
3139731360 // arguments for call to reportid
31398- stack[base + 19LLU] = stack[base + 0]/*fnid*/;
31361+ stack[base + 20LLU] = stack[base + 0]/*fnid*/;
3139931362 // set stack-base & callee-address
31400- base += 19LLU;
31363+ base += 20LLU;
3140131364 label = 18446744073709551586LLU; // reportid
3140231365 break;
3140331366 }
31404- case 2577LLU: // copy-back deleter (reportid to initfrom)
31367+ case 2573LLU: // copy-back deleter (reportid to initfrom)
3140531368 {
3140631369 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3140731370 // copy mutable arguments back from call to reportid
31408- label = 2263LLU; // continue to roll stack
31371+ label = 2259LLU; // continue to roll stack
3140931372 break;
3141031373 }
31411- case 2578LLU: // return from reportid to initfrom
31374+ case 2574LLU: // return from reportid to initfrom
3141231375 {
3141331376 // copy mutable arguments back from call to reportid
3141431377 fprintf(stderr, "%s", ": type ");
@@ -31415,7 +31378,7 @@
3141531378 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3141631379 if(!newstack)
3141731380 {
31418- label = 2263LLU; // throw: begin to unroll stack
31381+ label = 2259LLU; // throw: begin to unroll stack
3141931382 break;
3142031383 }
3142131384
@@ -31422,9 +31385,9 @@
3142231385 newstack[10LLU] = 9876543210LLU; // overflow-marker
3142331386 // call reporttype from initfrom
3142431387 newstack[0] = (uint64_t)stack; // backup stack location
31425- newstack[1] = 2579LLU;
31388+ newstack[1] = 2575LLU;
3142631389 newstack[2] = base;
31427- newstack[3] = 2580LLU;
31390+ newstack[3] = 2576LLU;
3142831391 // arguments for call to reporttype
3142931392 newstack[4LLU] = stack[base + 1]/*dsttype*/;
3143031393 stack = newstack;
@@ -31433,7 +31396,7 @@
3143331396 label = 316LLU; // reporttype
3143431397 break;
3143531398 }
31436- case 2579LLU: // copy-back deleter (reporttype to initfrom)
31399+ case 2575LLU: // copy-back deleter (reporttype to initfrom)
3143731400 {
3143831401 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3143931402 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31445,10 +31408,10 @@
3144531408 }
3144631409 Free(10LLU + 1, sizeof(uint64_t), stack);
3144731410 stack = oldstack;
31448- label = 2263LLU; // continue to unroll stack
31411+ label = 2259LLU; // continue to unroll stack
3144931412 break;
3145031413 }
31451- case 2580LLU: // return from reporttype to initfrom
31414+ case 2576LLU: // return from reporttype to initfrom
3145231415 {
3145331416 uint64_t *oldstack = (uint64_t *)stack[0];
3145431417 // copy mutable arguments back from call to reporttype
@@ -31461,100 +31424,100 @@
3146131424 stack = oldstack;
3146231425 fprintf(stderr, "%s", " has no constructor ");
3146331426 // call reportid from initfrom
31464- stack[base + 16LLU] = 2581LLU/*throw to this address*/;
31465- stack[base + 17LLU] = base;
31466- stack[base + 18LLU] = 2582LLU;
31427+ stack[base + 17LLU] = 2577LLU/*throw to this address*/;
31428+ stack[base + 18LLU] = base;
31429+ stack[base + 19LLU] = 2578LLU;
3146731430 // arguments for call to reportid
31468- stack[base + 19LLU] = stack[base + 11]/*content*/;
31431+ stack[base + 20LLU] = stack[base + 13]/*content*/;
3146931432 // set stack-base & callee-address
31470- base += 19LLU;
31433+ base += 20LLU;
3147131434 label = 18446744073709551586LLU; // reportid
3147231435 break;
3147331436 }
31474- case 2581LLU: // copy-back deleter (reportid to initfrom)
31437+ case 2577LLU: // copy-back deleter (reportid to initfrom)
3147531438 {
3147631439 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3147731440 // copy mutable arguments back from call to reportid
31478- label = 2263LLU; // continue to roll stack
31441+ label = 2259LLU; // continue to roll stack
3147931442 break;
3148031443 }
31481- case 2582LLU: // return from reportid to initfrom
31444+ case 2578LLU: // return from reportid to initfrom
3148231445 {
3148331446 // copy mutable arguments back from call to reportid
3148431447 fprintf(stderr, "%s", " - if you mean call enclose type and variable-name in perentheses\n");
3148531448 exit(-1);
31486- label = 2462LLU; // default complete
31449+ label = 2458LLU; // default complete
3148731450 break;
3148831451 }
31489- case 2462LLU: // completed switch
31452+ case 2458LLU: // completed switch
3149031453 {
31491- label = 2461LLU; // consequent complete
31454+ label = 2457LLU; // consequent complete
3149231455 break;
3149331456 }
31494- case 2460LLU: // alternative
31457+ case 2456LLU: // alternative
3149531458 {
3149631459 // call getlettype from initfrom
31497- stack[base + 17LLU] = 2583LLU/*throw to this address*/;
31498- stack[base + 18LLU] = base;
31499- stack[base + 19LLU] = 2584LLU;
31460+ stack[base + 18LLU] = 2579LLU/*throw to this address*/;
31461+ stack[base + 19LLU] = base;
31462+ stack[base + 20LLU] = 2580LLU;
3150031463 // arguments for call to getlettype
31501- stack[base + 21LLU] = stack[base + 0]/*fnid*/;
31502- stack[base + 22LLU] = stack[base + 11]/*content*/;
31503- stack[base + 23LLU] = stack[base + 4]/*scopes*/;
31504- stack[base + 24LLU] = stack[base + 5]/*scope*/;
31464+ stack[base + 22LLU] = stack[base + 0]/*fnid*/;
31465+ stack[base + 23LLU] = stack[base + 13]/*content*/;
31466+ stack[base + 24LLU] = stack[base + 5]/*scopes*/;
31467+ stack[base + 25LLU] = stack[base + 6]/*scope*/;
3150531468 // set stack-base & callee-address
31506- base += 20LLU;
31469+ base += 21LLU;
3150731470 label = 651LLU; // getlettype
3150831471 break;
3150931472 }
31510- case 2583LLU: // copy-back deleter (getlettype to initfrom)
31473+ case 2579LLU: // copy-back deleter (getlettype to initfrom)
3151131474 {
3151231475 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
3151331476 // copy mutable arguments back from call to getlettype
31514- label = 2263LLU; // continue to roll stack
31477+ label = 2259LLU; // continue to roll stack
3151531478 break;
3151631479 }
31517- case 2584LLU: // return from getlettype to initfrom
31480+ case 2580LLU: // return from getlettype to initfrom
3151831481 {
3151931482 // copy mutable arguments back from call to getlettype
3152031483 // copy back results provided by call to getlettype
31521- stack[base + 16] = stack[base + 20LLU];
31522- if(/*typename*/0 != ((uint64_t *)(stack[base + 16]/*dsttype*/))[0])
31484+ stack[base + 17] = stack[base + 21LLU];
31485+ if(/*typename*/0 != ((uint64_t *)(stack[base + 17]/*dsttype*/))[0])
3152331486 {
31524- label = 2586LLU; // jump to alternative
31487+ label = 2582LLU; // jump to alternative
3152531488 break;
3152631489 }
3152731490
31528- /*name*/stack[base + 17] = ((uint64_t **)(stack[base + 16]/*dsttype*/))[1][0]/*name*/;
31491+ /*name*/stack[base + 18] = ((uint64_t **)(stack[base + 17]/*dsttype*/))[1][0]/*name*/;
3152931492
3153031493 // case
3153131494 // call equ from initfrom
31532- stack[base + 18LLU] = 2588LLU/*throw to this address*/;
31533- stack[base + 19LLU] = base;
31534- stack[base + 20LLU] = 2589LLU;
31495+ stack[base + 19LLU] = 2584LLU/*throw to this address*/;
31496+ stack[base + 20LLU] = base;
31497+ stack[base + 21LLU] = 2585LLU;
3153531498 // arguments for call to equ
31536- stack[base + 22LLU] = stack[base + 17]/*name*/;
31537- stack[base + 23LLU] = 881834713755418624LLU;
31499+ stack[base + 23LLU] = stack[base + 18]/*name*/;
31500+ stack[base + 24LLU] = 881834713755418624LLU;
3153831501 // set stack-base & callee-address
31539- base += 21LLU;
31502+ base += 22LLU;
3154031503 label = 18446744073709551600LLU; // equ
3154131504 break;
3154231505 }
31543- case 2588LLU: // copy-back deleter (equ to initfrom)
31506+ case 2584LLU: // copy-back deleter (equ to initfrom)
3154431507 {
3154531508 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3154631509 // copy mutable arguments back from call to equ
31547- label = 2587LLU; // continue to roll stack
31510+ label = 2583LLU; // continue to roll stack
3154831511 break;
3154931512 }
31550- case 2589LLU: // return from equ to initfrom
31513+ case 2585LLU: // return from equ to initfrom
3155131514 {
3155231515 // copy mutable arguments back from call to equ
3155331516 // copy back results provided by call to equ
31554- stack[base + 9] = stack[base + 21LLU];
31555- if(!stack[base + 9]/*isequal*/)
31517+ stack[base + 10] = stack[base + 22LLU];
31518+ if(!stack[base + 10]/*isequal*/)
3155631519 {
31557- label = 2590LLU; // jump to alternative
31520+ label = 2586LLU; // jump to alternative
3155831521 break;
3155931522 }
3156031523
@@ -31561,233 +31524,233 @@
3156131524 // consequent
3156231525 printf("%s", "\n ");
3156331526 // call emitvaridx from initfrom
31564- stack[base + 18LLU] = 2592LLU/*throw to this address*/;
31565- stack[base + 19LLU] = base;
31566- stack[base + 20LLU] = 2593LLU;
31527+ stack[base + 19LLU] = 2588LLU/*throw to this address*/;
31528+ stack[base + 20LLU] = base;
31529+ stack[base + 21LLU] = 2589LLU;
3156731530 // arguments for call to emitvaridx
31568- stack[base + 21LLU] = stack[base + 2]/*dstindex*/;
31531+ stack[base + 22LLU] = stack[base + 3]/*dstindex*/;
3156931532 // set stack-base & callee-address
31570- base += 21LLU;
31533+ base += 22LLU;
3157131534 label = 691LLU; // emitvaridx
3157231535 break;
3157331536 }
31574- case 2592LLU: // copy-back deleter (emitvaridx to initfrom)
31537+ case 2588LLU: // copy-back deleter (emitvaridx to initfrom)
3157531538 {
3157631539 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3157731540 // copy mutable arguments back from call to emitvaridx
31578- label = 2587LLU; // continue to roll stack
31541+ label = 2583LLU; // continue to roll stack
3157931542 break;
3158031543 }
31581- case 2593LLU: // return from emitvaridx to initfrom
31544+ case 2589LLU: // return from emitvaridx to initfrom
3158231545 {
3158331546 // copy mutable arguments back from call to emitvaridx
3158431547 printf("%s", " = ");
3158531548 // call emitvar from initfrom
31586- stack[base + 18LLU] = 2594LLU/*throw to this address*/;
31587- stack[base + 19LLU] = base;
31588- stack[base + 20LLU] = 2595LLU;
31549+ stack[base + 19LLU] = 2590LLU/*throw to this address*/;
31550+ stack[base + 20LLU] = base;
31551+ stack[base + 21LLU] = 2591LLU;
3158931552 // arguments for call to emitvar
31590- stack[base + 21LLU] = stack[base + 0]/*fnid*/;
31591- stack[base + 22LLU] = stack[base + 11]/*content*/;
31592- stack[base + 23LLU] = stack[base + 4]/*scopes*/;
31593- stack[base + 24LLU] = stack[base + 5]/*scope*/;
31553+ stack[base + 22LLU] = stack[base + 0]/*fnid*/;
31554+ stack[base + 23LLU] = stack[base + 13]/*content*/;
31555+ stack[base + 24LLU] = stack[base + 5]/*scopes*/;
31556+ stack[base + 25LLU] = stack[base + 6]/*scope*/;
3159431557 // set stack-base & callee-address
31595- base += 21LLU;
31558+ base += 22LLU;
3159631559 label = 695LLU; // emitvar
3159731560 break;
3159831561 }
31599- case 2594LLU: // copy-back deleter (emitvar to initfrom)
31562+ case 2590LLU: // copy-back deleter (emitvar to initfrom)
3160031563 {
3160131564 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3160231565 // copy mutable arguments back from call to emitvar
31603- label = 2587LLU; // continue to roll stack
31566+ label = 2583LLU; // continue to roll stack
3160431567 break;
3160531568 }
31606- case 2595LLU: // return from emitvar to initfrom
31569+ case 2591LLU: // return from emitvar to initfrom
3160731570 {
3160831571 // copy mutable arguments back from call to emitvar
3160931572 printf("%s", ";");
31610- label = 2591LLU; // consequent complete
31573+ label = 2587LLU; // consequent complete
3161131574 break;
3161231575 }
31613- case 2590LLU: // alternative
31576+ case 2586LLU: // alternative
3161431577 {
3161531578 printf("%s", "\n INIT(&");
3161631579 // call emitvaridx from initfrom
31617- stack[base + 18LLU] = 2596LLU/*throw to this address*/;
31618- stack[base + 19LLU] = base;
31619- stack[base + 20LLU] = 2597LLU;
31580+ stack[base + 19LLU] = 2592LLU/*throw to this address*/;
31581+ stack[base + 20LLU] = base;
31582+ stack[base + 21LLU] = 2593LLU;
3162031583 // arguments for call to emitvaridx
31621- stack[base + 21LLU] = stack[base + 2]/*dstindex*/;
31584+ stack[base + 22LLU] = stack[base + 3]/*dstindex*/;
3162231585 // set stack-base & callee-address
31623- base += 21LLU;
31586+ base += 22LLU;
3162431587 label = 691LLU; // emitvaridx
3162531588 break;
3162631589 }
31627- case 2596LLU: // copy-back deleter (emitvaridx to initfrom)
31590+ case 2592LLU: // copy-back deleter (emitvaridx to initfrom)
3162831591 {
3162931592 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3163031593 // copy mutable arguments back from call to emitvaridx
31631- label = 2587LLU; // continue to roll stack
31594+ label = 2583LLU; // continue to roll stack
3163231595 break;
3163331596 }
31634- case 2597LLU: // return from emitvaridx to initfrom
31597+ case 2593LLU: // return from emitvaridx to initfrom
3163531598 {
3163631599 // copy mutable arguments back from call to emitvaridx
3163731600 printf("%s", ", &");
3163831601 // call emitvar from initfrom
31639- stack[base + 18LLU] = 2598LLU/*throw to this address*/;
31640- stack[base + 19LLU] = base;
31641- stack[base + 20LLU] = 2599LLU;
31602+ stack[base + 19LLU] = 2594LLU/*throw to this address*/;
31603+ stack[base + 20LLU] = base;
31604+ stack[base + 21LLU] = 2595LLU;
3164231605 // arguments for call to emitvar
31643- stack[base + 21LLU] = stack[base + 0]/*fnid*/;
31644- stack[base + 22LLU] = stack[base + 11]/*content*/;
31645- stack[base + 23LLU] = stack[base + 4]/*scopes*/;
31646- stack[base + 24LLU] = stack[base + 5]/*scope*/;
31606+ stack[base + 22LLU] = stack[base + 0]/*fnid*/;
31607+ stack[base + 23LLU] = stack[base + 13]/*content*/;
31608+ stack[base + 24LLU] = stack[base + 5]/*scopes*/;
31609+ stack[base + 25LLU] = stack[base + 6]/*scope*/;
3164731610 // set stack-base & callee-address
31648- base += 21LLU;
31611+ base += 22LLU;
3164931612 label = 695LLU; // emitvar
3165031613 break;
3165131614 }
31652- case 2598LLU: // copy-back deleter (emitvar to initfrom)
31615+ case 2594LLU: // copy-back deleter (emitvar to initfrom)
3165331616 {
3165431617 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3165531618 // copy mutable arguments back from call to emitvar
31656- label = 2587LLU; // continue to roll stack
31619+ label = 2583LLU; // continue to roll stack
3165731620 break;
3165831621 }