• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revisão1171 (tree)
Hora2021-02-24 07:30:28
Autorjakobthomsen

Mensagem de Log

cleanup

Mudança Sumário

Diff

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1170)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1171)
@@ -27413,160 +27413,129 @@
2741327413 base = stack[base - 2];
2741427414 break;
2741527415 }
27416- case 2254LLU: // function initfrom failed
27416+ case 2254LLU: // function emitdelete failed
2741727417 {
27418- fprintf(stderr, "function initfrom failed\n");
27418+ fprintf(stderr, "function emitdelete failed\n");
2741927419 label = stack[base - 3];
2742027420 base = stack[base - 2];
2742127421 break;
2742227422 }
27423- case 2253LLU: // initfrom
27423+ case 2253LLU: // emitdelete
2742427424 {
27425-//#define arg0 0
27426-//#define arg1 1
27427-//#define arg2 2
27428-//#define arg3 3
27429-//#define arg4 4
27430-//#define arg5 5
27431-//#define arg6 6
27432-//#define arg7 7
27433-//#define arg8 8
27434-//#define arg9 9
27435- label = 2256LLU; // skip deleter
27436- break;
27437- }
27438- case 2255LLU: // deleter
27439- {
27440- // throw from initfrom
27441- if(!stack[base + 10])
27442- {
27443- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
27444- label = 2254LLU; // skip, variable already deleted/unscoped
27445- break;
27446- }
27447- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 isequal\n");
27448- label = 2254LLU; // continue unrolling stack, delete next variable
27449- break;
27450- }
27451- case 2256LLU: // skipped deleter
27452- {
27453- stack[base + 10] = 0;
27454- // call add from initfrom
27455- stack[base + 11LLU] = 2257LLU/*throw to this address*/;
27456- stack[base + 12LLU] = base;
27457- stack[base + 13LLU] = 2258LLU;
27425+//#define res0 0
27426+//#define arg0 1
27427+//#define arg1 2
27428+//#define arg2 3
27429+//#define arg3 4
27430+//#define arg4 5
27431+//#define arg5 6
27432+//#define arg6 7
27433+ // call add from emitdelete
27434+ stack[base + 8LLU] = 2255LLU/*throw to this address*/;
27435+ stack[base + 9LLU] = base;
27436+ stack[base + 10LLU] = 2256LLU;
2745827437 // arguments for call to add
27459- stack[base + 15LLU] = 1LLU;
27460- stack[base + 16LLU] = stack[base + 8]/*label*/;
27438+ stack[base + 12LLU] = 1LLU;
27439+ stack[base + 13LLU] = stack[base + 7]/*label*/;
2746127440 // set stack-base & callee-address
27462- base += 14LLU;
27441+ base += 11LLU;
2746327442 label = 18446744073709551605LLU; // add
2746427443 break;
2746527444 }
27466- case 2257LLU: // copy-back deleter (add to initfrom)
27445+ case 2255LLU: // copy-back deleter (add to emitdelete)
2746727446 {
27468- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
27447+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (add to emitdelete)\n");
2746927448 // copy mutable arguments back from call to add
27470- label = 2255LLU; // continue to roll stack
27449+ label = 2254LLU; // continue to roll stack
2747127450 break;
2747227451 }
27473- case 2258LLU: // return from add to initfrom
27452+ case 2256LLU: // return from add to emitdelete
2747427453 {
2747527454 // copy mutable arguments back from call to add
2747627455 // copy back results provided by call to add
27477- stack[base + 8] = stack[base + 14LLU];
27478- label = 2260LLU; // skip deleter
27456+ stack[base + 7] = stack[base + 11LLU];
27457+ label = 2258LLU; // skip deleter
2747927458 break;
2748027459 }
27481- case 2259LLU: // deleter
27460+ case 2257LLU: // deleter
2748227461 {
27483- // throw from initfrom
27484- if(!stack[base + 11])
27462+ // throw from emitdelete
27463+ if(!stack[base + 8])
2748527464 {
27486- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
27487- label = 2255LLU; // skip, variable already deleted/unscoped
27465+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
27466+ label = 2254LLU; // skip, variable already deleted/unscoped
2748827467 break;
2748927468 }
27490- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelfail\n");
27491- label = 2255LLU; // continue unrolling stack, delete next variable
27469+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 labelfail\n");
27470+ label = 2254LLU; // continue unrolling stack, delete next variable
2749227471 break;
2749327472 }
27494- case 2260LLU: // skipped deleter
27473+ case 2258LLU: // skipped deleter
2749527474 {
27496- stack[base + 11] = stack[base + 8]/*label*/;
27497- if(/*scope*/0 != ((uint64_t *)(stack[base + 6]/*scope*/))[0])
27498- {
27499- label = 2262LLU; // jump to alternative
27500- break;
27501- }
27502-
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*/;
27505-
27506- // case
27507- // call add from initfrom
27508- stack[base + 14LLU] = 2264LLU/*throw to this address*/;
27509- stack[base + 15LLU] = base;
27510- stack[base + 16LLU] = 2265LLU;
27475+ stack[base + 8] = stack[base + 7]/*label*/;
27476+ // call add from emitdelete
27477+ stack[base + 9LLU] = 2259LLU/*throw to this address*/;
27478+ stack[base + 10LLU] = base;
27479+ stack[base + 11LLU] = 2260LLU;
2751127480 // arguments for call to add
27512- stack[base + 18LLU] = 1LLU;
27513- stack[base + 19LLU] = stack[base + 8]/*label*/;
27481+ stack[base + 13LLU] = 1LLU;
27482+ stack[base + 14LLU] = stack[base + 7]/*label*/;
2751427483 // set stack-base & callee-address
27515- base += 17LLU;
27484+ base += 12LLU;
2751627485 label = 18446744073709551605LLU; // add
2751727486 break;
2751827487 }
27519- case 2264LLU: // copy-back deleter (add to initfrom)
27488+ case 2259LLU: // copy-back deleter (add to emitdelete)
2752027489 {
27521- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
27490+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (add to emitdelete)\n");
2752227491 // copy mutable arguments back from call to add
27523- label = 2263LLU; // continue to roll stack
27492+ label = 2257LLU; // continue to roll stack
2752427493 break;
2752527494 }
27526- case 2265LLU: // return from add to initfrom
27495+ case 2260LLU: // return from add to emitdelete
2752727496 {
2752827497 // copy mutable arguments back from call to add
2752927498 // copy back results provided by call to add
27530- stack[base + 8] = stack[base + 17LLU];
27531- label = 2267LLU; // skip deleter
27499+ stack[base + 7] = stack[base + 12LLU];
27500+ label = 2262LLU; // skip deleter
2753227501 break;
2753327502 }
27534- case 2266LLU: // deleter
27503+ case 2261LLU: // deleter
2753527504 {
27536- // throw from initfrom
27537- if(!stack[base + 14])
27505+ // throw from emitdelete
27506+ if(!stack[base + 9])
2753827507 {
27539- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
27540- label = 2263LLU; // skip, variable already deleted/unscoped
27508+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
27509+ label = 2257LLU; // skip, variable already deleted/unscoped
2754127510 break;
2754227511 }
27543- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelskip\n");
27544- label = 2263LLU; // continue unrolling stack, delete next variable
27512+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 labelskip\n");
27513+ label = 2257LLU; // continue unrolling stack, delete next variable
2754527514 break;
2754627515 }
27547- case 2267LLU: // skipped deleter
27516+ case 2262LLU: // skipped deleter
2754827517 {
27549- stack[base + 14] = stack[base + 8]/*label*/;
27518+ stack[base + 9] = stack[base + 7]/*label*/;
2755027519 printf("%s", "\n label = ");
27551- // call printnr from initfrom
27552- stack[base + 15LLU] = 2268LLU/*throw to this address*/;
27553- stack[base + 16LLU] = base;
27554- stack[base + 17LLU] = 2269LLU;
27520+ // call printnr from emitdelete
27521+ stack[base + 10LLU] = 2263LLU/*throw to this address*/;
27522+ stack[base + 11LLU] = base;
27523+ stack[base + 12LLU] = 2264LLU;
2755527524 // arguments for call to printnr
27556- stack[base + 18LLU] = stack[base + 14]/*labelskip*/;
27525+ stack[base + 13LLU] = stack[base + 9]/*labelskip*/;
2755727526 // set stack-base & callee-address
27558- base += 18LLU;
27527+ base += 13LLU;
2755927528 label = 18446744073709551590LLU; // printnr
2756027529 break;
2756127530 }
27562- case 2268LLU: // copy-back deleter (printnr to initfrom)
27531+ case 2263LLU: // copy-back deleter (printnr to emitdelete)
2756327532 {
27564- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27533+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
2756527534 // copy mutable arguments back from call to printnr
27566- label = 2266LLU; // continue to roll stack
27535+ label = 2261LLU; // continue to roll stack
2756727536 break;
2756827537 }
27569- case 2269LLU: // return from printnr to initfrom
27538+ case 2264LLU: // return from printnr to emitdelete
2757027539 {
2757127540 // copy mutable arguments back from call to printnr
2757227541 printf("%s", "LLU; // skip deleter");
@@ -27573,95 +27542,95 @@
2757327542 printf("%s", "\n break;");
2757427543 printf("%s", "\n }");
2757527544 printf("%s", "\n case ");
27576- // call printnr from initfrom
27577- stack[base + 15LLU] = 2270LLU/*throw to this address*/;
27578- stack[base + 16LLU] = base;
27579- stack[base + 17LLU] = 2271LLU;
27545+ // call printnr from emitdelete
27546+ stack[base + 10LLU] = 2265LLU/*throw to this address*/;
27547+ stack[base + 11LLU] = base;
27548+ stack[base + 12LLU] = 2266LLU;
2758027549 // arguments for call to printnr
27581- stack[base + 18LLU] = stack[base + 11]/*labelfail*/;
27550+ stack[base + 13LLU] = stack[base + 8]/*labelfail*/;
2758227551 // set stack-base & callee-address
27583- base += 18LLU;
27552+ base += 13LLU;
2758427553 label = 18446744073709551590LLU; // printnr
2758527554 break;
2758627555 }
27587- case 2270LLU: // copy-back deleter (printnr to initfrom)
27556+ case 2265LLU: // copy-back deleter (printnr to emitdelete)
2758827557 {
27589- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27558+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
2759027559 // copy mutable arguments back from call to printnr
27591- label = 2266LLU; // continue to roll stack
27560+ label = 2261LLU; // continue to roll stack
2759227561 break;
2759327562 }
27594- case 2271LLU: // return from printnr to initfrom
27563+ case 2266LLU: // return from printnr to emitdelete
2759527564 {
2759627565 // copy mutable arguments back from call to printnr
2759727566 printf("%s", "LLU: // deleter");
2759827567 printf("%s", "\n {");
2759927568 printf("%s", "\n // throw from ");
27600- // call printid from initfrom
27601- stack[base + 15LLU] = 2272LLU/*throw to this address*/;
27602- stack[base + 16LLU] = base;
27603- stack[base + 17LLU] = 2273LLU;
27569+ // call printid from emitdelete
27570+ stack[base + 10LLU] = 2267LLU/*throw to this address*/;
27571+ stack[base + 11LLU] = base;
27572+ stack[base + 12LLU] = 2268LLU;
2760427573 // arguments for call to printid
27605- stack[base + 18LLU] = stack[base + 0]/*fnid*/;
27574+ stack[base + 13LLU] = stack[base + 1]/*fnid*/;
2760627575 // set stack-base & callee-address
27607- base += 18LLU;
27576+ base += 13LLU;
2760827577 label = 18446744073709551587LLU; // printid
2760927578 break;
2761027579 }
27611- case 2272LLU: // copy-back deleter (printid to initfrom)
27580+ case 2267LLU: // copy-back deleter (printid to emitdelete)
2761227581 {
27613- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27582+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
2761427583 // copy mutable arguments back from call to printid
27615- label = 2266LLU; // continue to roll stack
27584+ label = 2261LLU; // continue to roll stack
2761627585 break;
2761727586 }
27618- case 2273LLU: // return from printid to initfrom
27587+ case 2268LLU: // return from printid to emitdelete
2761927588 {
2762027589 // copy mutable arguments back from call to printid
2762127590 printf("%s", "\n if(!");
27622- // call emitvaridx from initfrom
27623- stack[base + 15LLU] = 2274LLU/*throw to this address*/;
27624- stack[base + 16LLU] = base;
27625- stack[base + 17LLU] = 2275LLU;
27591+ // call emitvaridx from emitdelete
27592+ stack[base + 10LLU] = 2269LLU/*throw to this address*/;
27593+ stack[base + 11LLU] = base;
27594+ stack[base + 12LLU] = 2270LLU;
2762627595 // arguments for call to emitvaridx
27627- stack[base + 18LLU] = stack[base + 3]/*dstindex*/;
27596+ stack[base + 13LLU] = stack[base + 4]/*dstindex*/;
2762827597 // set stack-base & callee-address
27629- base += 18LLU;
27598+ base += 13LLU;
2763027599 label = 691LLU; // emitvaridx
2763127600 break;
2763227601 }
27633- case 2274LLU: // copy-back deleter (emitvaridx to initfrom)
27602+ case 2269LLU: // copy-back deleter (emitvaridx to emitdelete)
2763427603 {
27635- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
27604+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (emitvaridx to emitdelete)\n");
2763627605 // copy mutable arguments back from call to emitvaridx
27637- label = 2266LLU; // continue to roll stack
27606+ label = 2261LLU; // continue to roll stack
2763827607 break;
2763927608 }
27640- case 2275LLU: // return from emitvaridx to initfrom
27609+ case 2270LLU: // return from emitvaridx to emitdelete
2764127610 {
2764227611 // copy mutable arguments back from call to emitvaridx
2764327612 printf("%s", ")");
2764427613 printf("%s", "\n {");
2764527614 printf("%s", "\n fprintf(stderr, \"in function ");
27646- // call printid from initfrom
27647- stack[base + 15LLU] = 2276LLU/*throw to this address*/;
27648- stack[base + 16LLU] = base;
27649- stack[base + 17LLU] = 2277LLU;
27615+ // call printid from emitdelete
27616+ stack[base + 10LLU] = 2271LLU/*throw to this address*/;
27617+ stack[base + 11LLU] = base;
27618+ stack[base + 12LLU] = 2272LLU;
2765027619 // arguments for call to printid
27651- stack[base + 18LLU] = stack[base + 0]/*fnid*/;
27620+ stack[base + 13LLU] = stack[base + 1]/*fnid*/;
2765227621 // set stack-base & callee-address
27653- base += 18LLU;
27622+ base += 13LLU;
2765427623 label = 18446744073709551587LLU; // printid
2765527624 break;
2765627625 }
27657- case 2276LLU: // copy-back deleter (printid to initfrom)
27626+ case 2271LLU: // copy-back deleter (printid to emitdelete)
2765827627 {
27659- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27628+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
2766027629 // copy mutable arguments back from call to printid
27661- label = 2266LLU; // continue to roll stack
27630+ label = 2261LLU; // continue to roll stack
2766227631 break;
2766327632 }
27664- case 2277LLU: // return from printid to initfrom
27633+ case 2272LLU: // return from printid to emitdelete
2766527634 {
2766627635 // copy mutable arguments back from call to printid
2766727636 printf("%s", ": unrolling stack, skipping already deleted/unscoped variable ");
@@ -27668,18 +27637,18 @@
2766827637 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2766927638 if(!newstack)
2767027639 {
27671- label = 2266LLU; // throw: begin to unroll stack
27640+ label = 2261LLU; // throw: begin to unroll stack
2767227641 break;
2767327642 }
2767427643
2767527644 newstack[10LLU] = 9876543210LLU; // overflow-marker
27676- // call printtype from initfrom
27645+ // call printtype from emitdelete
2767727646 newstack[0] = (uint64_t)stack; // backup stack location
27678- newstack[1] = 2278LLU;
27647+ newstack[1] = 2273LLU;
2767927648 newstack[2] = base;
27680- newstack[3] = 2279LLU;
27649+ newstack[3] = 2274LLU;
2768127650 // arguments for call to printtype
27682- newstack[4LLU] = stack[base + 1]/*dsttype*/;
27651+ newstack[4LLU] = stack[base + 2]/*dsttype*/;
2768327652 stack = newstack;
2768427653 // set stack-base & callee-address
2768527654 base = 4/*deloffset*/;
@@ -27686,9 +27655,9 @@
2768627655 label = 305LLU; // printtype
2768727656 break;
2768827657 }
27689- case 2278LLU: // copy-back deleter (printtype to initfrom)
27658+ case 2273LLU: // copy-back deleter (printtype to emitdelete)
2769027659 {
27691- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
27660+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printtype to emitdelete)\n");
2769227661 uint64_t *oldstack = (uint64_t *)stack[0];
2769327662 // copy mutable arguments back from call to printtype
2769427663 if(stack[10LLU] != 9876543210LLU)
@@ -27698,10 +27667,10 @@
2769827667 }
2769927668 Free(10LLU + 1, sizeof(uint64_t), stack);
2770027669 stack = oldstack;
27701- label = 2266LLU; // continue to unroll stack
27670+ label = 2261LLU; // continue to unroll stack
2770227671 break;
2770327672 }
27704- case 2279LLU: // return from printtype to initfrom
27673+ case 2274LLU: // return from printtype to emitdelete
2770527674 {
2770627675 uint64_t *oldstack = (uint64_t *)stack[0];
2770727676 // copy mutable arguments back from call to printtype
@@ -27713,48 +27682,48 @@
2771327682 Free(10LLU + 1, sizeof(uint64_t), stack);
2771427683 stack = oldstack;
2771527684 printf("%s", " ");
27716- // call printid from initfrom
27717- stack[base + 15LLU] = 2280LLU/*throw to this address*/;
27718- stack[base + 16LLU] = base;
27719- stack[base + 17LLU] = 2281LLU;
27685+ // call printid from emitdelete
27686+ stack[base + 10LLU] = 2275LLU/*throw to this address*/;
27687+ stack[base + 11LLU] = base;
27688+ stack[base + 12LLU] = 2276LLU;
2772027689 // arguments for call to printid
27721- stack[base + 18LLU] = stack[base + 2]/*dstid*/;
27690+ stack[base + 13LLU] = stack[base + 3]/*dstid*/;
2772227691 // set stack-base & callee-address
27723- base += 18LLU;
27692+ base += 13LLU;
2772427693 label = 18446744073709551587LLU; // printid
2772527694 break;
2772627695 }
27727- case 2280LLU: // copy-back deleter (printid to initfrom)
27696+ case 2275LLU: // copy-back deleter (printid to emitdelete)
2772827697 {
27729- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27698+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
2773027699 // copy mutable arguments back from call to printid
27731- label = 2266LLU; // continue to roll stack
27700+ label = 2261LLU; // continue to roll stack
2773227701 break;
2773327702 }
27734- case 2281LLU: // return from printid to initfrom
27703+ case 2276LLU: // return from printid to emitdelete
2773527704 {
2773627705 // copy mutable arguments back from call to printid
2773727706 printf("%s", "\\n\");");
2773827707 printf("%s", "\n label = ");
27739- // call printnr from initfrom
27740- stack[base + 15LLU] = 2282LLU/*throw to this address*/;
27741- stack[base + 16LLU] = base;
27742- stack[base + 17LLU] = 2283LLU;
27708+ // call printnr from emitdelete
27709+ stack[base + 10LLU] = 2277LLU/*throw to this address*/;
27710+ stack[base + 11LLU] = base;
27711+ stack[base + 12LLU] = 2278LLU;
2774327712 // arguments for call to printnr
27744- stack[base + 18LLU] = stack[base + 12]/*labelthrow*/;
27713+ stack[base + 13LLU] = stack[base + 6]/*labelthrow*/;
2774527714 // set stack-base & callee-address
27746- base += 18LLU;
27715+ base += 13LLU;
2774727716 label = 18446744073709551590LLU; // printnr
2774827717 break;
2774927718 }
27750- case 2282LLU: // copy-back deleter (printnr to initfrom)
27719+ case 2277LLU: // copy-back deleter (printnr to emitdelete)
2775127720 {
27752- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27721+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
2775327722 // copy mutable arguments back from call to printnr
27754- label = 2266LLU; // continue to roll stack
27723+ label = 2261LLU; // continue to roll stack
2775527724 break;
2775627725 }
27757- case 2283LLU: // return from printnr to initfrom
27726+ case 2278LLU: // return from printnr to emitdelete
2775827727 {
2775927728 // copy mutable arguments back from call to printnr
2776027729 printf("%s", "LLU; // skip, variable already deleted/unscoped");
@@ -27761,25 +27730,25 @@
2776127730 printf("%s", "\n break;");
2776227731 printf("%s", "\n }");
2776327732 printf("%s", "\n fprintf(stderr, \"in function ");
27764- // call printid from initfrom
27765- stack[base + 15LLU] = 2284LLU/*throw to this address*/;
27766- stack[base + 16LLU] = base;
27767- stack[base + 17LLU] = 2285LLU;
27733+ // call printid from emitdelete
27734+ stack[base + 10LLU] = 2279LLU/*throw to this address*/;
27735+ stack[base + 11LLU] = base;
27736+ stack[base + 12LLU] = 2280LLU;
2776827737 // arguments for call to printid
27769- stack[base + 18LLU] = stack[base + 0]/*fnid*/;
27738+ stack[base + 13LLU] = stack[base + 1]/*fnid*/;
2777027739 // set stack-base & callee-address
27771- base += 18LLU;
27740+ base += 13LLU;
2777227741 label = 18446744073709551587LLU; // printid
2777327742 break;
2777427743 }
27775- case 2284LLU: // copy-back deleter (printid to initfrom)
27744+ case 2279LLU: // copy-back deleter (printid to emitdelete)
2777627745 {
27777- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27746+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
2777827747 // copy mutable arguments back from call to printid
27779- label = 2266LLU; // continue to roll stack
27748+ label = 2261LLU; // continue to roll stack
2778027749 break;
2778127750 }
27782- case 2285LLU: // return from printid to initfrom
27751+ case 2280LLU: // return from printid to emitdelete
2778327752 {
2778427753 // copy mutable arguments back from call to printid
2778527754 printf("%s", ": unrolling stack, variable ");
@@ -27786,18 +27755,18 @@
2778627755 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2778727756 if(!newstack)
2778827757 {
27789- label = 2266LLU; // throw: begin to unroll stack
27758+ label = 2261LLU; // throw: begin to unroll stack
2779027759 break;
2779127760 }
2779227761
2779327762 newstack[10LLU] = 9876543210LLU; // overflow-marker
27794- // call printtype from initfrom
27763+ // call printtype from emitdelete
2779527764 newstack[0] = (uint64_t)stack; // backup stack location
27796- newstack[1] = 2286LLU;
27765+ newstack[1] = 2281LLU;
2779727766 newstack[2] = base;
27798- newstack[3] = 2287LLU;
27767+ newstack[3] = 2282LLU;
2779927768 // arguments for call to printtype
27800- newstack[4LLU] = stack[base + 1]/*dsttype*/;
27769+ newstack[4LLU] = stack[base + 2]/*dsttype*/;
2780127770 stack = newstack;
2780227771 // set stack-base & callee-address
2780327772 base = 4/*deloffset*/;
@@ -27804,9 +27773,9 @@
2780427773 label = 305LLU; // printtype
2780527774 break;
2780627775 }
27807- case 2286LLU: // copy-back deleter (printtype to initfrom)
27776+ case 2281LLU: // copy-back deleter (printtype to emitdelete)
2780827777 {
27809- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
27778+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printtype to emitdelete)\n");
2781027779 uint64_t *oldstack = (uint64_t *)stack[0];
2781127780 // copy mutable arguments back from call to printtype
2781227781 if(stack[10LLU] != 9876543210LLU)
@@ -27816,10 +27785,10 @@
2781627785 }
2781727786 Free(10LLU + 1, sizeof(uint64_t), stack);
2781827787 stack = oldstack;
27819- label = 2266LLU; // continue to unroll stack
27788+ label = 2261LLU; // continue to unroll stack
2782027789 break;
2782127790 }
27822- case 2287LLU: // return from printtype to initfrom
27791+ case 2282LLU: // return from printtype to emitdelete
2782327792 {
2782427793 uint64_t *oldstack = (uint64_t *)stack[0];
2782527794 // copy mutable arguments back from call to printtype
@@ -27831,25 +27800,25 @@
2783127800 Free(10LLU + 1, sizeof(uint64_t), stack);
2783227801 stack = oldstack;
2783327802 printf("%s", " ");
27834- // call printid from initfrom
27835- stack[base + 15LLU] = 2288LLU/*throw to this address*/;
27836- stack[base + 16LLU] = base;
27837- stack[base + 17LLU] = 2289LLU;
27803+ // call printid from emitdelete
27804+ stack[base + 10LLU] = 2283LLU/*throw to this address*/;
27805+ stack[base + 11LLU] = base;
27806+ stack[base + 12LLU] = 2284LLU;
2783827807 // arguments for call to printid
27839- stack[base + 18LLU] = stack[base + 2]/*dstid*/;
27808+ stack[base + 13LLU] = stack[base + 3]/*dstid*/;
2784027809 // set stack-base & callee-address
27841- base += 18LLU;
27810+ base += 13LLU;
2784227811 label = 18446744073709551587LLU; // printid
2784327812 break;
2784427813 }
27845- case 2288LLU: // copy-back deleter (printid to initfrom)
27814+ case 2283LLU: // copy-back deleter (printid to emitdelete)
2784627815 {
27847- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27816+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
2784827817 // copy mutable arguments back from call to printid
27849- label = 2266LLU; // continue to roll stack
27818+ label = 2261LLU; // continue to roll stack
2785027819 break;
2785127820 }
27852- case 2289LLU: // return from printid to initfrom
27821+ case 2284LLU: // return from printid to emitdelete
2785327822 {
2785427823 // copy mutable arguments back from call to printid
2785527824 printf("%s", "\\n\");");
@@ -27856,22 +27825,22 @@
2785627825 uint64_t *newstack = (uint64_t *)Calloc(75LLU + 1, sizeof(uint64_t));
2785727826 if(!newstack)
2785827827 {
27859- label = 2266LLU; // throw: begin to unroll stack
27828+ label = 2261LLU; // throw: begin to unroll stack
2786027829 break;
2786127830 }
2786227831
2786327832 newstack[75LLU] = 9876543210LLU; // overflow-marker
27864- // call calldestr from initfrom
27833+ // call calldestr from emitdelete
2786527834 newstack[0] = (uint64_t)stack; // backup stack location
27866- newstack[1] = 2290LLU;
27835+ newstack[1] = 2285LLU;
2786727836 newstack[2] = base;
27868- newstack[3] = 2291LLU;
27837+ newstack[3] = 2286LLU;
2786927838 // arguments for call to calldestr
27870- newstack[4LLU] = stack[base + 0]/*fnid*/;
27871- newstack[5LLU] = stack[base + 4]/*typedefs*/;
27872- newstack[6LLU] = stack[base + 1]/*dsttype*/;
27873- newstack[7LLU] = stack[base + 3]/*dstindex*/;
27874- newstack[8LLU] = stack[base + 8]/*label*/;
27839+ newstack[4LLU] = stack[base + 1]/*fnid*/;
27840+ newstack[5LLU] = stack[base + 5]/*typedefs*/;
27841+ newstack[6LLU] = stack[base + 2]/*dsttype*/;
27842+ newstack[7LLU] = stack[base + 4]/*dstindex*/;
27843+ newstack[8LLU] = stack[base + 7]/*label*/;
2787527844 newstack[9LLU] = 0LLU; //
2787627845 stack = newstack;
2787727846 // set stack-base & callee-address
@@ -27879,12 +27848,12 @@
2787927848 label = 1084LLU; // calldestr
2788027849 break;
2788127850 }
27882- case 2290LLU: // copy-back deleter (calldestr to initfrom)
27851+ case 2285LLU: // copy-back deleter (calldestr to emitdelete)
2788327852 {
27884- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (calldestr to initfrom)\n");
27853+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (calldestr to emitdelete)\n");
2788527854 uint64_t *oldstack = (uint64_t *)stack[0];
2788627855 // copy mutable arguments back from call to calldestr
27887- oldstack[base + 8]/*label*/ = stack[8LLU];
27856+ oldstack[base + 7]/*label*/ = stack[8LLU];
2788827857 if(stack[75LLU] != 9876543210LLU)
2788927858 {
2789027859 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");
@@ -27892,14 +27861,14 @@
2789227861 }
2789327862 Free(75LLU + 1, sizeof(uint64_t), stack);
2789427863 stack = oldstack;
27895- label = 2266LLU; // continue to unroll stack
27864+ label = 2261LLU; // continue to unroll stack
2789627865 break;
2789727866 }
27898- case 2291LLU: // return from calldestr to initfrom
27867+ case 2286LLU: // return from calldestr to emitdelete
2789927868 {
2790027869 uint64_t *oldstack = (uint64_t *)stack[0];
2790127870 // copy mutable arguments back from call to calldestr
27902- oldstack[base + 8]/*label*/ = stack[8LLU];
27871+ oldstack[base + 7]/*label*/ = stack[8LLU];
2790327872 if(stack[75LLU] != 9876543210LLU)
2790427873 {
2790527874 fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");
@@ -27908,25 +27877,25 @@
2790827877 Free(75LLU + 1, sizeof(uint64_t), stack);
2790927878 stack = oldstack;
2791027879 printf("%s", "\n label = ");
27911- // call printnr from initfrom
27912- stack[base + 15LLU] = 2292LLU/*throw to this address*/;
27913- stack[base + 16LLU] = base;
27914- stack[base + 17LLU] = 2293LLU;
27880+ // call printnr from emitdelete
27881+ stack[base + 10LLU] = 2287LLU/*throw to this address*/;
27882+ stack[base + 11LLU] = base;
27883+ stack[base + 12LLU] = 2288LLU;
2791527884 // arguments for call to printnr
27916- stack[base + 18LLU] = stack[base + 12]/*labelthrow*/;
27885+ stack[base + 13LLU] = stack[base + 6]/*labelthrow*/;
2791727886 // set stack-base & callee-address
27918- base += 18LLU;
27887+ base += 13LLU;
2791927888 label = 18446744073709551590LLU; // printnr
2792027889 break;
2792127890 }
27922- case 2292LLU: // copy-back deleter (printnr to initfrom)
27891+ case 2287LLU: // copy-back deleter (printnr to emitdelete)
2792327892 {
27924- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27893+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
2792527894 // copy mutable arguments back from call to printnr
27926- label = 2266LLU; // continue to roll stack
27895+ label = 2261LLU; // continue to roll stack
2792727896 break;
2792827897 }
27929- case 2293LLU: // return from printnr to initfrom
27898+ case 2288LLU: // return from printnr to emitdelete
2793027899 {
2793127900 // copy mutable arguments back from call to printnr
2793227901 printf("%s", "LLU; // continue unrolling stack, delete next variable");
@@ -27933,52 +27902,149 @@
2793327902 printf("%s", "\n break;");
2793427903 printf("%s", "\n }");
2793527904 printf("%s", "\n case ");
27936- // call printnr from initfrom
27937- stack[base + 15LLU] = 2294LLU/*throw to this address*/;
27938- stack[base + 16LLU] = base;
27939- stack[base + 17LLU] = 2295LLU;
27905+ // call printnr from emitdelete
27906+ stack[base + 10LLU] = 2289LLU/*throw to this address*/;
27907+ stack[base + 11LLU] = base;
27908+ stack[base + 12LLU] = 2290LLU;
2794027909 // arguments for call to printnr
27941- stack[base + 18LLU] = stack[base + 14]/*labelskip*/;
27910+ stack[base + 13LLU] = stack[base + 9]/*labelskip*/;
2794227911 // set stack-base & callee-address
27943- base += 18LLU;
27912+ base += 13LLU;
2794427913 label = 18446744073709551590LLU; // printnr
2794527914 break;
2794627915 }
27947- case 2294LLU: // copy-back deleter (printnr to initfrom)
27916+ case 2289LLU: // copy-back deleter (printnr to emitdelete)
2794827917 {
27949- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27918+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
2795027919 // copy mutable arguments back from call to printnr
27951- label = 2266LLU; // continue to roll stack
27920+ label = 2261LLU; // continue to roll stack
2795227921 break;
2795327922 }
27954- case 2295LLU: // return from printnr to initfrom
27923+ case 2290LLU: // return from printnr to emitdelete
2795527924 {
2795627925 // copy mutable arguments back from call to printnr
2795727926 printf("%s", "LLU: // skipped deleter");
2795827927 printf("%s", "\n {");
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
27928+ label = 2292LLU; // skip deleter
2796227929 break;
2796327930 }
27964- case 2263LLU: // copy-back deleter (switch)
27931+ case 2291LLU: // deleter
2796527932 {
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
27933+ // throw from emitdelete
27934+ if(!stack[base + 0])
27935+ {
27936+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27937+ label = 2261LLU; // skip, variable already deleted/unscoped
27938+ break;
27939+ }
27940+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 \n");
27941+ label = 2261LLU; // continue unrolling stack, delete next variable
2796927942 break;
2797027943 }
27971- case 2262LLU: // try next case
27944+ case 2292LLU: // skipped deleter
2797227945 {
27973- fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
27974- exit(-1);
27946+ stack[base + 0] = stack[base + 8]/*labelfail*/;
27947+ // return from emitdelete
27948+ label = stack[base - 1];
27949+ base = stack[base - 2];
27950+ break;
2797527951 }
27976- case 2261LLU: // completed switch
27952+ case 2294LLU: // function initfrom failed
2797727953 {
27954+ fprintf(stderr, "function initfrom failed\n");
27955+ label = stack[base - 3];
27956+ base = stack[base - 2];
27957+ break;
27958+ }
27959+ case 2293LLU: // initfrom
27960+ {
27961+//#define arg0 0
27962+//#define arg1 1
27963+//#define arg2 2
27964+//#define arg3 3
27965+//#define arg4 4
27966+//#define arg5 5
27967+//#define arg6 6
27968+//#define arg7 7
27969+//#define arg8 8
27970+//#define arg9 9
27971+ label = 2296LLU; // skip deleter
27972+ break;
27973+ }
27974+ case 2295LLU: // deleter
27975+ {
27976+ // throw from initfrom
27977+ if(!stack[base + 10])
27978+ {
27979+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
27980+ label = 2294LLU; // skip, variable already deleted/unscoped
27981+ break;
27982+ }
27983+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 isequal\n");
27984+ label = 2294LLU; // continue unrolling stack, delete next variable
27985+ break;
27986+ }
27987+ case 2296LLU: // skipped deleter
27988+ {
27989+ stack[base + 10] = 0;
27990+ // call getdeladdr from initfrom
27991+ stack[base + 13LLU] = 2297LLU/*throw to this address*/;
27992+ stack[base + 14LLU] = base;
27993+ stack[base + 15LLU] = 2298LLU;
27994+ // arguments for call to getdeladdr
27995+ stack[base + 17LLU] = stack[base + 6]/*scope*/;
27996+ // set stack-base & callee-address
27997+ base += 16LLU;
27998+ label = 564LLU; // getdeladdr
27999+ break;
28000+ }
28001+ case 2297LLU: // copy-back deleter (getdeladdr to initfrom)
28002+ {
28003+ fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getdeladdr to initfrom)\n");
28004+ // copy mutable arguments back from call to getdeladdr
28005+ label = 2295LLU; // continue to roll stack
28006+ break;
28007+ }
28008+ case 2298LLU: // return from getdeladdr to initfrom
28009+ {
28010+ // copy mutable arguments back from call to getdeladdr
28011+ // copy back results provided by call to getdeladdr
28012+ stack[base + 12] = stack[base + 16LLU];
28013+ // call emitdelete from initfrom
28014+ stack[base + 13LLU] = 2299LLU/*throw to this address*/;
28015+ stack[base + 14LLU] = base;
28016+ stack[base + 15LLU] = 2300LLU;
28017+ // arguments for call to emitdelete
28018+ stack[base + 17LLU] = stack[base + 0]/*fnid*/;
28019+ stack[base + 18LLU] = stack[base + 1]/*dsttype*/;
28020+ stack[base + 19LLU] = stack[base + 2]/*dstid*/;
28021+ stack[base + 20LLU] = stack[base + 3]/*dstindex*/;
28022+ stack[base + 21LLU] = stack[base + 4]/*typedefs*/;
28023+ stack[base + 22LLU] = stack[base + 12]/*labelthrow*/;
28024+ stack[base + 23LLU] = stack[base + 8]/*label*/;
28025+ // set stack-base & callee-address
28026+ base += 16LLU;
28027+ label = 2253LLU; // emitdelete
28028+ break;
28029+ }
28030+ case 2299LLU: // copy-back deleter (emitdelete to initfrom)
28031+ {
28032+ fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitdelete to initfrom)\n");
28033+ // copy mutable arguments back from call to emitdelete
28034+ stack[base + 8]/*label*/ = stack[base + 23LLU];
28035+ label = 2295LLU; // continue to roll stack
28036+ break;
28037+ }
28038+ case 2300LLU: // return from emitdelete to initfrom
28039+ {
28040+ // copy mutable arguments back from call to emitdelete
28041+ stack[base + 8]/*label*/ = stack[base + 23LLU];
28042+ // copy back results provided by call to emitdelete
28043+ stack[base + 11] = stack[base + 16LLU];
2797828044 // call ParseToken from initfrom
27979- stack[base + 14LLU] = 2296LLU/*throw to this address*/;
28045+ stack[base + 14LLU] = 2301LLU/*throw to this address*/;
2798028046 stack[base + 15LLU] = base;
27981- stack[base + 16LLU] = 2297LLU;
28047+ stack[base + 16LLU] = 2302LLU;
2798228048 // arguments for call to ParseToken
2798328049 stack[base + 19LLU] = stack[base + 7]/*lookahead*/;
2798428050 // set stack-base & callee-address
@@ -27986,15 +28052,15 @@
2798628052 label = 3LLU; // ParseToken
2798728053 break;
2798828054 }
27989- case 2296LLU: // copy-back deleter (ParseToken to initfrom)
28055+ case 2301LLU: // copy-back deleter (ParseToken to initfrom)
2799028056 {
2799128057 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2799228058 // copy mutable arguments back from call to ParseToken
2799328059 stack[base + 7]/*lookahead*/ = stack[base + 19LLU];
27994- label = 2259LLU; // continue to roll stack
28060+ label = 2295LLU; // continue to roll stack
2799528061 break;
2799628062 }
27997- case 2297LLU: // return from ParseToken to initfrom
28063+ case 2302LLU: // return from ParseToken to initfrom
2799828064 {
2799928065 // copy mutable arguments back from call to ParseToken
2800028066 stack[base + 7]/*lookahead*/ = stack[base + 19LLU];
@@ -28002,9 +28068,9 @@
2800228068 stack[base + 12] = stack[base + 17LLU];
2800328069 stack[base + 13] = stack[base + 18LLU];
2800428070 // call issimple from initfrom
28005- stack[base + 15LLU] = 2298LLU/*throw to this address*/;
28071+ stack[base + 15LLU] = 2303LLU/*throw to this address*/;
2800628072 stack[base + 16LLU] = base;
28007- stack[base + 17LLU] = 2299LLU;
28073+ stack[base + 17LLU] = 2304LLU;
2800828074 // arguments for call to issimple
2800928075 stack[base + 19LLU] = stack[base + 12]/*variant*/;
2801028076 stack[base + 20LLU] = stack[base + 13]/*content*/;
@@ -28014,14 +28080,14 @@
2801428080 label = 158LLU; // issimple
2801528081 break;
2801628082 }
28017- case 2298LLU: // copy-back deleter (issimple to initfrom)
28083+ case 2303LLU: // copy-back deleter (issimple to initfrom)
2801828084 {
2801928085 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
2802028086 // copy mutable arguments back from call to issimple
28021- label = 2259LLU; // continue to roll stack
28087+ label = 2295LLU; // continue to roll stack
2802228088 break;
2802328089 }
28024- case 2299LLU: // return from issimple to initfrom
28090+ case 2304LLU: // return from issimple to initfrom
2802528091 {
2802628092 // copy mutable arguments back from call to issimple
2802728093 // copy back results provided by call to issimple
@@ -28028,7 +28094,7 @@
2802828094 stack[base + 14] = stack[base + 18LLU];
2802928095 if(!stack[base + 14]/*forceerror*/)
2803028096 {
28031- label = 2300LLU; // jump to alternative
28097+ label = 2305LLU; // jump to alternative
2803228098 break;
2803328099 }
2803428100
@@ -28035,9 +28101,9 @@
2803528101 // consequent
2803628102 fprintf(stderr, "%s", "in function ");
2803728103 // call reportid from initfrom
28038- stack[base + 15LLU] = 2302LLU/*throw to this address*/;
28104+ stack[base + 15LLU] = 2307LLU/*throw to this address*/;
2803928105 stack[base + 16LLU] = base;
28040- stack[base + 17LLU] = 2303LLU;
28106+ stack[base + 17LLU] = 2308LLU;
2804128107 // arguments for call to reportid
2804228108 stack[base + 18LLU] = stack[base + 0]/*fnid*/;
2804328109 // set stack-base & callee-address
@@ -28045,21 +28111,21 @@
2804528111 label = 18446744073709551586LLU; // reportid
2804628112 break;
2804728113 }
28048- case 2302LLU: // copy-back deleter (reportid to initfrom)
28114+ case 2307LLU: // copy-back deleter (reportid to initfrom)
2804928115 {
2805028116 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2805128117 // copy mutable arguments back from call to reportid
28052- label = 2259LLU; // continue to roll stack
28118+ label = 2295LLU; // continue to roll stack
2805328119 break;
2805428120 }
28055- case 2303LLU: // return from reportid to initfrom
28121+ case 2308LLU: // return from reportid to initfrom
2805628122 {
2805728123 // copy mutable arguments back from call to reportid
2805828124 fprintf(stderr, "%s", ": WARNING, FORCING CONSTRUCTION TO FAIL TO TEST THROW MECHANISM!\n");
2805928125 // call ParseToken from initfrom
28060- stack[base + 15LLU] = 2304LLU/*throw to this address*/;
28126+ stack[base + 15LLU] = 2309LLU/*throw to this address*/;
2806128127 stack[base + 16LLU] = base;
28062- stack[base + 17LLU] = 2305LLU;
28128+ stack[base + 17LLU] = 2310LLU;
2806328129 // arguments for call to ParseToken
2806428130 stack[base + 20LLU] = stack[base + 7]/*lookahead*/;
2806528131 // set stack-base & callee-address
@@ -28067,15 +28133,15 @@
2806728133 label = 3LLU; // ParseToken
2806828134 break;
2806928135 }
28070- case 2304LLU: // copy-back deleter (ParseToken to initfrom)
28136+ case 2309LLU: // copy-back deleter (ParseToken to initfrom)
2807128137 {
2807228138 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2807328139 // copy mutable arguments back from call to ParseToken
2807428140 stack[base + 7]/*lookahead*/ = stack[base + 20LLU];
28075- label = 2259LLU; // continue to roll stack
28141+ label = 2295LLU; // continue to roll stack
2807628142 break;
2807728143 }
28078- case 2305LLU: // return from ParseToken to initfrom
28144+ case 2310LLU: // return from ParseToken to initfrom
2807928145 {
2808028146 // copy mutable arguments back from call to ParseToken
2808128147 stack[base + 7]/*lookahead*/ = stack[base + 20LLU];
@@ -28082,20 +28148,20 @@
2808228148 // copy back results provided by call to ParseToken
2808328149 stack[base + 12] = stack[base + 18LLU];
2808428150 stack[base + 13] = stack[base + 19LLU];
28085- label = 2301LLU; // consequent complete
28151+ label = 2306LLU; // consequent complete
2808628152 break;
2808728153 }
28088- case 2300LLU: // alternative
28154+ case 2305LLU: // alternative
2808928155 {
28090- label = 2301LLU; // alternative complete
28156+ label = 2306LLU; // alternative complete
2809128157 break;
2809228158 }
28093- case 2301LLU: // completed if-then-else
28159+ case 2306LLU: // completed if-then-else
2809428160 {
2809528161 // call equ from initfrom
28096- stack[base + 15LLU] = 2306LLU/*throw to this address*/;
28162+ stack[base + 15LLU] = 2311LLU/*throw to this address*/;
2809728163 stack[base + 16LLU] = base;
28098- stack[base + 17LLU] = 2307LLU;
28164+ stack[base + 17LLU] = 2312LLU;
2809928165 // arguments for call to equ
2810028166 stack[base + 19LLU] = stack[base + 12]/*variant*/;
2810128167 stack[base + 20LLU] = 4LLU;
@@ -28104,14 +28170,14 @@
2810428170 label = 18446744073709551600LLU; // equ
2810528171 break;
2810628172 }
28107- case 2306LLU: // copy-back deleter (equ to initfrom)
28173+ case 2311LLU: // copy-back deleter (equ to initfrom)
2810828174 {
2810928175 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2811028176 // copy mutable arguments back from call to equ
28111- label = 2259LLU; // continue to roll stack
28177+ label = 2295LLU; // continue to roll stack
2811228178 break;
2811328179 }
28114- case 2307LLU: // return from equ to initfrom
28180+ case 2312LLU: // return from equ to initfrom
2811528181 {
2811628182 // copy mutable arguments back from call to equ
2811728183 // copy back results provided by call to equ
@@ -28118,15 +28184,15 @@
2811828184 stack[base + 10] = stack[base + 18LLU];
2811928185 if(!stack[base + 10]/*isequal*/)
2812028186 {
28121- label = 2308LLU; // jump to alternative
28187+ label = 2313LLU; // jump to alternative
2812228188 break;
2812328189 }
2812428190
2812528191 // consequent
2812628192 // call skipwscmnt from initfrom
28127- stack[base + 15LLU] = 2310LLU/*throw to this address*/;
28193+ stack[base + 15LLU] = 2315LLU/*throw to this address*/;
2812828194 stack[base + 16LLU] = base;
28129- stack[base + 17LLU] = 2311LLU;
28195+ stack[base + 17LLU] = 2316LLU;
2813028196 // arguments for call to skipwscmnt
2813128197 stack[base + 19LLU] = stack[base + 7]/*lookahead*/;
2813228198 // set stack-base & callee-address
@@ -28134,22 +28200,22 @@
2813428200 label = 18446744073709551580LLU; // skipwscmnt
2813528201 break;
2813628202 }
28137- case 2310LLU: // copy-back deleter (skipwscmnt to initfrom)
28203+ case 2315LLU: // copy-back deleter (skipwscmnt to initfrom)
2813828204 {
2813928205 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (skipwscmnt to initfrom)\n");
2814028206 // copy mutable arguments back from call to skipwscmnt
28141- label = 2259LLU; // continue to roll stack
28207+ label = 2295LLU; // continue to roll stack
2814228208 break;
2814328209 }
28144- case 2311LLU: // return from skipwscmnt to initfrom
28210+ case 2316LLU: // return from skipwscmnt to initfrom
2814528211 {
2814628212 // copy mutable arguments back from call to skipwscmnt
2814728213 // copy back results provided by call to skipwscmnt
2814828214 stack[base + 7] = stack[base + 18LLU];
2814928215 // call equ from initfrom
28150- stack[base + 16LLU] = 2312LLU/*throw to this address*/;
28216+ stack[base + 16LLU] = 2317LLU/*throw to this address*/;
2815128217 stack[base + 17LLU] = base;
28152- stack[base + 18LLU] = 2313LLU;
28218+ stack[base + 18LLU] = 2318LLU;
2815328219 // arguments for call to equ
2815428220 stack[base + 20LLU] = stack[base + 7]/*lookahead*/;
2815528221 stack[base + 21LLU] = 46LLU;
@@ -28158,14 +28224,14 @@
2815828224 label = 18446744073709551600LLU; // equ
2815928225 break;
2816028226 }
28161- case 2312LLU: // copy-back deleter (equ to initfrom)
28227+ case 2317LLU: // copy-back deleter (equ to initfrom)
2816228228 {
2816328229 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2816428230 // copy mutable arguments back from call to equ
28165- label = 2259LLU; // continue to roll stack
28231+ label = 2295LLU; // continue to roll stack
2816628232 break;
2816728233 }
28168- case 2313LLU: // return from equ to initfrom
28234+ case 2318LLU: // return from equ to initfrom
2816928235 {
2817028236 // copy mutable arguments back from call to equ
2817128237 // copy back results provided by call to equ
@@ -28172,40 +28238,40 @@
2817228238 stack[base + 15] = stack[base + 19LLU];
2817328239 if(!stack[base + 15]/*namespace*/)
2817428240 {
28175- label = 2314LLU; // jump to alternative
28241+ label = 2319LLU; // jump to alternative
2817628242 break;
2817728243 }
2817828244
2817928245 // consequent
28180- label = 2317LLU; // skip deleter
28246+ label = 2322LLU; // skip deleter
2818128247 break;
2818228248 }
28183- case 2316LLU: // deleter
28249+ case 2321LLU: // deleter
2818428250 {
2818528251 // throw from initfrom
2818628252 if(!stack[base + 16])
2818728253 {
2818828254 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 typename\n");
28189- label = 2259LLU; // skip, variable already deleted/unscoped
28255+ label = 2295LLU; // skip, variable already deleted/unscoped
2819028256 break;
2819128257 }
2819228258 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 typename\n");
28193- label = 2259LLU; // continue unrolling stack, delete next variable
28259+ label = 2295LLU; // continue unrolling stack, delete next variable
2819428260 break;
2819528261 }
28196- case 2317LLU: // skipped deleter
28262+ case 2322LLU: // skipped deleter
2819728263 {
2819828264 stack[base + 16] = stack[base + 13]/*content*/;
28199- label = 2319LLU; // skip deleter
28265+ label = 2324LLU; // skip deleter
2820028266 break;
2820128267 }
28202- case 2318LLU: // deleter
28268+ case 2323LLU: // deleter
2820328269 {
2820428270 // throw from initfrom
2820528271 if(!stack[base + 17])
2820628272 {
2820728273 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type assigntype\n");
28208- label = 2316LLU; // skip, variable already deleted/unscoped
28274+ label = 2321LLU; // skip, variable already deleted/unscoped
2820928275 break;
2821028276 }
2821128277 fprintf(stderr, "in function initfrom: unrolling stack, variable type assigntype\n");
@@ -28215,7 +28281,7 @@
2821528281 newstack[0] = (uint64_t)stack; // backup stack location
2821628282 newstack[1] = 1234567890;
2821728283 newstack[2] = base;
28218- newstack[3] = 2320LLU;
28284+ newstack[3] = 2325LLU;
2821928285 stack = newstack;
2822028286 // set stack-base & callee-address
2822128287 base = 4/*deloffset*/;
@@ -28222,21 +28288,21 @@
2822228288 label = 296LLU; // ~type
2822328289 break;
2822428290 }
28225- case 2320LLU: // return from ~type to initfrom
28291+ case 2325LLU: // return from ~type to initfrom
2822628292 {
2822728293 stack = (uint64_t *)stack[0];
2822828294 // releasing toplevel container
2822928295 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2823028296
28231- label = 2316LLU; // continue unrolling stack, delete next variable
28297+ label = 2321LLU; // continue unrolling stack, delete next variable
2823228298 break;
2823328299 }
28234- case 2319LLU: // skipped deleter
28300+ case 2324LLU: // skipped deleter
2823528301 {
2823628302 // construct type.typename
2823728303 if(!(stack[base + 17] = construct(1)))
2823828304 {
28239- label = 2316LLU; // throw: begin to unroll stack
28305+ label = 2321LLU; // throw: begin to unroll stack
2824028306 break;
2824128307 }
2824228308
@@ -28246,7 +28312,7 @@
2824628312 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2824728313 if(!newstack)
2824828314 {
28249- label = 2318LLU; // throw: begin to unroll stack
28315+ label = 2323LLU; // throw: begin to unroll stack
2825028316 break;
2825128317 }
2825228318
@@ -28253,9 +28319,9 @@
2825328319 newstack[15LLU] = 9876543210LLU; // overflow-marker
2825428320 // call equtype from initfrom
2825528321 newstack[0] = (uint64_t)stack; // backup stack location
28256- newstack[1] = 2321LLU;
28322+ newstack[1] = 2326LLU;
2825728323 newstack[2] = base;
28258- newstack[3] = 2322LLU;
28324+ newstack[3] = 2327LLU;
2825928325 // arguments for call to equtype
2826028326 newstack[5LLU] = stack[base + 1]/*dsttype*/;
2826128327 newstack[6LLU] = stack[base + 17]/*assigntype*/;
@@ -28265,7 +28331,7 @@
2826528331 label = 342LLU; // equtype
2826628332 break;
2826728333 }
28268- case 2321LLU: // copy-back deleter (equtype to initfrom)
28334+ case 2326LLU: // copy-back deleter (equtype to initfrom)
2826928335 {
2827028336 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2827128337 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28277,10 +28343,10 @@
2827728343 }
2827828344 Free(15LLU + 1, sizeof(uint64_t), stack);
2827928345 stack = oldstack;
28280- label = 2318LLU; // continue to unroll stack
28346+ label = 2323LLU; // continue to unroll stack
2828128347 break;
2828228348 }
28283- case 2322LLU: // return from equtype to initfrom
28349+ case 2327LLU: // return from equtype to initfrom
2828428350 {
2828528351 uint64_t *oldstack = (uint64_t *)stack[0];
2828628352 // copy mutable arguments back from call to equtype
@@ -28295,21 +28361,21 @@
2829528361 stack = oldstack;
2829628362 if(!stack[base + 10]/*isequal*/)
2829728363 {
28298- label = 2323LLU; // jump to alternative
28364+ label = 2328LLU; // jump to alternative
2829928365 break;
2830028366 }
2830128367
2830228368 // consequent
28303- label = 2324LLU; // consequent complete
28369+ label = 2329LLU; // consequent complete
2830428370 break;
2830528371 }
28306- case 2323LLU: // alternative
28372+ case 2328LLU: // alternative
2830728373 {
2830828374 fprintf(stderr, "%s", "in function ");
2830928375 // call reportid from initfrom
28310- stack[base + 18LLU] = 2325LLU/*throw to this address*/;
28376+ stack[base + 18LLU] = 2330LLU/*throw to this address*/;
2831128377 stack[base + 19LLU] = base;
28312- stack[base + 20LLU] = 2326LLU;
28378+ stack[base + 20LLU] = 2331LLU;
2831328379 // arguments for call to reportid
2831428380 stack[base + 21LLU] = stack[base + 0]/*fnid*/;
2831528381 // set stack-base & callee-address
@@ -28317,14 +28383,14 @@
2831728383 label = 18446744073709551586LLU; // reportid
2831828384 break;
2831928385 }
28320- case 2325LLU: // copy-back deleter (reportid to initfrom)
28386+ case 2330LLU: // copy-back deleter (reportid to initfrom)
2832128387 {
2832228388 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2832328389 // copy mutable arguments back from call to reportid
28324- label = 2318LLU; // continue to roll stack
28390+ label = 2323LLU; // continue to roll stack
2832528391 break;
2832628392 }
28327- case 2326LLU: // return from reportid to initfrom
28393+ case 2331LLU: // return from reportid to initfrom
2832828394 {
2832928395 // copy mutable arguments back from call to reportid
2833028396 fprintf(stderr, "%s", ": can't construct type ");
@@ -28331,7 +28397,7 @@
2833128397 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2833228398 if(!newstack)
2833328399 {
28334- label = 2318LLU; // throw: begin to unroll stack
28400+ label = 2323LLU; // throw: begin to unroll stack
2833528401 break;
2833628402 }
2833728403
@@ -28338,9 +28404,9 @@
2833828404 newstack[10LLU] = 9876543210LLU; // overflow-marker
2833928405 // call reporttype from initfrom
2834028406 newstack[0] = (uint64_t)stack; // backup stack location
28341- newstack[1] = 2327LLU;
28407+ newstack[1] = 2332LLU;
2834228408 newstack[2] = base;
28343- newstack[3] = 2328LLU;
28409+ newstack[3] = 2333LLU;
2834428410 // arguments for call to reporttype
2834528411 newstack[4LLU] = stack[base + 1]/*dsttype*/;
2834628412 stack = newstack;
@@ -28349,7 +28415,7 @@
2834928415 label = 316LLU; // reporttype
2835028416 break;
2835128417 }
28352- case 2327LLU: // copy-back deleter (reporttype to initfrom)
28418+ case 2332LLU: // copy-back deleter (reporttype to initfrom)
2835328419 {
2835428420 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2835528421 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28361,10 +28427,10 @@
2836128427 }
2836228428 Free(10LLU + 1, sizeof(uint64_t), stack);
2836328429 stack = oldstack;
28364- label = 2318LLU; // continue to unroll stack
28430+ label = 2323LLU; // continue to unroll stack
2836528431 break;
2836628432 }
28367- case 2328LLU: // return from reporttype to initfrom
28433+ case 2333LLU: // return from reporttype to initfrom
2836828434 {
2836928435 uint64_t *oldstack = (uint64_t *)stack[0];
2837028436 // copy mutable arguments back from call to reporttype
@@ -28379,7 +28445,7 @@
2837928445 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2838028446 if(!newstack)
2838128447 {
28382- label = 2318LLU; // throw: begin to unroll stack
28448+ label = 2323LLU; // throw: begin to unroll stack
2838328449 break;
2838428450 }
2838528451
@@ -28386,9 +28452,9 @@
2838628452 newstack[10LLU] = 9876543210LLU; // overflow-marker
2838728453 // call reporttype from initfrom
2838828454 newstack[0] = (uint64_t)stack; // backup stack location
28389- newstack[1] = 2329LLU;
28455+ newstack[1] = 2334LLU;
2839028456 newstack[2] = base;
28391- newstack[3] = 2330LLU;
28457+ newstack[3] = 2335LLU;
2839228458 // arguments for call to reporttype
2839328459 newstack[4LLU] = stack[base + 17]/*assigntype*/;
2839428460 stack = newstack;
@@ -28397,7 +28463,7 @@
2839728463 label = 316LLU; // reporttype
2839828464 break;
2839928465 }
28400- case 2329LLU: // copy-back deleter (reporttype to initfrom)
28466+ case 2334LLU: // copy-back deleter (reporttype to initfrom)
2840128467 {
2840228468 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2840328469 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -28409,10 +28475,10 @@
2840928475 }
2841028476 Free(10LLU + 1, sizeof(uint64_t), stack);
2841128477 stack = oldstack;
28412- label = 2318LLU; // continue to unroll stack
28478+ label = 2323LLU; // continue to unroll stack
2841328479 break;
2841428480 }
28415- case 2330LLU: // return from reporttype to initfrom
28481+ case 2335LLU: // return from reporttype to initfrom
2841628482 {
2841728483 uint64_t *oldstack = (uint64_t *)stack[0];
2841828484 // copy mutable arguments back from call to reporttype
@@ -28425,10 +28491,10 @@
2842528491 stack = oldstack;
2842628492 fprintf(stderr, "%s", "\n");
2842728493 exit(-1);
28428- label = 2324LLU; // alternative complete
28494+ label = 2329LLU; // alternative complete
2842928495 break;
2843028496 }
28431- case 2324LLU: // completed if-then-else
28497+ case 2329LLU: // completed if-then-else
2843228498 {
2843328499
2843428500 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
@@ -28436,7 +28502,7 @@
2843628502 newstack[0] = (uint64_t)stack; // backup stack location
2843728503 newstack[1] = 1234567890;
2843828504 newstack[2] = base;
28439- newstack[3] = 2331LLU;
28505+ newstack[3] = 2336LLU;
2844028506 stack = newstack;
2844128507 // set stack-base & callee-address
2844228508 base = 4/*deloffset*/;
@@ -28443,7 +28509,7 @@
2844328509 label = 296LLU; // ~type
2844428510 break;
2844528511 }
28446- case 2331LLU: // return from ~type to initfrom
28512+ case 2336LLU: // return from ~type to initfrom
2844728513 {
2844828514 stack = (uint64_t *)stack[0];
2844928515 // releasing toplevel container
@@ -28450,9 +28516,9 @@
2845028516 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2845128517
2845228518 // call matchsym from initfrom
28453- stack[base + 17LLU] = 2332LLU/*throw to this address*/;
28519+ stack[base + 17LLU] = 2337LLU/*throw to this address*/;
2845428520 stack[base + 18LLU] = base;
28455- stack[base + 19LLU] = 2333LLU;
28521+ stack[base + 19LLU] = 2338LLU;
2845628522 // arguments for call to matchsym
2845728523 stack[base + 20LLU] = stack[base + 0]/*fnid*/;
2845828524 stack[base + 21LLU] = 46LLU;
@@ -28462,22 +28528,22 @@
2846228528 label = 212LLU; // matchsym
2846328529 break;
2846428530 }
28465- case 2332LLU: // copy-back deleter (matchsym to initfrom)
28531+ case 2337LLU: // copy-back deleter (matchsym to initfrom)
2846628532 {
2846728533 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2846828534 // copy mutable arguments back from call to matchsym
2846928535 stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
28470- label = 2316LLU; // continue to roll stack
28536+ label = 2321LLU; // continue to roll stack
2847128537 break;
2847228538 }
28473- case 2333LLU: // return from matchsym to initfrom
28539+ case 2338LLU: // return from matchsym to initfrom
2847428540 {
2847528541 // copy mutable arguments back from call to matchsym
2847628542 stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
2847728543 // call ParseToken from initfrom
28478- stack[base + 17LLU] = 2334LLU/*throw to this address*/;
28544+ stack[base + 17LLU] = 2339LLU/*throw to this address*/;
2847928545 stack[base + 18LLU] = base;
28480- stack[base + 19LLU] = 2335LLU;
28546+ stack[base + 19LLU] = 2340LLU;
2848128547 // arguments for call to ParseToken
2848228548 stack[base + 22LLU] = stack[base + 7]/*lookahead*/;
2848328549 // set stack-base & callee-address
@@ -28485,15 +28551,15 @@
2848528551 label = 3LLU; // ParseToken
2848628552 break;
2848728553 }
28488- case 2334LLU: // copy-back deleter (ParseToken to initfrom)
28554+ case 2339LLU: // copy-back deleter (ParseToken to initfrom)
2848928555 {
2849028556 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2849128557 // copy mutable arguments back from call to ParseToken
2849228558 stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
28493- label = 2316LLU; // continue to roll stack
28559+ label = 2321LLU; // continue to roll stack
2849428560 break;
2849528561 }
28496- case 2335LLU: // return from ParseToken to initfrom
28562+ case 2340LLU: // return from ParseToken to initfrom
2849728563 {
2849828564 // copy mutable arguments back from call to ParseToken
2849928565 stack[base + 7]/*lookahead*/ = stack[base + 22LLU];
@@ -28501,9 +28567,9 @@
2850128567 stack[base + 12] = stack[base + 20LLU];
2850228568 stack[base + 13] = stack[base + 21LLU];
2850328569 // call equ from initfrom
28504- stack[base + 17LLU] = 2336LLU/*throw to this address*/;
28570+ stack[base + 17LLU] = 2341LLU/*throw to this address*/;
2850528571 stack[base + 18LLU] = base;
28506- stack[base + 19LLU] = 2337LLU;
28572+ stack[base + 19LLU] = 2342LLU;
2850728573 // arguments for call to equ
2850828574 stack[base + 21LLU] = stack[base + 12]/*variant*/;
2850928575 stack[base + 22LLU] = 4LLU;
@@ -28512,14 +28578,14 @@
2851228578 label = 18446744073709551600LLU; // equ
2851328579 break;
2851428580 }
28515- case 2336LLU: // copy-back deleter (equ to initfrom)
28581+ case 2341LLU: // copy-back deleter (equ to initfrom)
2851628582 {
2851728583 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2851828584 // copy mutable arguments back from call to equ
28519- label = 2316LLU; // continue to roll stack
28585+ label = 2321LLU; // continue to roll stack
2852028586 break;
2852128587 }
28522- case 2337LLU: // return from equ to initfrom
28588+ case 2342LLU: // return from equ to initfrom
2852328589 {
2852428590 // copy mutable arguments back from call to equ
2852528591 // copy back results provided by call to equ
@@ -28526,21 +28592,21 @@
2852628592 stack[base + 10] = stack[base + 20LLU];
2852728593 if(!stack[base + 10]/*isequal*/)
2852828594 {
28529- label = 2338LLU; // jump to alternative
28595+ label = 2343LLU; // jump to alternative
2853028596 break;
2853128597 }
2853228598
2853328599 // consequent
28534- label = 2339LLU; // consequent complete
28600+ label = 2344LLU; // consequent complete
2853528601 break;
2853628602 }
28537- case 2338LLU: // alternative
28603+ case 2343LLU: // alternative
2853828604 {
2853928605 fprintf(stderr, "%s", "construct requires constructor but found ");
2854028606 // call reporttok from initfrom
28541- stack[base + 17LLU] = 2340LLU/*throw to this address*/;
28607+ stack[base + 17LLU] = 2345LLU/*throw to this address*/;
2854228608 stack[base + 18LLU] = base;
28543- stack[base + 19LLU] = 2341LLU;
28609+ stack[base + 19LLU] = 2346LLU;
2854428610 // arguments for call to reporttok
2854528611 stack[base + 20LLU] = stack[base + 12]/*variant*/;
2854628612 stack[base + 21LLU] = stack[base + 13]/*content*/;
@@ -28549,40 +28615,40 @@
2854928615 label = 18446744073709551582LLU; // reporttok
2855028616 break;
2855128617 }
28552- case 2340LLU: // copy-back deleter (reporttok to initfrom)
28618+ case 2345LLU: // copy-back deleter (reporttok to initfrom)
2855328619 {
2855428620 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2855528621 // copy mutable arguments back from call to reporttok
28556- label = 2316LLU; // continue to roll stack
28622+ label = 2321LLU; // continue to roll stack
2855728623 break;
2855828624 }
28559- case 2341LLU: // return from reporttok to initfrom
28625+ case 2346LLU: // return from reporttok to initfrom
2856028626 {
2856128627 // copy mutable arguments back from call to reporttok
2856228628 fprintf(stderr, "%s", "\n");
2856328629 exit(-1);
28564- label = 2339LLU; // alternative complete
28630+ label = 2344LLU; // alternative complete
2856528631 break;
2856628632 }
28567- case 2339LLU: // completed if-then-else
28633+ case 2344LLU: // completed if-then-else
2856828634 {
2856928635 if(!stack[base + 9]/*fncanthrow*/)
2857028636 {
28571- label = 2342LLU; // jump to alternative
28637+ label = 2347LLU; // jump to alternative
2857228638 break;
2857328639 }
2857428640
2857528641 // consequent
28576- label = 2343LLU; // consequent complete
28642+ label = 2348LLU; // consequent complete
2857728643 break;
2857828644 }
28579- case 2342LLU: // alternative
28645+ case 2347LLU: // alternative
2858028646 {
2858128647 fprintf(stderr, "%s", "in function ");
2858228648 // call reportid from initfrom
28583- stack[base + 17LLU] = 2344LLU/*throw to this address*/;
28649+ stack[base + 17LLU] = 2349LLU/*throw to this address*/;
2858428650 stack[base + 18LLU] = base;
28585- stack[base + 19LLU] = 2345LLU;
28651+ stack[base + 19LLU] = 2350LLU;
2858628652 // arguments for call to reportid
2858728653 stack[base + 20LLU] = stack[base + 0]/*fnid*/;
2858828654 // set stack-base & callee-address
@@ -28590,21 +28656,21 @@
2859028656 label = 18446744073709551586LLU; // reportid
2859128657 break;
2859228658 }
28593- case 2344LLU: // copy-back deleter (reportid to initfrom)
28659+ case 2349LLU: // copy-back deleter (reportid to initfrom)
2859428660 {
2859528661 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2859628662 // copy mutable arguments back from call to reportid
28597- label = 2316LLU; // continue to roll stack
28663+ label = 2321LLU; // continue to roll stack
2859828664 break;
2859928665 }
28600- case 2345LLU: // return from reportid to initfrom
28666+ case 2350LLU: // return from reportid to initfrom
2860128667 {
2860228668 // copy mutable arguments back from call to reportid
2860328669 fprintf(stderr, "%s", ": construction of data ");
2860428670 // call reportid from initfrom
28605- stack[base + 17LLU] = 2346LLU/*throw to this address*/;
28671+ stack[base + 17LLU] = 2351LLU/*throw to this address*/;
2860628672 stack[base + 18LLU] = base;
28607- stack[base + 19LLU] = 2347LLU;
28673+ stack[base + 19LLU] = 2352LLU;
2860828674 // arguments for call to reportid
2860928675 stack[base + 20LLU] = stack[base + 16]/*typename*/;
2861028676 // set stack-base & callee-address
@@ -28612,28 +28678,28 @@
2861228678 label = 18446744073709551586LLU; // reportid
2861328679 break;
2861428680 }
28615- case 2346LLU: // copy-back deleter (reportid to initfrom)
28681+ case 2351LLU: // copy-back deleter (reportid to initfrom)
2861628682 {
2861728683 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2861828684 // copy mutable arguments back from call to reportid
28619- label = 2316LLU; // continue to roll stack
28685+ label = 2321LLU; // continue to roll stack
2862028686 break;
2862128687 }
28622- case 2347LLU: // return from reportid to initfrom
28688+ case 2352LLU: // return from reportid to initfrom
2862328689 {
2862428690 // copy mutable arguments back from call to reportid
2862528691 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
2862628692 exit(-1);
28627- label = 2343LLU; // alternative complete
28693+ label = 2348LLU; // alternative complete
2862828694 break;
2862928695 }
28630- case 2343LLU: // completed if-then-else
28696+ case 2348LLU: // completed if-then-else
2863128697 {
2863228698 printf("%s", "\n // construct ");
2863328699 // call printid from initfrom
28634- stack[base + 17LLU] = 2348LLU/*throw to this address*/;
28700+ stack[base + 17LLU] = 2353LLU/*throw to this address*/;
2863528701 stack[base + 18LLU] = base;
28636- stack[base + 19LLU] = 2349LLU;
28702+ stack[base + 19LLU] = 2354LLU;
2863728703 // arguments for call to printid
2863828704 stack[base + 20LLU] = stack[base + 16]/*typename*/;
2863928705 // set stack-base & callee-address
@@ -28641,21 +28707,21 @@
2864128707 label = 18446744073709551587LLU; // printid
2864228708 break;
2864328709 }
28644- case 2348LLU: // copy-back deleter (printid to initfrom)
28710+ case 2353LLU: // copy-back deleter (printid to initfrom)
2864528711 {
2864628712 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2864728713 // copy mutable arguments back from call to printid
28648- label = 2316LLU; // continue to roll stack
28714+ label = 2321LLU; // continue to roll stack
2864928715 break;
2865028716 }
28651- case 2349LLU: // return from printid to initfrom
28717+ case 2354LLU: // return from printid to initfrom
2865228718 {
2865328719 // copy mutable arguments back from call to printid
2865428720 printf("%s", ".");
2865528721 // call printid from initfrom
28656- stack[base + 17LLU] = 2350LLU/*throw to this address*/;
28722+ stack[base + 17LLU] = 2355LLU/*throw to this address*/;
2865728723 stack[base + 18LLU] = base;
28658- stack[base + 19LLU] = 2351LLU;
28724+ stack[base + 19LLU] = 2356LLU;
2865928725 // arguments for call to printid
2866028726 stack[base + 20LLU] = stack[base + 13]/*content*/;
2866128727 // set stack-base & callee-address
@@ -28663,20 +28729,20 @@
2866328729 label = 18446744073709551587LLU; // printid
2866428730 break;
2866528731 }
28666- case 2350LLU: // copy-back deleter (printid to initfrom)
28732+ case 2355LLU: // copy-back deleter (printid to initfrom)
2866728733 {
2866828734 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
2866928735 // copy mutable arguments back from call to printid
28670- label = 2316LLU; // continue to roll stack
28736+ label = 2321LLU; // continue to roll stack
2867128737 break;
2867228738 }
28673- case 2351LLU: // return from printid to initfrom
28739+ case 2356LLU: // return from printid to initfrom
2867428740 {
2867528741 // copy mutable arguments back from call to printid
2867628742 // call FindData from initfrom
28677- stack[base + 18LLU] = 2352LLU/*throw to this address*/;
28743+ stack[base + 18LLU] = 2357LLU/*throw to this address*/;
2867828744 stack[base + 19LLU] = base;
28679- stack[base + 20LLU] = 2353LLU;
28745+ stack[base + 20LLU] = 2358LLU;
2868028746 // arguments for call to FindData
2868128747 stack[base + 22LLU] = stack[base + 4]/*typedefs*/;
2868228748 stack[base + 23LLU] = stack[base + 16]/*typename*/;
@@ -28685,14 +28751,14 @@
2868528751 label = 1004LLU; // FindData
2868628752 break;
2868728753 }
28688- case 2352LLU: // copy-back deleter (FindData to initfrom)
28754+ case 2357LLU: // copy-back deleter (FindData to initfrom)
2868928755 {
2869028756 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
2869128757 // copy mutable arguments back from call to FindData
28692- label = 2316LLU; // continue to roll stack
28758+ label = 2321LLU; // continue to roll stack
2869328759 break;
2869428760 }
28695- case 2353LLU: // return from FindData to initfrom
28761+ case 2358LLU: // return from FindData to initfrom
2869628762 {
2869728763 // copy mutable arguments back from call to FindData
2869828764 // copy back results provided by call to FindData
@@ -28699,7 +28765,7 @@
2869928765 stack[base + 17] = stack[base + 21LLU];
2870028766 if(/*datadef*/0 != ((uint64_t *)(stack[base + 17]/*reftypedef*/))[0])
2870128767 {
28702- label = 2355LLU; // jump to alternative
28768+ label = 2360LLU; // jump to alternative
2870328769 break;
2870428770 }
2870528771
@@ -28709,9 +28775,9 @@
2870928775
2871028776 // case
2871128777 // call GetVariant from initfrom
28712- stack[base + 23LLU] = 2357LLU/*throw to this address*/;
28778+ stack[base + 23LLU] = 2362LLU/*throw to this address*/;
2871328779 stack[base + 24LLU] = base;
28714- stack[base + 25LLU] = 2358LLU;
28780+ stack[base + 25LLU] = 2363LLU;
2871528781 // arguments for call to GetVariant
2871628782 stack[base + 28LLU] = stack[base + 0]/*fnid*/;
2871728783 stack[base + 29LLU] = stack[base + 19]/*variants*/;
@@ -28721,14 +28787,14 @@
2872128787 label = 907LLU; // GetVariant
2872228788 break;
2872328789 }
28724- case 2357LLU: // copy-back deleter (GetVariant to initfrom)
28790+ case 2362LLU: // copy-back deleter (GetVariant to initfrom)
2872528791 {
2872628792 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
2872728793 // copy mutable arguments back from call to GetVariant
28728- label = 2356LLU; // continue to roll stack
28794+ label = 2361LLU; // continue to roll stack
2872928795 break;
2873028796 }
28731- case 2358LLU: // return from GetVariant to initfrom
28797+ case 2363LLU: // return from GetVariant to initfrom
2873228798 {
2873328799 // copy mutable arguments back from call to GetVariant
2873428800 // copy back results provided by call to GetVariant
@@ -28736,7 +28802,7 @@
2873628802 stack[base + 22] = stack[base + 27LLU];
2873728803 if(/*variant*/0 != ((uint64_t *)(stack[base + 22]/*constr*/))[0])
2873828804 {
28739- label = 2360LLU; // jump to alternative
28805+ label = 2365LLU; // jump to alternative
2874028806 break;
2874128807 }
2874228808
@@ -28744,29 +28810,29 @@
2874428810 /*TYPEIDS*/stack[base + 24] = ((uint64_t **)(stack[base + 22]/*constr*/))[1][1]/*elements*/;
2874528811
2874628812 // case
28747- label = 2363LLU; // skip deleter
28813+ label = 2368LLU; // skip deleter
2874828814 break;
2874928815 }
28750- case 2362LLU: // deleter
28816+ case 2367LLU: // deleter
2875128817 {
2875228818 // throw from initfrom
2875328819 if(!stack[base + 25])
2875428820 {
2875528821 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
28756- label = 2361LLU; // skip, variable already deleted/unscoped
28822+ label = 2366LLU; // skip, variable already deleted/unscoped
2875728823 break;
2875828824 }
2875928825 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
28760- label = 2361LLU; // continue unrolling stack, delete next variable
28826+ label = 2366LLU; // continue unrolling stack, delete next variable
2876128827 break;
2876228828 }
28763- case 2363LLU: // skipped deleter
28829+ case 2368LLU: // skipped deleter
2876428830 {
2876528831 stack[base + 25] = 0;
2876628832 stack[base + 25]/*size*/ = list_size(((struct listnode *)(stack[base + 24]/*TYPEIDS*/)));
2876728833 if(!stack[base + 14]/*forceerror*/)
2876828834 {
28769- label = 2364LLU; // jump to alternative
28835+ label = 2369LLU; // jump to alternative
2877028836 break;
2877128837 }
2877228838
@@ -28773,9 +28839,9 @@
2877328839 // consequent
2877428840 printf("%s", "\n // if(!(");
2877528841 // call emitvaridx from initfrom
28776- stack[base + 26LLU] = 2366LLU/*throw to this address*/;
28842+ stack[base + 26LLU] = 2371LLU/*throw to this address*/;
2877728843 stack[base + 27LLU] = base;
28778- stack[base + 28LLU] = 2367LLU;
28844+ stack[base + 28LLU] = 2372LLU;
2877928845 // arguments for call to emitvaridx
2878028846 stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2878128847 // set stack-base & callee-address
@@ -28783,21 +28849,21 @@
2878328849 label = 691LLU; // emitvaridx
2878428850 break;
2878528851 }
28786- case 2366LLU: // copy-back deleter (emitvaridx to initfrom)
28852+ case 2371LLU: // copy-back deleter (emitvaridx to initfrom)
2878728853 {
2878828854 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2878928855 // copy mutable arguments back from call to emitvaridx
28790- label = 2362LLU; // continue to roll stack
28856+ label = 2367LLU; // continue to roll stack
2879128857 break;
2879228858 }
28793- case 2367LLU: // return from emitvaridx to initfrom
28859+ case 2372LLU: // return from emitvaridx to initfrom
2879428860 {
2879528861 // copy mutable arguments back from call to emitvaridx
2879628862 printf("%s", " = construct(");
2879728863 // call printnr from initfrom
28798- stack[base + 26LLU] = 2368LLU/*throw to this address*/;
28864+ stack[base + 26LLU] = 2373LLU/*throw to this address*/;
2879928865 stack[base + 27LLU] = base;
28800- stack[base + 28LLU] = 2369LLU;
28866+ stack[base + 28LLU] = 2374LLU;
2880128867 // arguments for call to printnr
2880228868 stack[base + 29LLU] = stack[base + 25]/*size*/;
2880328869 // set stack-base & callee-address
@@ -28805,27 +28871,27 @@
2880528871 label = 18446744073709551590LLU; // printnr
2880628872 break;
2880728873 }
28808- case 2368LLU: // copy-back deleter (printnr to initfrom)
28874+ case 2373LLU: // copy-back deleter (printnr to initfrom)
2880928875 {
2881028876 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2881128877 // copy mutable arguments back from call to printnr
28812- label = 2362LLU; // continue to roll stack
28878+ label = 2367LLU; // continue to roll stack
2881328879 break;
2881428880 }
28815- case 2369LLU: // return from printnr to initfrom
28881+ case 2374LLU: // return from printnr to initfrom
2881628882 {
2881728883 // copy mutable arguments back from call to printnr
2881828884 printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
28819- label = 2365LLU; // consequent complete
28885+ label = 2370LLU; // consequent complete
2882028886 break;
2882128887 }
28822- case 2364LLU: // alternative
28888+ case 2369LLU: // alternative
2882328889 {
2882428890 printf("%s", "\n if(!(");
2882528891 // call emitvaridx from initfrom
28826- stack[base + 26LLU] = 2370LLU/*throw to this address*/;
28892+ stack[base + 26LLU] = 2375LLU/*throw to this address*/;
2882728893 stack[base + 27LLU] = base;
28828- stack[base + 28LLU] = 2371LLU;
28894+ stack[base + 28LLU] = 2376LLU;
2882928895 // arguments for call to emitvaridx
2883028896 stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2883128897 // set stack-base & callee-address
@@ -28833,21 +28899,21 @@
2883328899 label = 691LLU; // emitvaridx
2883428900 break;
2883528901 }
28836- case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
28902+ case 2375LLU: // copy-back deleter (emitvaridx to initfrom)
2883728903 {
2883828904 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2883928905 // copy mutable arguments back from call to emitvaridx
28840- label = 2362LLU; // continue to roll stack
28906+ label = 2367LLU; // continue to roll stack
2884128907 break;
2884228908 }
28843- case 2371LLU: // return from emitvaridx to initfrom
28909+ case 2376LLU: // return from emitvaridx to initfrom
2884428910 {
2884528911 // copy mutable arguments back from call to emitvaridx
2884628912 printf("%s", " = construct(");
2884728913 // call printnr from initfrom
28848- stack[base + 26LLU] = 2372LLU/*throw to this address*/;
28914+ stack[base + 26LLU] = 2377LLU/*throw to this address*/;
2884928915 stack[base + 27LLU] = base;
28850- stack[base + 28LLU] = 2373LLU;
28916+ stack[base + 28LLU] = 2378LLU;
2885128917 // arguments for call to printnr
2885228918 stack[base + 29LLU] = stack[base + 25]/*size*/;
2885328919 // set stack-base & callee-address
@@ -28855,26 +28921,26 @@
2885528921 label = 18446744073709551590LLU; // printnr
2885628922 break;
2885728923 }
28858- case 2372LLU: // copy-back deleter (printnr to initfrom)
28924+ case 2377LLU: // copy-back deleter (printnr to initfrom)
2885928925 {
2886028926 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2886128927 // copy mutable arguments back from call to printnr
28862- label = 2362LLU; // continue to roll stack
28928+ label = 2367LLU; // continue to roll stack
2886328929 break;
2886428930 }
28865- case 2373LLU: // return from printnr to initfrom
28931+ case 2378LLU: // return from printnr to initfrom
2886628932 {
2886728933 // copy mutable arguments back from call to printnr
2886828934 printf("%s", ")))");
28869- label = 2365LLU; // alternative complete
28935+ label = 2370LLU; // alternative complete
2887028936 break;
2887128937 }
28872- case 2365LLU: // completed if-then-else
28938+ case 2370LLU: // completed if-then-else
2887328939 {
2887428940 // call emitthrow from initfrom
28875- stack[base + 26LLU] = 2374LLU/*throw to this address*/;
28941+ stack[base + 26LLU] = 2379LLU/*throw to this address*/;
2887628942 stack[base + 27LLU] = base;
28877- stack[base + 28LLU] = 2375LLU;
28943+ stack[base + 28LLU] = 2380LLU;
2887828944 // arguments for call to emitthrow
2887928945 stack[base + 29LLU] = stack[base + 6]/*scope*/;
2888028946 // set stack-base & callee-address
@@ -28882,22 +28948,22 @@
2888228948 label = 1559LLU; // emitthrow
2888328949 break;
2888428950 }
28885- case 2374LLU: // copy-back deleter (emitthrow to initfrom)
28951+ case 2379LLU: // copy-back deleter (emitthrow to initfrom)
2888628952 {
2888728953 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
2888828954 // copy mutable arguments back from call to emitthrow
28889- label = 2362LLU; // continue to roll stack
28955+ label = 2367LLU; // continue to roll stack
2889028956 break;
2889128957 }
28892- case 2375LLU: // return from emitthrow to initfrom
28958+ case 2380LLU: // return from emitthrow to initfrom
2889328959 {
2889428960 // copy mutable arguments back from call to emitthrow
2889528961 printf("%s", "\n // consequent");
2889628962 printf("%s", "\n ((uint64_t *)");
2889728963 // call emitvaridx from initfrom
28898- stack[base + 26LLU] = 2376LLU/*throw to this address*/;
28964+ stack[base + 26LLU] = 2381LLU/*throw to this address*/;
2889928965 stack[base + 27LLU] = base;
28900- stack[base + 28LLU] = 2377LLU;
28966+ stack[base + 28LLU] = 2382LLU;
2890128967 // arguments for call to emitvaridx
2890228968 stack[base + 29LLU] = stack[base + 3]/*dstindex*/;
2890328969 // set stack-base & callee-address
@@ -28905,21 +28971,21 @@
2890528971 label = 691LLU; // emitvaridx
2890628972 break;
2890728973 }
28908- case 2376LLU: // copy-back deleter (emitvaridx to initfrom)
28974+ case 2381LLU: // copy-back deleter (emitvaridx to initfrom)
2890928975 {
2891028976 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2891128977 // copy mutable arguments back from call to emitvaridx
28912- label = 2362LLU; // continue to roll stack
28978+ label = 2367LLU; // continue to roll stack
2891328979 break;
2891428980 }
28915- case 2377LLU: // return from emitvaridx to initfrom
28981+ case 2382LLU: // return from emitvaridx to initfrom
2891628982 {
2891728983 // copy mutable arguments back from call to emitvaridx
2891828984 printf("%s", ")[0] = ");
2891928985 // call printnr from initfrom
28920- stack[base + 26LLU] = 2378LLU/*throw to this address*/;
28986+ stack[base + 26LLU] = 2383LLU/*throw to this address*/;
2892128987 stack[base + 27LLU] = base;
28922- stack[base + 28LLU] = 2379LLU;
28988+ stack[base + 28LLU] = 2384LLU;
2892328989 // arguments for call to printnr
2892428990 stack[base + 29LLU] = stack[base + 21]/*varnr*/;
2892528991 // set stack-base & callee-address
@@ -28927,21 +28993,21 @@
2892728993 label = 18446744073709551590LLU; // printnr
2892828994 break;
2892928995 }
28930- case 2378LLU: // copy-back deleter (printnr to initfrom)
28996+ case 2383LLU: // copy-back deleter (printnr to initfrom)
2893128997 {
2893228998 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2893328999 // copy mutable arguments back from call to printnr
28934- label = 2362LLU; // continue to roll stack
29000+ label = 2367LLU; // continue to roll stack
2893529001 break;
2893629002 }
28937- case 2379LLU: // return from printnr to initfrom
29003+ case 2384LLU: // return from printnr to initfrom
2893829004 {
2893929005 // copy mutable arguments back from call to printnr
2894029006 printf("%s", ";");
2894129007 // call matchsym from initfrom
28942- stack[base + 26LLU] = 2380LLU/*throw to this address*/;
29008+ stack[base + 26LLU] = 2385LLU/*throw to this address*/;
2894329009 stack[base + 27LLU] = base;
28944- stack[base + 28LLU] = 2381LLU;
29010+ stack[base + 28LLU] = 2386LLU;
2894529011 // arguments for call to matchsym
2894629012 stack[base + 29LLU] = stack[base + 0]/*fnid*/;
2894729013 stack[base + 30LLU] = 40LLU;
@@ -28951,46 +29017,46 @@
2895129017 label = 212LLU; // matchsym
2895229018 break;
2895329019 }
28954- case 2380LLU: // copy-back deleter (matchsym to initfrom)
29020+ case 2385LLU: // copy-back deleter (matchsym to initfrom)
2895529021 {
2895629022 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2895729023 // copy mutable arguments back from call to matchsym
2895829024 stack[base + 7]/*lookahead*/ = stack[base + 31LLU];
28959- label = 2362LLU; // continue to roll stack
29025+ label = 2367LLU; // continue to roll stack
2896029026 break;
2896129027 }
28962- case 2381LLU: // return from matchsym to initfrom
29028+ case 2386LLU: // return from matchsym to initfrom
2896329029 {
2896429030 // copy mutable arguments back from call to matchsym
2896529031 stack[base + 7]/*lookahead*/ = stack[base + 31LLU];
28966- label = 2383LLU; // skip deleter
29032+ label = 2388LLU; // skip deleter
2896729033 break;
2896829034 }
28969- case 2382LLU: // deleter
29035+ case 2387LLU: // deleter
2897029036 {
2897129037 // throw from initfrom
2897229038 if(!stack[base + 26])
2897329039 {
2897429040 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
28975- label = 2362LLU; // skip, variable already deleted/unscoped
29041+ label = 2367LLU; // skip, variable already deleted/unscoped
2897629042 break;
2897729043 }
2897829044 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
28979- label = 2362LLU; // continue unrolling stack, delete next variable
29045+ label = 2367LLU; // continue unrolling stack, delete next variable
2898029046 break;
2898129047 }
28982- case 2383LLU: // skipped deleter
29048+ case 2388LLU: // skipped deleter
2898329049 {
2898429050 stack[base + 26] = 0;
2898529051 flippedassign(stack[base + 24]/*TYPEIDS*/, &stack[base + 27]);
28986- label = 2384LLU; // start to repeat
29052+ label = 2389LLU; // start to repeat
2898729053 break;
2898829054 }
28989- case 2384LLU: // repeat from here
29055+ case 2389LLU: // repeat from here
2899029056 {
2899129057 if(!stack[base + 27])
2899229058 {
28993- label = 2385LLU; // break loop
29059+ label = 2390LLU; // break loop
2899429060 break;
2899529061 }
2899629062
@@ -29000,7 +29066,7 @@
2900029066 stack[base + 27] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->next);
2900129067 if(/*typeid*/0 != ((uint64_t *)(stack[base + 28]/*typeid*/))[0])
2900229068 {
29003- label = 2388LLU; // jump to alternative
29069+ label = 2393LLU; // jump to alternative
2900429070 break;
2900529071 }
2900629072
@@ -29010,15 +29076,15 @@
2901029076 // case
2901129077 if(!stack[base + 26]/*elemindex*/)
2901229078 {
29013- label = 2390LLU; // jump to alternative
29079+ label = 2395LLU; // jump to alternative
2901429080 break;
2901529081 }
2901629082
2901729083 // consequent
2901829084 // call matchsym from initfrom
29019- stack[base + 32LLU] = 2392LLU/*throw to this address*/;
29085+ stack[base + 32LLU] = 2397LLU/*throw to this address*/;
2902029086 stack[base + 33LLU] = base;
29021- stack[base + 34LLU] = 2393LLU;
29087+ stack[base + 34LLU] = 2398LLU;
2902229088 // arguments for call to matchsym
2902329089 stack[base + 35LLU] = stack[base + 0]/*fnid*/;
2902429090 stack[base + 36LLU] = 44LLU;
@@ -29028,32 +29094,32 @@
2902829094 label = 212LLU; // matchsym
2902929095 break;
2903029096 }
29031- case 2392LLU: // copy-back deleter (matchsym to initfrom)
29097+ case 2397LLU: // copy-back deleter (matchsym to initfrom)
2903229098 {
2903329099 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2903429100 // copy mutable arguments back from call to matchsym
2903529101 stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29036- label = 2389LLU; // continue to roll stack
29102+ label = 2394LLU; // continue to roll stack
2903729103 break;
2903829104 }
29039- case 2393LLU: // return from matchsym to initfrom
29105+ case 2398LLU: // return from matchsym to initfrom
2904029106 {
2904129107 // copy mutable arguments back from call to matchsym
2904229108 stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29043- label = 2391LLU; // consequent complete
29109+ label = 2396LLU; // consequent complete
2904429110 break;
2904529111 }
29046- case 2390LLU: // alternative
29112+ case 2395LLU: // alternative
2904729113 {
29048- label = 2391LLU; // alternative complete
29114+ label = 2396LLU; // alternative complete
2904929115 break;
2905029116 }
29051- case 2391LLU: // completed if-then-else
29117+ case 2396LLU: // completed if-then-else
2905229118 {
2905329119 // call ParseToken from initfrom
29054- stack[base + 32LLU] = 2394LLU/*throw to this address*/;
29120+ stack[base + 32LLU] = 2399LLU/*throw to this address*/;
2905529121 stack[base + 33LLU] = base;
29056- stack[base + 34LLU] = 2395LLU;
29122+ stack[base + 34LLU] = 2400LLU;
2905729123 // arguments for call to ParseToken
2905829124 stack[base + 37LLU] = stack[base + 7]/*lookahead*/;
2905929125 // set stack-base & callee-address
@@ -29061,15 +29127,15 @@
2906129127 label = 3LLU; // ParseToken
2906229128 break;
2906329129 }
29064- case 2394LLU: // copy-back deleter (ParseToken to initfrom)
29130+ case 2399LLU: // copy-back deleter (ParseToken to initfrom)
2906529131 {
2906629132 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
2906729133 // copy mutable arguments back from call to ParseToken
2906829134 stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
29069- label = 2389LLU; // continue to roll stack
29135+ label = 2394LLU; // continue to roll stack
2907029136 break;
2907129137 }
29072- case 2395LLU: // return from ParseToken to initfrom
29138+ case 2400LLU: // return from ParseToken to initfrom
2907329139 {
2907429140 // copy mutable arguments back from call to ParseToken
2907529141 stack[base + 7]/*lookahead*/ = stack[base + 37LLU];
@@ -29077,9 +29143,9 @@
2907729143 stack[base + 12] = stack[base + 35LLU];
2907829144 stack[base + 13] = stack[base + 36LLU];
2907929145 // call equ from initfrom
29080- stack[base + 32LLU] = 2396LLU/*throw to this address*/;
29146+ stack[base + 32LLU] = 2401LLU/*throw to this address*/;
2908129147 stack[base + 33LLU] = base;
29082- stack[base + 34LLU] = 2397LLU;
29148+ stack[base + 34LLU] = 2402LLU;
2908329149 // arguments for call to equ
2908429150 stack[base + 36LLU] = stack[base + 12]/*variant*/;
2908529151 stack[base + 37LLU] = 4LLU;
@@ -29088,14 +29154,14 @@
2908829154 label = 18446744073709551600LLU; // equ
2908929155 break;
2909029156 }
29091- case 2396LLU: // copy-back deleter (equ to initfrom)
29157+ case 2401LLU: // copy-back deleter (equ to initfrom)
2909229158 {
2909329159 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2909429160 // copy mutable arguments back from call to equ
29095- label = 2389LLU; // continue to roll stack
29161+ label = 2394LLU; // continue to roll stack
2909629162 break;
2909729163 }
29098- case 2397LLU: // return from equ to initfrom
29164+ case 2402LLU: // return from equ to initfrom
2909929165 {
2910029166 // copy mutable arguments back from call to equ
2910129167 // copy back results provided by call to equ
@@ -29102,21 +29168,21 @@
2910229168 stack[base + 10] = stack[base + 35LLU];
2910329169 if(!stack[base + 10]/*isequal*/)
2910429170 {
29105- label = 2398LLU; // jump to alternative
29171+ label = 2403LLU; // jump to alternative
2910629172 break;
2910729173 }
2910829174
2910929175 // consequent
29110- label = 2399LLU; // consequent complete
29176+ label = 2404LLU; // consequent complete
2911129177 break;
2911229178 }
29113- case 2398LLU: // alternative
29179+ case 2403LLU: // alternative
2911429180 {
2911529181 fprintf(stderr, "%s", "constructor requires variables but found ");
2911629182 // call reporttok from initfrom
29117- stack[base + 32LLU] = 2400LLU/*throw to this address*/;
29183+ stack[base + 32LLU] = 2405LLU/*throw to this address*/;
2911829184 stack[base + 33LLU] = base;
29119- stack[base + 34LLU] = 2401LLU;
29185+ stack[base + 34LLU] = 2406LLU;
2912029186 // arguments for call to reporttok
2912129187 stack[base + 35LLU] = stack[base + 12]/*variant*/;
2912229188 stack[base + 36LLU] = stack[base + 13]/*content*/;
@@ -29125,27 +29191,27 @@
2912529191 label = 18446744073709551582LLU; // reporttok
2912629192 break;
2912729193 }
29128- case 2400LLU: // copy-back deleter (reporttok to initfrom)
29194+ case 2405LLU: // copy-back deleter (reporttok to initfrom)
2912929195 {
2913029196 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
2913129197 // copy mutable arguments back from call to reporttok
29132- label = 2389LLU; // continue to roll stack
29198+ label = 2394LLU; // continue to roll stack
2913329199 break;
2913429200 }
29135- case 2401LLU: // return from reporttok to initfrom
29201+ case 2406LLU: // return from reporttok to initfrom
2913629202 {
2913729203 // copy mutable arguments back from call to reporttok
2913829204 fprintf(stderr, "%s", "\n");
2913929205 exit(-1);
29140- label = 2399LLU; // alternative complete
29206+ label = 2404LLU; // alternative complete
2914129207 break;
2914229208 }
29143- case 2399LLU: // completed if-then-else
29209+ case 2404LLU: // completed if-then-else
2914429210 {
2914529211 // call getlettype from initfrom
29146- stack[base + 33LLU] = 2402LLU/*throw to this address*/;
29212+ stack[base + 33LLU] = 2407LLU/*throw to this address*/;
2914729213 stack[base + 34LLU] = base;
29148- stack[base + 35LLU] = 2403LLU;
29214+ stack[base + 35LLU] = 2408LLU;
2914929215 // arguments for call to getlettype
2915029216 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
2915129217 stack[base + 38LLU] = stack[base + 13]/*content*/;
@@ -29156,14 +29222,14 @@
2915629222 label = 651LLU; // getlettype
2915729223 break;
2915829224 }
29159- case 2402LLU: // copy-back deleter (getlettype to initfrom)
29225+ case 2407LLU: // copy-back deleter (getlettype to initfrom)
2916029226 {
2916129227 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
2916229228 // copy mutable arguments back from call to getlettype
29163- label = 2389LLU; // continue to roll stack
29229+ label = 2394LLU; // continue to roll stack
2916429230 break;
2916529231 }
29166- case 2403LLU: // return from getlettype to initfrom
29232+ case 2408LLU: // return from getlettype to initfrom
2916729233 {
2916829234 // copy mutable arguments back from call to getlettype
2916929235 // copy back results provided by call to getlettype
@@ -29171,7 +29237,7 @@
2917129237 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
2917229238 if(!newstack)
2917329239 {
29174- label = 2389LLU; // throw: begin to unroll stack
29240+ label = 2394LLU; // throw: begin to unroll stack
2917529241 break;
2917629242 }
2917729243
@@ -29178,9 +29244,9 @@
2917829244 newstack[15LLU] = 9876543210LLU; // overflow-marker
2917929245 // call equtype from initfrom
2918029246 newstack[0] = (uint64_t)stack; // backup stack location
29181- newstack[1] = 2404LLU;
29247+ newstack[1] = 2409LLU;
2918229248 newstack[2] = base;
29183- newstack[3] = 2405LLU;
29249+ newstack[3] = 2410LLU;
2918429250 // arguments for call to equtype
2918529251 newstack[5LLU] = stack[base + 30]/*dsttype*/;
2918629252 newstack[6LLU] = stack[base + 32]/*srctype*/;
@@ -29190,7 +29256,7 @@
2919029256 label = 342LLU; // equtype
2919129257 break;
2919229258 }
29193- case 2404LLU: // copy-back deleter (equtype to initfrom)
29259+ case 2409LLU: // copy-back deleter (equtype to initfrom)
2919429260 {
2919529261 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
2919629262 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29202,10 +29268,10 @@
2920229268 }
2920329269 Free(15LLU + 1, sizeof(uint64_t), stack);
2920429270 stack = oldstack;
29205- label = 2389LLU; // continue to unroll stack
29271+ label = 2394LLU; // continue to unroll stack
2920629272 break;
2920729273 }
29208- case 2405LLU: // return from equtype to initfrom
29274+ case 2410LLU: // return from equtype to initfrom
2920929275 {
2921029276 uint64_t *oldstack = (uint64_t *)stack[0];
2921129277 // copy mutable arguments back from call to equtype
@@ -29220,7 +29286,7 @@
2922029286 stack = oldstack;
2922129287 if(!stack[base + 10]/*isequal*/)
2922229288 {
29223- label = 2406LLU; // jump to alternative
29289+ label = 2411LLU; // jump to alternative
2922429290 break;
2922529291 }
2922629292
@@ -29227,7 +29293,7 @@
2922729293 // consequent
2922829294 if(/*typename*/0 != ((uint64_t *)(stack[base + 30]/*dsttype*/))[0])
2922929295 {
29230- label = 2409LLU; // jump to alternative
29296+ label = 2414LLU; // jump to alternative
2923129297 break;
2923229298 }
2923329299
@@ -29235,9 +29301,9 @@
2923529301
2923629302 // case
2923729303 // call equ from initfrom
29238- stack[base + 34LLU] = 2411LLU/*throw to this address*/;
29304+ stack[base + 34LLU] = 2416LLU/*throw to this address*/;
2923929305 stack[base + 35LLU] = base;
29240- stack[base + 36LLU] = 2412LLU;
29306+ stack[base + 36LLU] = 2417LLU;
2924129307 // arguments for call to equ
2924229308 stack[base + 38LLU] = 881834713755418624LLU;
2924329309 stack[base + 39LLU] = stack[base + 33]/*name*/;
@@ -29246,14 +29312,14 @@
2924629312 label = 18446744073709551600LLU; // equ
2924729313 break;
2924829314 }
29249- case 2411LLU: // copy-back deleter (equ to initfrom)
29315+ case 2416LLU: // copy-back deleter (equ to initfrom)
2925029316 {
2925129317 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2925229318 // copy mutable arguments back from call to equ
29253- label = 2410LLU; // continue to roll stack
29319+ label = 2415LLU; // continue to roll stack
2925429320 break;
2925529321 }
29256- case 2412LLU: // return from equ to initfrom
29322+ case 2417LLU: // return from equ to initfrom
2925729323 {
2925829324 // copy mutable arguments back from call to equ
2925929325 // copy back results provided by call to equ
@@ -29260,7 +29326,7 @@
2926029326 stack[base + 10] = stack[base + 37LLU];
2926129327 if(!stack[base + 10]/*isequal*/)
2926229328 {
29263- label = 2413LLU; // jump to alternative
29329+ label = 2418LLU; // jump to alternative
2926429330 break;
2926529331 }
2926629332
@@ -29267,9 +29333,9 @@
2926729333 // consequent
2926829334 printf("%s", "\n (((uint64_t **)(");
2926929335 // call emitvaridx from initfrom
29270- stack[base + 34LLU] = 2415LLU/*throw to this address*/;
29336+ stack[base + 34LLU] = 2420LLU/*throw to this address*/;
2927129337 stack[base + 35LLU] = base;
29272- stack[base + 36LLU] = 2416LLU;
29338+ stack[base + 36LLU] = 2421LLU;
2927329339 // arguments for call to emitvaridx
2927429340 stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
2927529341 // set stack-base & callee-address
@@ -29277,21 +29343,21 @@
2927729343 label = 691LLU; // emitvaridx
2927829344 break;
2927929345 }
29280- case 2415LLU: // copy-back deleter (emitvaridx to initfrom)
29346+ case 2420LLU: // copy-back deleter (emitvaridx to initfrom)
2928129347 {
2928229348 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2928329349 // copy mutable arguments back from call to emitvaridx
29284- label = 2410LLU; // continue to roll stack
29350+ label = 2415LLU; // continue to roll stack
2928529351 break;
2928629352 }
29287- case 2416LLU: // return from emitvaridx to initfrom
29353+ case 2421LLU: // return from emitvaridx to initfrom
2928829354 {
2928929355 // copy mutable arguments back from call to emitvaridx
2929029356 printf("%s", "))[1][");
2929129357 // call printnr from initfrom
29292- stack[base + 34LLU] = 2417LLU/*throw to this address*/;
29358+ stack[base + 34LLU] = 2422LLU/*throw to this address*/;
2929329359 stack[base + 35LLU] = base;
29294- stack[base + 36LLU] = 2418LLU;
29360+ stack[base + 36LLU] = 2423LLU;
2929529361 // arguments for call to printnr
2929629362 stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
2929729363 // set stack-base & callee-address
@@ -29299,21 +29365,21 @@
2929929365 label = 18446744073709551590LLU; // printnr
2930029366 break;
2930129367 }
29302- case 2417LLU: // copy-back deleter (printnr to initfrom)
29368+ case 2422LLU: // copy-back deleter (printnr to initfrom)
2930329369 {
2930429370 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2930529371 // copy mutable arguments back from call to printnr
29306- label = 2410LLU; // continue to roll stack
29372+ label = 2415LLU; // continue to roll stack
2930729373 break;
2930829374 }
29309- case 2418LLU: // return from printnr to initfrom
29375+ case 2423LLU: // return from printnr to initfrom
2931029376 {
2931129377 // copy mutable arguments back from call to printnr
2931229378 printf("%s", "]) = ");
2931329379 // call emitvar from initfrom
29314- stack[base + 34LLU] = 2419LLU/*throw to this address*/;
29380+ stack[base + 34LLU] = 2424LLU/*throw to this address*/;
2931529381 stack[base + 35LLU] = base;
29316- stack[base + 36LLU] = 2420LLU;
29382+ stack[base + 36LLU] = 2425LLU;
2931729383 // arguments for call to emitvar
2931829384 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
2931929385 stack[base + 38LLU] = stack[base + 13]/*content*/;
@@ -29324,27 +29390,27 @@
2932429390 label = 695LLU; // emitvar
2932529391 break;
2932629392 }
29327- case 2419LLU: // copy-back deleter (emitvar to initfrom)
29393+ case 2424LLU: // copy-back deleter (emitvar to initfrom)
2932829394 {
2932929395 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2933029396 // copy mutable arguments back from call to emitvar
29331- label = 2410LLU; // continue to roll stack
29397+ label = 2415LLU; // continue to roll stack
2933229398 break;
2933329399 }
29334- case 2420LLU: // return from emitvar to initfrom
29400+ case 2425LLU: // return from emitvar to initfrom
2933529401 {
2933629402 // copy mutable arguments back from call to emitvar
2933729403 printf("%s", ";");
29338- label = 2414LLU; // consequent complete
29404+ label = 2419LLU; // consequent complete
2933929405 break;
2934029406 }
29341- case 2413LLU: // alternative
29407+ case 2418LLU: // alternative
2934229408 {
2934329409 printf("%s", "\n INIT(&(((uint64_t **)(");
2934429410 // call emitvaridx from initfrom
29345- stack[base + 34LLU] = 2421LLU/*throw to this address*/;
29411+ stack[base + 34LLU] = 2426LLU/*throw to this address*/;
2934629412 stack[base + 35LLU] = base;
29347- stack[base + 36LLU] = 2422LLU;
29413+ stack[base + 36LLU] = 2427LLU;
2934829414 // arguments for call to emitvaridx
2934929415 stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
2935029416 // set stack-base & callee-address
@@ -29352,21 +29418,21 @@
2935229418 label = 691LLU; // emitvaridx
2935329419 break;
2935429420 }
29355- case 2421LLU: // copy-back deleter (emitvaridx to initfrom)
29421+ case 2426LLU: // copy-back deleter (emitvaridx to initfrom)
2935629422 {
2935729423 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2935829424 // copy mutable arguments back from call to emitvaridx
29359- label = 2410LLU; // continue to roll stack
29425+ label = 2415LLU; // continue to roll stack
2936029426 break;
2936129427 }
29362- case 2422LLU: // return from emitvaridx to initfrom
29428+ case 2427LLU: // return from emitvaridx to initfrom
2936329429 {
2936429430 // copy mutable arguments back from call to emitvaridx
2936529431 printf("%s", "))[1][");
2936629432 // call printnr from initfrom
29367- stack[base + 34LLU] = 2423LLU/*throw to this address*/;
29433+ stack[base + 34LLU] = 2428LLU/*throw to this address*/;
2936829434 stack[base + 35LLU] = base;
29369- stack[base + 36LLU] = 2424LLU;
29435+ stack[base + 36LLU] = 2429LLU;
2937029436 // arguments for call to printnr
2937129437 stack[base + 37LLU] = stack[base + 26]/*elemindex*/;
2937229438 // set stack-base & callee-address
@@ -29374,21 +29440,21 @@
2937429440 label = 18446744073709551590LLU; // printnr
2937529441 break;
2937629442 }
29377- case 2423LLU: // copy-back deleter (printnr to initfrom)
29443+ case 2428LLU: // copy-back deleter (printnr to initfrom)
2937829444 {
2937929445 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2938029446 // copy mutable arguments back from call to printnr
29381- label = 2410LLU; // continue to roll stack
29447+ label = 2415LLU; // continue to roll stack
2938229448 break;
2938329449 }
29384- case 2424LLU: // return from printnr to initfrom
29450+ case 2429LLU: // return from printnr to initfrom
2938529451 {
2938629452 // copy mutable arguments back from call to printnr
2938729453 printf("%s", "]), &");
2938829454 // call emitvar from initfrom
29389- stack[base + 34LLU] = 2425LLU/*throw to this address*/;
29455+ stack[base + 34LLU] = 2430LLU/*throw to this address*/;
2939029456 stack[base + 35LLU] = base;
29391- stack[base + 36LLU] = 2426LLU;
29457+ stack[base + 36LLU] = 2431LLU;
2939229458 // arguments for call to emitvar
2939329459 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
2939429460 stack[base + 38LLU] = stack[base + 13]/*content*/;
@@ -29399,21 +29465,21 @@
2939929465 label = 695LLU; // emitvar
2940029466 break;
2940129467 }
29402- case 2425LLU: // copy-back deleter (emitvar to initfrom)
29468+ case 2430LLU: // copy-back deleter (emitvar to initfrom)
2940329469 {
2940429470 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2940529471 // copy mutable arguments back from call to emitvar
29406- label = 2410LLU; // continue to roll stack
29472+ label = 2415LLU; // continue to roll stack
2940729473 break;
2940829474 }
29409- case 2426LLU: // return from emitvar to initfrom
29475+ case 2431LLU: // return from emitvar to initfrom
2941029476 {
2941129477 // copy mutable arguments back from call to emitvar
2941229478 printf("%s", ");");
2941329479 // call unscopelet from initfrom
29414- stack[base + 34LLU] = 2427LLU/*throw to this address*/;
29480+ stack[base + 34LLU] = 2432LLU/*throw to this address*/;
2941529481 stack[base + 35LLU] = base;
29416- stack[base + 36LLU] = 2428LLU;
29482+ stack[base + 36LLU] = 2433LLU;
2941729483 // arguments for call to unscopelet
2941829484 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
2941929485 stack[base + 38LLU] = stack[base + 6]/*scope*/;
@@ -29423,41 +29489,41 @@
2942329489 label = 761LLU; // unscopelet
2942429490 break;
2942529491 }
29426- case 2427LLU: // copy-back deleter (unscopelet to initfrom)
29492+ case 2432LLU: // copy-back deleter (unscopelet to initfrom)
2942729493 {
2942829494 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2942929495 // copy mutable arguments back from call to unscopelet
2943029496 stack[base + 6]/*scope*/ = stack[base + 38LLU];
29431- label = 2410LLU; // continue to roll stack
29497+ label = 2415LLU; // continue to roll stack
2943229498 break;
2943329499 }
29434- case 2428LLU: // return from unscopelet to initfrom
29500+ case 2433LLU: // return from unscopelet to initfrom
2943529501 {
2943629502 // copy mutable arguments back from call to unscopelet
2943729503 stack[base + 6]/*scope*/ = stack[base + 38LLU];
29438- label = 2414LLU; // alternative complete
29504+ label = 2419LLU; // alternative complete
2943929505 break;
2944029506 }
29441- case 2414LLU: // completed if-then-else
29507+ case 2419LLU: // completed if-then-else
2944229508 {
2944329509 ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29444- label = 2408LLU; // case complete
29510+ label = 2413LLU; // case complete
2944529511 break;
2944629512 }
29447- case 2410LLU: // copy-back deleter (switch)
29513+ case 2415LLU: // copy-back deleter (switch)
2944829514 {
2944929515 ((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29450- label = 2389LLU; // continue to unroll stack
29516+ label = 2394LLU; // continue to unroll stack
2945129517 break;
2945229518 }
29453- case 2409LLU: // try next case
29519+ case 2414LLU: // try next case
2945429520 {
2945529521 // default
2945629522 printf("%s", "\n INIT(&(((uint64_t **)(");
2945729523 // call emitvaridx from initfrom
29458- stack[base + 33LLU] = 2429LLU/*throw to this address*/;
29524+ stack[base + 33LLU] = 2434LLU/*throw to this address*/;
2945929525 stack[base + 34LLU] = base;
29460- stack[base + 35LLU] = 2430LLU;
29526+ stack[base + 35LLU] = 2435LLU;
2946129527 // arguments for call to emitvaridx
2946229528 stack[base + 36LLU] = stack[base + 3]/*dstindex*/;
2946329529 // set stack-base & callee-address
@@ -29465,21 +29531,21 @@
2946529531 label = 691LLU; // emitvaridx
2946629532 break;
2946729533 }
29468- case 2429LLU: // copy-back deleter (emitvaridx to initfrom)
29534+ case 2434LLU: // copy-back deleter (emitvaridx to initfrom)
2946929535 {
2947029536 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
2947129537 // copy mutable arguments back from call to emitvaridx
29472- label = 2389LLU; // continue to roll stack
29538+ label = 2394LLU; // continue to roll stack
2947329539 break;
2947429540 }
29475- case 2430LLU: // return from emitvaridx to initfrom
29541+ case 2435LLU: // return from emitvaridx to initfrom
2947629542 {
2947729543 // copy mutable arguments back from call to emitvaridx
2947829544 printf("%s", "))[1][");
2947929545 // call printnr from initfrom
29480- stack[base + 33LLU] = 2431LLU/*throw to this address*/;
29546+ stack[base + 33LLU] = 2436LLU/*throw to this address*/;
2948129547 stack[base + 34LLU] = base;
29482- stack[base + 35LLU] = 2432LLU;
29548+ stack[base + 35LLU] = 2437LLU;
2948329549 // arguments for call to printnr
2948429550 stack[base + 36LLU] = stack[base + 26]/*elemindex*/;
2948529551 // set stack-base & callee-address
@@ -29487,21 +29553,21 @@
2948729553 label = 18446744073709551590LLU; // printnr
2948829554 break;
2948929555 }
29490- case 2431LLU: // copy-back deleter (printnr to initfrom)
29556+ case 2436LLU: // copy-back deleter (printnr to initfrom)
2949129557 {
2949229558 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
2949329559 // copy mutable arguments back from call to printnr
29494- label = 2389LLU; // continue to roll stack
29560+ label = 2394LLU; // continue to roll stack
2949529561 break;
2949629562 }
29497- case 2432LLU: // return from printnr to initfrom
29563+ case 2437LLU: // return from printnr to initfrom
2949829564 {
2949929565 // copy mutable arguments back from call to printnr
2950029566 printf("%s", "]), &");
2950129567 // call emitvar from initfrom
29502- stack[base + 33LLU] = 2433LLU/*throw to this address*/;
29568+ stack[base + 33LLU] = 2438LLU/*throw to this address*/;
2950329569 stack[base + 34LLU] = base;
29504- stack[base + 35LLU] = 2434LLU;
29570+ stack[base + 35LLU] = 2439LLU;
2950529571 // arguments for call to emitvar
2950629572 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2950729573 stack[base + 37LLU] = stack[base + 13]/*content*/;
@@ -29512,21 +29578,21 @@
2951229578 label = 695LLU; // emitvar
2951329579 break;
2951429580 }
29515- case 2433LLU: // copy-back deleter (emitvar to initfrom)
29581+ case 2438LLU: // copy-back deleter (emitvar to initfrom)
2951629582 {
2951729583 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
2951829584 // copy mutable arguments back from call to emitvar
29519- label = 2389LLU; // continue to roll stack
29585+ label = 2394LLU; // continue to roll stack
2952029586 break;
2952129587 }
29522- case 2434LLU: // return from emitvar to initfrom
29588+ case 2439LLU: // return from emitvar to initfrom
2952329589 {
2952429590 // copy mutable arguments back from call to emitvar
2952529591 printf("%s", ");");
2952629592 // call unscopelet from initfrom
29527- stack[base + 33LLU] = 2435LLU/*throw to this address*/;
29593+ stack[base + 33LLU] = 2440LLU/*throw to this address*/;
2952829594 stack[base + 34LLU] = base;
29529- stack[base + 35LLU] = 2436LLU;
29595+ stack[base + 35LLU] = 2441LLU;
2953029596 // arguments for call to unscopelet
2953129597 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2953229598 stack[base + 37LLU] = stack[base + 6]/*scope*/;
@@ -29536,33 +29602,33 @@
2953629602 label = 761LLU; // unscopelet
2953729603 break;
2953829604 }
29539- case 2435LLU: // copy-back deleter (unscopelet to initfrom)
29605+ case 2440LLU: // copy-back deleter (unscopelet to initfrom)
2954029606 {
2954129607 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
2954229608 // copy mutable arguments back from call to unscopelet
2954329609 stack[base + 6]/*scope*/ = stack[base + 37LLU];
29544- label = 2389LLU; // continue to roll stack
29610+ label = 2394LLU; // continue to roll stack
2954529611 break;
2954629612 }
29547- case 2436LLU: // return from unscopelet to initfrom
29613+ case 2441LLU: // return from unscopelet to initfrom
2954829614 {
2954929615 // copy mutable arguments back from call to unscopelet
2955029616 stack[base + 6]/*scope*/ = stack[base + 37LLU];
29551- label = 2408LLU; // default complete
29617+ label = 2413LLU; // default complete
2955229618 break;
2955329619 }
29554- case 2408LLU: // completed switch
29620+ case 2413LLU: // completed switch
2955529621 {
29556- label = 2407LLU; // consequent complete
29622+ label = 2412LLU; // consequent complete
2955729623 break;
2955829624 }
29559- case 2406LLU: // alternative
29625+ case 2411LLU: // alternative
2956029626 {
2956129627 fprintf(stderr, "%s", "in function ");
2956229628 // call reportid from initfrom
29563- stack[base + 33LLU] = 2437LLU/*throw to this address*/;
29629+ stack[base + 33LLU] = 2442LLU/*throw to this address*/;
2956429630 stack[base + 34LLU] = base;
29565- stack[base + 35LLU] = 2438LLU;
29631+ stack[base + 35LLU] = 2443LLU;
2956629632 // arguments for call to reportid
2956729633 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
2956829634 // set stack-base & callee-address
@@ -29570,14 +29636,14 @@
2957029636 label = 18446744073709551586LLU; // reportid
2957129637 break;
2957229638 }
29573- case 2437LLU: // copy-back deleter (reportid to initfrom)
29639+ case 2442LLU: // copy-back deleter (reportid to initfrom)
2957429640 {
2957529641 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2957629642 // copy mutable arguments back from call to reportid
29577- label = 2389LLU; // continue to roll stack
29643+ label = 2394LLU; // continue to roll stack
2957829644 break;
2957929645 }
29580- case 2438LLU: // return from reportid to initfrom
29646+ case 2443LLU: // return from reportid to initfrom
2958129647 {
2958229648 // copy mutable arguments back from call to reportid
2958329649 fprintf(stderr, "%s", ": constructor of type ");
@@ -29584,7 +29650,7 @@
2958429650 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2958529651 if(!newstack)
2958629652 {
29587- label = 2389LLU; // throw: begin to unroll stack
29653+ label = 2394LLU; // throw: begin to unroll stack
2958829654 break;
2958929655 }
2959029656
@@ -29591,9 +29657,9 @@
2959129657 newstack[10LLU] = 9876543210LLU; // overflow-marker
2959229658 // call reporttype from initfrom
2959329659 newstack[0] = (uint64_t)stack; // backup stack location
29594- newstack[1] = 2439LLU;
29660+ newstack[1] = 2444LLU;
2959529661 newstack[2] = base;
29596- newstack[3] = 2440LLU;
29662+ newstack[3] = 2445LLU;
2959729663 // arguments for call to reporttype
2959829664 newstack[4LLU] = stack[base + 30]/*dsttype*/;
2959929665 stack = newstack;
@@ -29602,7 +29668,7 @@
2960229668 label = 316LLU; // reporttype
2960329669 break;
2960429670 }
29605- case 2439LLU: // copy-back deleter (reporttype to initfrom)
29671+ case 2444LLU: // copy-back deleter (reporttype to initfrom)
2960629672 {
2960729673 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2960829674 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29614,10 +29680,10 @@
2961429680 }
2961529681 Free(10LLU + 1, sizeof(uint64_t), stack);
2961629682 stack = oldstack;
29617- label = 2389LLU; // continue to unroll stack
29683+ label = 2394LLU; // continue to unroll stack
2961829684 break;
2961929685 }
29620- case 2440LLU: // return from reporttype to initfrom
29686+ case 2445LLU: // return from reporttype to initfrom
2962129687 {
2962229688 uint64_t *oldstack = (uint64_t *)stack[0];
2962329689 // copy mutable arguments back from call to reporttype
@@ -29632,7 +29698,7 @@
2963229698 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2963329699 if(!newstack)
2963429700 {
29635- label = 2389LLU; // throw: begin to unroll stack
29701+ label = 2394LLU; // throw: begin to unroll stack
2963629702 break;
2963729703 }
2963829704
@@ -29639,9 +29705,9 @@
2963929705 newstack[10LLU] = 9876543210LLU; // overflow-marker
2964029706 // call reporttype from initfrom
2964129707 newstack[0] = (uint64_t)stack; // backup stack location
29642- newstack[1] = 2441LLU;
29708+ newstack[1] = 2446LLU;
2964329709 newstack[2] = base;
29644- newstack[3] = 2442LLU;
29710+ newstack[3] = 2447LLU;
2964529711 // arguments for call to reporttype
2964629712 newstack[4LLU] = stack[base + 30]/*dsttype*/;
2964729713 stack = newstack;
@@ -29650,7 +29716,7 @@
2965029716 label = 316LLU; // reporttype
2965129717 break;
2965229718 }
29653- case 2441LLU: // copy-back deleter (reporttype to initfrom)
29719+ case 2446LLU: // copy-back deleter (reporttype to initfrom)
2965429720 {
2965529721 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2965629722 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29662,10 +29728,10 @@
2966229728 }
2966329729 Free(10LLU + 1, sizeof(uint64_t), stack);
2966429730 stack = oldstack;
29665- label = 2389LLU; // continue to unroll stack
29731+ label = 2394LLU; // continue to unroll stack
2966629732 break;
2966729733 }
29668- case 2442LLU: // return from reporttype to initfrom
29734+ case 2447LLU: // return from reporttype to initfrom
2966929735 {
2967029736 uint64_t *oldstack = (uint64_t *)stack[0];
2967129737 // copy mutable arguments back from call to reporttype
@@ -29680,7 +29746,7 @@
2968029746 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
2968129747 if(!newstack)
2968229748 {
29683- label = 2389LLU; // throw: begin to unroll stack
29749+ label = 2394LLU; // throw: begin to unroll stack
2968429750 break;
2968529751 }
2968629752
@@ -29687,9 +29753,9 @@
2968729753 newstack[10LLU] = 9876543210LLU; // overflow-marker
2968829754 // call reporttype from initfrom
2968929755 newstack[0] = (uint64_t)stack; // backup stack location
29690- newstack[1] = 2443LLU;
29756+ newstack[1] = 2448LLU;
2969129757 newstack[2] = base;
29692- newstack[3] = 2444LLU;
29758+ newstack[3] = 2449LLU;
2969329759 // arguments for call to reporttype
2969429760 newstack[4LLU] = stack[base + 32]/*srctype*/;
2969529761 stack = newstack;
@@ -29698,7 +29764,7 @@
2969829764 label = 316LLU; // reporttype
2969929765 break;
2970029766 }
29701- case 2443LLU: // copy-back deleter (reporttype to initfrom)
29767+ case 2448LLU: // copy-back deleter (reporttype to initfrom)
2970229768 {
2970329769 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
2970429770 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -29710,10 +29776,10 @@
2971029776 }
2971129777 Free(10LLU + 1, sizeof(uint64_t), stack);
2971229778 stack = oldstack;
29713- label = 2389LLU; // continue to unroll stack
29779+ label = 2394LLU; // continue to unroll stack
2971429780 break;
2971529781 }
29716- case 2444LLU: // return from reporttype to initfrom
29782+ case 2449LLU: // return from reporttype to initfrom
2971729783 {
2971829784 uint64_t *oldstack = (uint64_t *)stack[0];
2971929785 // copy mutable arguments back from call to reporttype
@@ -29726,9 +29792,9 @@
2972629792 stack = oldstack;
2972729793 fprintf(stderr, "%s", " ");
2972829794 // call reportid from initfrom
29729- stack[base + 33LLU] = 2445LLU/*throw to this address*/;
29795+ stack[base + 33LLU] = 2450LLU/*throw to this address*/;
2973029796 stack[base + 34LLU] = base;
29731- stack[base + 35LLU] = 2446LLU;
29797+ stack[base + 35LLU] = 2451LLU;
2973229798 // arguments for call to reportid
2973329799 stack[base + 36LLU] = stack[base + 13]/*content*/;
2973429800 // set stack-base & callee-address
@@ -29736,22 +29802,22 @@
2973629802 label = 18446744073709551586LLU; // reportid
2973729803 break;
2973829804 }
29739- case 2445LLU: // copy-back deleter (reportid to initfrom)
29805+ case 2450LLU: // copy-back deleter (reportid to initfrom)
2974029806 {
2974129807 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
2974229808 // copy mutable arguments back from call to reportid
29743- label = 2389LLU; // continue to roll stack
29809+ label = 2394LLU; // continue to roll stack
2974429810 break;
2974529811 }
29746- case 2446LLU: // return from reportid to initfrom
29812+ case 2451LLU: // return from reportid to initfrom
2974729813 {
2974829814 // copy mutable arguments back from call to reportid
2974929815 fprintf(stderr, "%s", "\n");
2975029816 exit(-1);
29751- label = 2407LLU; // alternative complete
29817+ label = 2412LLU; // alternative complete
2975229818 break;
2975329819 }
29754- case 2407LLU: // completed if-then-else
29820+ case 2412LLU: // completed if-then-else
2975529821 {
2975629822
2975729823 uint64_t *newstack = (uint64_t *)(stack[base + 32] - sizeof(uint64_t) * 4);
@@ -29759,7 +29825,7 @@
2975929825 newstack[0] = (uint64_t)stack; // backup stack location
2976029826 newstack[1] = 1234567890;
2976129827 newstack[2] = base;
29762- newstack[3] = 2447LLU;
29828+ newstack[3] = 2452LLU;
2976329829 stack = newstack;
2976429830 // set stack-base & callee-address
2976529831 base = 4/*deloffset*/;
@@ -29766,7 +29832,7 @@
2976629832 label = 296LLU; // ~type
2976729833 break;
2976829834 }
29769- case 2447LLU: // return from ~type to initfrom
29835+ case 2452LLU: // return from ~type to initfrom
2977029836 {
2977129837 stack = (uint64_t *)stack[0];
2977229838 // releasing toplevel container
@@ -29774,27 +29840,27 @@
2977429840
2977529841 ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
2977629842 ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29777- label = 2387LLU; // case complete
29843+ label = 2392LLU; // case complete
2977829844 break;
2977929845 }
29780- case 2389LLU: // copy-back deleter (switch)
29846+ case 2394LLU: // copy-back deleter (switch)
2978129847 {
2978229848 ((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
2978329849 ((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29784- label = 2386LLU; // continue to unroll stack
29850+ label = 2391LLU; // continue to unroll stack
2978529851 break;
2978629852 }
29787- case 2388LLU: // try next case
29853+ case 2393LLU: // try next case
2978829854 {
2978929855 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2979029856 exit(-1);
2979129857 }
29792- case 2387LLU: // completed switch
29858+ case 2392LLU: // completed switch
2979329859 {
2979429860 // call add from initfrom
29795- stack[base + 30LLU] = 2448LLU/*throw to this address*/;
29861+ stack[base + 30LLU] = 2453LLU/*throw to this address*/;
2979629862 stack[base + 31LLU] = base;
29797- stack[base + 32LLU] = 2449LLU;
29863+ stack[base + 32LLU] = 2454LLU;
2979829864 // arguments for call to add
2979929865 stack[base + 34LLU] = stack[base + 26]/*elemindex*/;
2980029866 stack[base + 35LLU] = 1LLU;
@@ -29803,34 +29869,34 @@
2980329869 label = 18446744073709551605LLU; // add
2980429870 break;
2980529871 }
29806- case 2448LLU: // copy-back deleter (add to initfrom)
29872+ case 2453LLU: // copy-back deleter (add to initfrom)
2980729873 {
2980829874 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
2980929875 // copy mutable arguments back from call to add
29810- label = 2386LLU; // continue to roll stack
29876+ label = 2391LLU; // continue to roll stack
2981129877 break;
2981229878 }
29813- case 2449LLU: // return from add to initfrom
29879+ case 2454LLU: // return from add to initfrom
2981429880 {
2981529881 // copy mutable arguments back from call to add
2981629882 // copy back results provided by call to add
2981729883 stack[base + 26] = stack[base + 33LLU];
2981829884 ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
29819- label = 2384LLU; // repeat
29885+ label = 2389LLU; // repeat
2982029886 break;
2982129887 }
29822- case 2386LLU: // copy-back deleter for while next
29888+ case 2391LLU: // copy-back deleter for while next
2982329889 {
2982429890 ((struct listnode *)(stack[base + 29]/*previous*/))->data = stack[base + 28];
29825- label = 2382LLU; // continue to unroll stack
29891+ label = 2387LLU; // continue to unroll stack
2982629892 break;
2982729893 }
29828- case 2385LLU: // loop finished
29894+ case 2390LLU: // loop finished
2982929895 {
2983029896 // call matchsym from initfrom
29831- stack[base + 30LLU] = 2450LLU/*throw to this address*/;
29897+ stack[base + 30LLU] = 2455LLU/*throw to this address*/;
2983229898 stack[base + 31LLU] = base;
29833- stack[base + 32LLU] = 2451LLU;
29899+ stack[base + 32LLU] = 2456LLU;
2983429900 // arguments for call to matchsym
2983529901 stack[base + 33LLU] = stack[base + 0]/*fnid*/;
2983629902 stack[base + 34LLU] = 41LLU;
@@ -29840,36 +29906,36 @@
2984029906 label = 212LLU; // matchsym
2984129907 break;
2984229908 }
29843- case 2450LLU: // copy-back deleter (matchsym to initfrom)
29909+ case 2455LLU: // copy-back deleter (matchsym to initfrom)
2984429910 {
2984529911 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
2984629912 // copy mutable arguments back from call to matchsym
2984729913 stack[base + 7]/*lookahead*/ = stack[base + 35LLU];
29848- label = 2382LLU; // continue to roll stack
29914+ label = 2387LLU; // continue to roll stack
2984929915 break;
2985029916 }
29851- case 2451LLU: // return from matchsym to initfrom
29917+ case 2456LLU: // return from matchsym to initfrom
2985229918 {
2985329919 // copy mutable arguments back from call to matchsym
2985429920 stack[base + 7]/*lookahead*/ = stack[base + 35LLU];
2985529921 ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
2985629922 ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29857- label = 2359LLU; // case complete
29923+ label = 2364LLU; // case complete
2985829924 break;
2985929925 }
29860- case 2361LLU: // copy-back deleter (switch)
29926+ case 2366LLU: // copy-back deleter (switch)
2986129927 {
2986229928 ((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
2986329929 ((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29864- label = 2356LLU; // continue to unroll stack
29930+ label = 2361LLU; // continue to unroll stack
2986529931 break;
2986629932 }
29867- case 2360LLU: // try next case
29933+ case 2365LLU: // try next case
2986829934 {
2986929935 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2987029936 exit(-1);
2987129937 }
29872- case 2359LLU: // completed switch
29938+ case 2364LLU: // completed switch
2987329939 {
2987429940
2987529941 uint64_t *newstack = (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4);
@@ -29877,7 +29943,7 @@
2987729943 newstack[0] = (uint64_t)stack; // backup stack location
2987829944 newstack[1] = 1234567890;
2987929945 newstack[2] = base;
29880- newstack[3] = 2452LLU;
29946+ newstack[3] = 2457LLU;
2988129947 stack = newstack;
2988229948 // set stack-base & callee-address
2988329949 base = 4/*deloffset*/;
@@ -29884,7 +29950,7 @@
2988429950 label = 870LLU; // ~variant
2988529951 break;
2988629952 }
29887- case 2452LLU: // return from ~variant to initfrom
29953+ case 2457LLU: // return from ~variant to initfrom
2988829954 {
2988929955 stack = (uint64_t *)stack[0];
2989029956 // releasing toplevel container
@@ -29893,23 +29959,23 @@
2989329959 ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
2989429960 ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
2989529961 ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29896- label = 2354LLU; // case complete
29962+ label = 2359LLU; // case complete
2989729963 break;
2989829964 }
29899- case 2356LLU: // copy-back deleter (switch)
29965+ case 2361LLU: // copy-back deleter (switch)
2990029966 {
2990129967 ((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
2990229968 ((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
2990329969 ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29904- label = 2316LLU; // continue to unroll stack
29970+ label = 2321LLU; // continue to unroll stack
2990529971 break;
2990629972 }
29907- case 2355LLU: // try next case
29973+ case 2360LLU: // try next case
2990829974 {
2990929975 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
2991029976 exit(-1);
2991129977 }
29912- case 2354LLU: // completed switch
29978+ case 2359LLU: // completed switch
2991329979 {
2991429980
2991529981 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
@@ -29917,7 +29983,7 @@
2991729983 newstack[0] = (uint64_t)stack; // backup stack location
2991829984 newstack[1] = 1234567890;
2991929985 newstack[2] = base;
29920- newstack[3] = 2453LLU;
29986+ newstack[3] = 2458LLU;
2992129987 stack = newstack;
2992229988 // set stack-base & callee-address
2992329989 base = 4/*deloffset*/;
@@ -29924,21 +29990,21 @@
2992429990 label = 945LLU; // ~datadef
2992529991 break;
2992629992 }
29927- case 2453LLU: // return from ~datadef to initfrom
29993+ case 2458LLU: // return from ~datadef to initfrom
2992829994 {
2992929995 stack = (uint64_t *)stack[0];
2993029996 // releasing toplevel container
2993129997 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
2993229998
29933- label = 2315LLU; // consequent complete
29999+ label = 2320LLU; // consequent complete
2993430000 break;
2993530001 }
29936- case 2314LLU: // alternative
30002+ case 2319LLU: // alternative
2993730003 {
2993830004 // call equ from initfrom
29939- stack[base + 17LLU] = 2454LLU/*throw to this address*/;
30005+ stack[base + 17LLU] = 2459LLU/*throw to this address*/;
2994030006 stack[base + 18LLU] = base;
29941- stack[base + 19LLU] = 2455LLU;
30007+ stack[base + 19LLU] = 2460LLU;
2994230008 // arguments for call to equ
2994330009 stack[base + 21LLU] = stack[base + 7]/*lookahead*/;
2994430010 stack[base + 22LLU] = 40LLU;
@@ -29947,14 +30013,14 @@
2994730013 label = 18446744073709551600LLU; // equ
2994830014 break;
2994930015 }
29950- case 2454LLU: // copy-back deleter (equ to initfrom)
30016+ case 2459LLU: // copy-back deleter (equ to initfrom)
2995130017 {
2995230018 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
2995330019 // copy mutable arguments back from call to equ
29954- label = 2259LLU; // continue to roll stack
30020+ label = 2295LLU; // continue to roll stack
2995530021 break;
2995630022 }
29957- case 2455LLU: // return from equ to initfrom
30023+ case 2460LLU: // return from equ to initfrom
2995830024 {
2995930025 // copy mutable arguments back from call to equ
2996030026 // copy back results provided by call to equ
@@ -29961,7 +30027,7 @@
2996130027 stack[base + 16] = stack[base + 20LLU];
2996230028 if(!stack[base + 16]/*construct*/)
2996330029 {
29964- label = 2456LLU; // jump to alternative
30030+ label = 2461LLU; // jump to alternative
2996530031 break;
2996630032 }
2996730033
@@ -29968,7 +30034,7 @@
2996830034 // consequent
2996930035 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*dsttype*/))[0])
2997030036 {
29971- label = 2459LLU; // jump to alternative
30037+ label = 2464LLU; // jump to alternative
2997230038 break;
2997330039 }
2997430040
@@ -29977,21 +30043,21 @@
2997730043 // case
2997830044 if(!stack[base + 9]/*fncanthrow*/)
2997930045 {
29980- label = 2461LLU; // jump to alternative
30046+ label = 2466LLU; // jump to alternative
2998130047 break;
2998230048 }
2998330049
2998430050 // consequent
29985- label = 2462LLU; // consequent complete
30051+ label = 2467LLU; // consequent complete
2998630052 break;
2998730053 }
29988- case 2461LLU: // alternative
30054+ case 2466LLU: // alternative
2998930055 {
2999030056 fprintf(stderr, "%s", "in function ");
2999130057 // call reportid from initfrom
29992- stack[base + 18LLU] = 2463LLU/*throw to this address*/;
30058+ stack[base + 18LLU] = 2468LLU/*throw to this address*/;
2999330059 stack[base + 19LLU] = base;
29994- stack[base + 20LLU] = 2464LLU;
30060+ stack[base + 20LLU] = 2469LLU;
2999530061 // arguments for call to reportid
2999630062 stack[base + 21LLU] = stack[base + 0]/*fnid*/;
2999730063 // set stack-base & callee-address
@@ -29999,21 +30065,21 @@
2999930065 label = 18446744073709551586LLU; // reportid
3000030066 break;
3000130067 }
30002- case 2463LLU: // copy-back deleter (reportid to initfrom)
30068+ case 2468LLU: // copy-back deleter (reportid to initfrom)
3000330069 {
3000430070 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3000530071 // copy mutable arguments back from call to reportid
30006- label = 2460LLU; // continue to roll stack
30072+ label = 2465LLU; // continue to roll stack
3000730073 break;
3000830074 }
30009- case 2464LLU: // return from reportid to initfrom
30075+ case 2469LLU: // return from reportid to initfrom
3001030076 {
3001130077 // copy mutable arguments back from call to reportid
3001230078 fprintf(stderr, "%s", ": construction of data ");
3001330079 // call reportid from initfrom
30014- stack[base + 18LLU] = 2465LLU/*throw to this address*/;
30080+ stack[base + 18LLU] = 2470LLU/*throw to this address*/;
3001530081 stack[base + 19LLU] = base;
30016- stack[base + 20LLU] = 2466LLU;
30082+ stack[base + 20LLU] = 2471LLU;
3001730083 // arguments for call to reportid
3001830084 stack[base + 21LLU] = stack[base + 17]/*typename*/;
3001930085 // set stack-base & callee-address
@@ -30021,28 +30087,28 @@
3002130087 label = 18446744073709551586LLU; // reportid
3002230088 break;
3002330089 }
30024- case 2465LLU: // copy-back deleter (reportid to initfrom)
30090+ case 2470LLU: // copy-back deleter (reportid to initfrom)
3002530091 {
3002630092 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3002730093 // copy mutable arguments back from call to reportid
30028- label = 2460LLU; // continue to roll stack
30094+ label = 2465LLU; // continue to roll stack
3002930095 break;
3003030096 }
30031- case 2466LLU: // return from reportid to initfrom
30097+ case 2471LLU: // return from reportid to initfrom
3003230098 {
3003330099 // copy mutable arguments back from call to reportid
3003430100 fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
3003530101 exit(-1);
30036- label = 2462LLU; // alternative complete
30102+ label = 2467LLU; // alternative complete
3003730103 break;
3003830104 }
30039- case 2462LLU: // completed if-then-else
30105+ case 2467LLU: // completed if-then-else
3004030106 {
3004130107 printf("%s", "\n // construct ");
3004230108 // call printid from initfrom
30043- stack[base + 18LLU] = 2467LLU/*throw to this address*/;
30109+ stack[base + 18LLU] = 2472LLU/*throw to this address*/;
3004430110 stack[base + 19LLU] = base;
30045- stack[base + 20LLU] = 2468LLU;
30111+ stack[base + 20LLU] = 2473LLU;
3004630112 // arguments for call to printid
3004730113 stack[base + 21LLU] = stack[base + 17]/*typename*/;
3004830114 // set stack-base & callee-address
@@ -30050,21 +30116,21 @@
3005030116 label = 18446744073709551587LLU; // printid
3005130117 break;
3005230118 }
30053- case 2467LLU: // copy-back deleter (printid to initfrom)
30119+ case 2472LLU: // copy-back deleter (printid to initfrom)
3005430120 {
3005530121 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
3005630122 // copy mutable arguments back from call to printid
30057- label = 2460LLU; // continue to roll stack
30123+ label = 2465LLU; // continue to roll stack
3005830124 break;
3005930125 }
30060- case 2468LLU: // return from printid to initfrom
30126+ case 2473LLU: // return from printid to initfrom
3006130127 {
3006230128 // copy mutable arguments back from call to printid
3006330129 printf("%s", ".");
3006430130 // call printid from initfrom
30065- stack[base + 18LLU] = 2469LLU/*throw to this address*/;
30131+ stack[base + 18LLU] = 2474LLU/*throw to this address*/;
3006630132 stack[base + 19LLU] = base;
30067- stack[base + 20LLU] = 2470LLU;
30133+ stack[base + 20LLU] = 2475LLU;
3006830134 // arguments for call to printid
3006930135 stack[base + 21LLU] = stack[base + 13]/*content*/;
3007030136 // set stack-base & callee-address
@@ -30072,20 +30138,20 @@
3007230138 label = 18446744073709551587LLU; // printid
3007330139 break;
3007430140 }
30075- case 2469LLU: // copy-back deleter (printid to initfrom)
30141+ case 2474LLU: // copy-back deleter (printid to initfrom)
3007630142 {
3007730143 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
3007830144 // copy mutable arguments back from call to printid
30079- label = 2460LLU; // continue to roll stack
30145+ label = 2465LLU; // continue to roll stack
3008030146 break;
3008130147 }
30082- case 2470LLU: // return from printid to initfrom
30148+ case 2475LLU: // return from printid to initfrom
3008330149 {
3008430150 // copy mutable arguments back from call to printid
3008530151 // call FindData from initfrom
30086- stack[base + 19LLU] = 2471LLU/*throw to this address*/;
30152+ stack[base + 19LLU] = 2476LLU/*throw to this address*/;
3008730153 stack[base + 20LLU] = base;
30088- stack[base + 21LLU] = 2472LLU;
30154+ stack[base + 21LLU] = 2477LLU;
3008930155 // arguments for call to FindData
3009030156 stack[base + 23LLU] = stack[base + 4]/*typedefs*/;
3009130157 stack[base + 24LLU] = stack[base + 17]/*typename*/;
@@ -30094,14 +30160,14 @@
3009430160 label = 1004LLU; // FindData
3009530161 break;
3009630162 }
30097- case 2471LLU: // copy-back deleter (FindData to initfrom)
30163+ case 2476LLU: // copy-back deleter (FindData to initfrom)
3009830164 {
3009930165 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
3010030166 // copy mutable arguments back from call to FindData
30101- label = 2460LLU; // continue to roll stack
30167+ label = 2465LLU; // continue to roll stack
3010230168 break;
3010330169 }
30104- case 2472LLU: // return from FindData to initfrom
30170+ case 2477LLU: // return from FindData to initfrom
3010530171 {
3010630172 // copy mutable arguments back from call to FindData
3010730173 // copy back results provided by call to FindData
@@ -30108,7 +30174,7 @@
3010830174 stack[base + 18] = stack[base + 22LLU];
3010930175 if(/*datadef*/0 != ((uint64_t *)(stack[base + 18]/*reftypedef*/))[0])
3011030176 {
30111- label = 2474LLU; // jump to alternative
30177+ label = 2479LLU; // jump to alternative
3011230178 break;
3011330179 }
3011430180
@@ -30118,9 +30184,9 @@
3011830184
3011930185 // case
3012030186 // call GetVariant from initfrom
30121- stack[base + 24LLU] = 2476LLU/*throw to this address*/;
30187+ stack[base + 24LLU] = 2481LLU/*throw to this address*/;
3012230188 stack[base + 25LLU] = base;
30123- stack[base + 26LLU] = 2477LLU;
30189+ stack[base + 26LLU] = 2482LLU;
3012430190 // arguments for call to GetVariant
3012530191 stack[base + 29LLU] = stack[base + 0]/*fnid*/;
3012630192 stack[base + 30LLU] = stack[base + 20]/*variants*/;
@@ -30130,14 +30196,14 @@
3013030196 label = 907LLU; // GetVariant
3013130197 break;
3013230198 }
30133- case 2476LLU: // copy-back deleter (GetVariant to initfrom)
30199+ case 2481LLU: // copy-back deleter (GetVariant to initfrom)
3013430200 {
3013530201 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
3013630202 // copy mutable arguments back from call to GetVariant
30137- label = 2475LLU; // continue to roll stack
30203+ label = 2480LLU; // continue to roll stack
3013830204 break;
3013930205 }
30140- case 2477LLU: // return from GetVariant to initfrom
30206+ case 2482LLU: // return from GetVariant to initfrom
3014130207 {
3014230208 // copy mutable arguments back from call to GetVariant
3014330209 // copy back results provided by call to GetVariant
@@ -30145,7 +30211,7 @@
3014530211 stack[base + 23] = stack[base + 28LLU];
3014630212 if(/*variant*/0 != ((uint64_t *)(stack[base + 23]/*constr*/))[0])
3014730213 {
30148- label = 2479LLU; // jump to alternative
30214+ label = 2484LLU; // jump to alternative
3014930215 break;
3015030216 }
3015130217
@@ -30153,29 +30219,29 @@
3015330219 /*TYPEIDS*/stack[base + 25] = ((uint64_t **)(stack[base + 23]/*constr*/))[1][1]/*elements*/;
3015430220
3015530221 // case
30156- label = 2482LLU; // skip deleter
30222+ label = 2487LLU; // skip deleter
3015730223 break;
3015830224 }
30159- case 2481LLU: // deleter
30225+ case 2486LLU: // deleter
3016030226 {
3016130227 // throw from initfrom
3016230228 if(!stack[base + 26])
3016330229 {
3016430230 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
30165- label = 2480LLU; // skip, variable already deleted/unscoped
30231+ label = 2485LLU; // skip, variable already deleted/unscoped
3016630232 break;
3016730233 }
3016830234 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
30169- label = 2480LLU; // continue unrolling stack, delete next variable
30235+ label = 2485LLU; // continue unrolling stack, delete next variable
3017030236 break;
3017130237 }
30172- case 2482LLU: // skipped deleter
30238+ case 2487LLU: // skipped deleter
3017330239 {
3017430240 stack[base + 26] = 0;
3017530241 stack[base + 26]/*size*/ = list_size(((struct listnode *)(stack[base + 25]/*TYPEIDS*/)));
3017630242 if(!stack[base + 14]/*forceerror*/)
3017730243 {
30178- label = 2483LLU; // jump to alternative
30244+ label = 2488LLU; // jump to alternative
3017930245 break;
3018030246 }
3018130247
@@ -30182,9 +30248,9 @@
3018230248 // consequent
3018330249 printf("%s", "\n // if(!(");
3018430250 // call emitvaridx from initfrom
30185- stack[base + 27LLU] = 2485LLU/*throw to this address*/;
30251+ stack[base + 27LLU] = 2490LLU/*throw to this address*/;
3018630252 stack[base + 28LLU] = base;
30187- stack[base + 29LLU] = 2486LLU;
30253+ stack[base + 29LLU] = 2491LLU;
3018830254 // arguments for call to emitvaridx
3018930255 stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3019030256 // set stack-base & callee-address
@@ -30192,21 +30258,21 @@
3019230258 label = 691LLU; // emitvaridx
3019330259 break;
3019430260 }
30195- case 2485LLU: // copy-back deleter (emitvaridx to initfrom)
30261+ case 2490LLU: // copy-back deleter (emitvaridx to initfrom)
3019630262 {
3019730263 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3019830264 // copy mutable arguments back from call to emitvaridx
30199- label = 2481LLU; // continue to roll stack
30265+ label = 2486LLU; // continue to roll stack
3020030266 break;
3020130267 }
30202- case 2486LLU: // return from emitvaridx to initfrom
30268+ case 2491LLU: // return from emitvaridx to initfrom
3020330269 {
3020430270 // copy mutable arguments back from call to emitvaridx
3020530271 printf("%s", " = construct(");
3020630272 // call printnr from initfrom
30207- stack[base + 27LLU] = 2487LLU/*throw to this address*/;
30273+ stack[base + 27LLU] = 2492LLU/*throw to this address*/;
3020830274 stack[base + 28LLU] = base;
30209- stack[base + 29LLU] = 2488LLU;
30275+ stack[base + 29LLU] = 2493LLU;
3021030276 // arguments for call to printnr
3021130277 stack[base + 30LLU] = stack[base + 26]/*size*/;
3021230278 // set stack-base & callee-address
@@ -30214,27 +30280,27 @@
3021430280 label = 18446744073709551590LLU; // printnr
3021530281 break;
3021630282 }
30217- case 2487LLU: // copy-back deleter (printnr to initfrom)
30283+ case 2492LLU: // copy-back deleter (printnr to initfrom)
3021830284 {
3021930285 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3022030286 // copy mutable arguments back from call to printnr
30221- label = 2481LLU; // continue to roll stack
30287+ label = 2486LLU; // continue to roll stack
3022230288 break;
3022330289 }
30224- case 2488LLU: // return from printnr to initfrom
30290+ case 2493LLU: // return from printnr to initfrom
3022530291 {
3022630292 // copy mutable arguments back from call to printnr
3022730293 printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
30228- label = 2484LLU; // consequent complete
30294+ label = 2489LLU; // consequent complete
3022930295 break;
3023030296 }
30231- case 2483LLU: // alternative
30297+ case 2488LLU: // alternative
3023230298 {
3023330299 printf("%s", "\n if(!(");
3023430300 // call emitvaridx from initfrom
30235- stack[base + 27LLU] = 2489LLU/*throw to this address*/;
30301+ stack[base + 27LLU] = 2494LLU/*throw to this address*/;
3023630302 stack[base + 28LLU] = base;
30237- stack[base + 29LLU] = 2490LLU;
30303+ stack[base + 29LLU] = 2495LLU;
3023830304 // arguments for call to emitvaridx
3023930305 stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3024030306 // set stack-base & callee-address
@@ -30242,21 +30308,21 @@
3024230308 label = 691LLU; // emitvaridx
3024330309 break;
3024430310 }
30245- case 2489LLU: // copy-back deleter (emitvaridx to initfrom)
30311+ case 2494LLU: // copy-back deleter (emitvaridx to initfrom)
3024630312 {
3024730313 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3024830314 // copy mutable arguments back from call to emitvaridx
30249- label = 2481LLU; // continue to roll stack
30315+ label = 2486LLU; // continue to roll stack
3025030316 break;
3025130317 }
30252- case 2490LLU: // return from emitvaridx to initfrom
30318+ case 2495LLU: // return from emitvaridx to initfrom
3025330319 {
3025430320 // copy mutable arguments back from call to emitvaridx
3025530321 printf("%s", " = construct(");
3025630322 // call printnr from initfrom
30257- stack[base + 27LLU] = 2491LLU/*throw to this address*/;
30323+ stack[base + 27LLU] = 2496LLU/*throw to this address*/;
3025830324 stack[base + 28LLU] = base;
30259- stack[base + 29LLU] = 2492LLU;
30325+ stack[base + 29LLU] = 2497LLU;
3026030326 // arguments for call to printnr
3026130327 stack[base + 30LLU] = stack[base + 26]/*size*/;
3026230328 // set stack-base & callee-address
@@ -30264,26 +30330,26 @@
3026430330 label = 18446744073709551590LLU; // printnr
3026530331 break;
3026630332 }
30267- case 2491LLU: // copy-back deleter (printnr to initfrom)
30333+ case 2496LLU: // copy-back deleter (printnr to initfrom)
3026830334 {
3026930335 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3027030336 // copy mutable arguments back from call to printnr
30271- label = 2481LLU; // continue to roll stack
30337+ label = 2486LLU; // continue to roll stack
3027230338 break;
3027330339 }
30274- case 2492LLU: // return from printnr to initfrom
30340+ case 2497LLU: // return from printnr to initfrom
3027530341 {
3027630342 // copy mutable arguments back from call to printnr
3027730343 printf("%s", ")))");
30278- label = 2484LLU; // alternative complete
30344+ label = 2489LLU; // alternative complete
3027930345 break;
3028030346 }
30281- case 2484LLU: // completed if-then-else
30347+ case 2489LLU: // completed if-then-else
3028230348 {
3028330349 // call emitthrow from initfrom
30284- stack[base + 27LLU] = 2493LLU/*throw to this address*/;
30350+ stack[base + 27LLU] = 2498LLU/*throw to this address*/;
3028530351 stack[base + 28LLU] = base;
30286- stack[base + 29LLU] = 2494LLU;
30352+ stack[base + 29LLU] = 2499LLU;
3028730353 // arguments for call to emitthrow
3028830354 stack[base + 30LLU] = stack[base + 6]/*scope*/;
3028930355 // set stack-base & callee-address
@@ -30291,22 +30357,22 @@
3029130357 label = 1559LLU; // emitthrow
3029230358 break;
3029330359 }
30294- case 2493LLU: // copy-back deleter (emitthrow to initfrom)
30360+ case 2498LLU: // copy-back deleter (emitthrow to initfrom)
3029530361 {
3029630362 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
3029730363 // copy mutable arguments back from call to emitthrow
30298- label = 2481LLU; // continue to roll stack
30364+ label = 2486LLU; // continue to roll stack
3029930365 break;
3030030366 }
30301- case 2494LLU: // return from emitthrow to initfrom
30367+ case 2499LLU: // return from emitthrow to initfrom
3030230368 {
3030330369 // copy mutable arguments back from call to emitthrow
3030430370 printf("%s", "\n // consequent");
3030530371 printf("%s", "\n ((uint64_t *)");
3030630372 // call emitvaridx from initfrom
30307- stack[base + 27LLU] = 2495LLU/*throw to this address*/;
30373+ stack[base + 27LLU] = 2500LLU/*throw to this address*/;
3030830374 stack[base + 28LLU] = base;
30309- stack[base + 29LLU] = 2496LLU;
30375+ stack[base + 29LLU] = 2501LLU;
3031030376 // arguments for call to emitvaridx
3031130377 stack[base + 30LLU] = stack[base + 3]/*dstindex*/;
3031230378 // set stack-base & callee-address
@@ -30314,21 +30380,21 @@
3031430380 label = 691LLU; // emitvaridx
3031530381 break;
3031630382 }
30317- case 2495LLU: // copy-back deleter (emitvaridx to initfrom)
30383+ case 2500LLU: // copy-back deleter (emitvaridx to initfrom)
3031830384 {
3031930385 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3032030386 // copy mutable arguments back from call to emitvaridx
30321- label = 2481LLU; // continue to roll stack
30387+ label = 2486LLU; // continue to roll stack
3032230388 break;
3032330389 }
30324- case 2496LLU: // return from emitvaridx to initfrom
30390+ case 2501LLU: // return from emitvaridx to initfrom
3032530391 {
3032630392 // copy mutable arguments back from call to emitvaridx
3032730393 printf("%s", ")[0] = ");
3032830394 // call printnr from initfrom
30329- stack[base + 27LLU] = 2497LLU/*throw to this address*/;
30395+ stack[base + 27LLU] = 2502LLU/*throw to this address*/;
3033030396 stack[base + 28LLU] = base;
30331- stack[base + 29LLU] = 2498LLU;
30397+ stack[base + 29LLU] = 2503LLU;
3033230398 // arguments for call to printnr
3033330399 stack[base + 30LLU] = stack[base + 22]/*varnr*/;
3033430400 // set stack-base & callee-address
@@ -30336,21 +30402,21 @@
3033630402 label = 18446744073709551590LLU; // printnr
3033730403 break;
3033830404 }
30339- case 2497LLU: // copy-back deleter (printnr to initfrom)
30405+ case 2502LLU: // copy-back deleter (printnr to initfrom)
3034030406 {
3034130407 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3034230408 // copy mutable arguments back from call to printnr
30343- label = 2481LLU; // continue to roll stack
30409+ label = 2486LLU; // continue to roll stack
3034430410 break;
3034530411 }
30346- case 2498LLU: // return from printnr to initfrom
30412+ case 2503LLU: // return from printnr to initfrom
3034730413 {
3034830414 // copy mutable arguments back from call to printnr
3034930415 printf("%s", ";");
3035030416 // call matchsym from initfrom
30351- stack[base + 27LLU] = 2499LLU/*throw to this address*/;
30417+ stack[base + 27LLU] = 2504LLU/*throw to this address*/;
3035230418 stack[base + 28LLU] = base;
30353- stack[base + 29LLU] = 2500LLU;
30419+ stack[base + 29LLU] = 2505LLU;
3035430420 // arguments for call to matchsym
3035530421 stack[base + 30LLU] = stack[base + 0]/*fnid*/;
3035630422 stack[base + 31LLU] = 40LLU;
@@ -30360,46 +30426,46 @@
3036030426 label = 212LLU; // matchsym
3036130427 break;
3036230428 }
30363- case 2499LLU: // copy-back deleter (matchsym to initfrom)
30429+ case 2504LLU: // copy-back deleter (matchsym to initfrom)
3036430430 {
3036530431 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3036630432 // copy mutable arguments back from call to matchsym
3036730433 stack[base + 7]/*lookahead*/ = stack[base + 32LLU];
30368- label = 2481LLU; // continue to roll stack
30434+ label = 2486LLU; // continue to roll stack
3036930435 break;
3037030436 }
30371- case 2500LLU: // return from matchsym to initfrom
30437+ case 2505LLU: // return from matchsym to initfrom
3037230438 {
3037330439 // copy mutable arguments back from call to matchsym
3037430440 stack[base + 7]/*lookahead*/ = stack[base + 32LLU];
30375- label = 2502LLU; // skip deleter
30441+ label = 2507LLU; // skip deleter
3037630442 break;
3037730443 }
30378- case 2501LLU: // deleter
30444+ case 2506LLU: // deleter
3037930445 {
3038030446 // throw from initfrom
3038130447 if(!stack[base + 27])
3038230448 {
3038330449 fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
30384- label = 2481LLU; // skip, variable already deleted/unscoped
30450+ label = 2486LLU; // skip, variable already deleted/unscoped
3038530451 break;
3038630452 }
3038730453 fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
30388- label = 2481LLU; // continue unrolling stack, delete next variable
30454+ label = 2486LLU; // continue unrolling stack, delete next variable
3038930455 break;
3039030456 }
30391- case 2502LLU: // skipped deleter
30457+ case 2507LLU: // skipped deleter
3039230458 {
3039330459 stack[base + 27] = 0;
3039430460 flippedassign(stack[base + 25]/*TYPEIDS*/, &stack[base + 28]);
30395- label = 2503LLU; // start to repeat
30461+ label = 2508LLU; // start to repeat
3039630462 break;
3039730463 }
30398- case 2503LLU: // repeat from here
30464+ case 2508LLU: // repeat from here
3039930465 {
3040030466 if(!stack[base + 28])
3040130467 {
30402- label = 2504LLU; // break loop
30468+ label = 2509LLU; // break loop
3040330469 break;
3040430470 }
3040530471
@@ -30409,7 +30475,7 @@
3040930475 stack[base + 28] = (uint64_t)(((const struct listnode *)(stack[base + 28]))->next);
3041030476 if(/*typeid*/0 != ((uint64_t *)(stack[base + 29]/*typeid*/))[0])
3041130477 {
30412- label = 2507LLU; // jump to alternative
30478+ label = 2512LLU; // jump to alternative
3041330479 break;
3041430480 }
3041530481
@@ -30419,15 +30485,15 @@
3041930485 // case
3042030486 if(!stack[base + 27]/*elemindex*/)
3042130487 {
30422- label = 2509LLU; // jump to alternative
30488+ label = 2514LLU; // jump to alternative
3042330489 break;
3042430490 }
3042530491
3042630492 // consequent
3042730493 // call matchsym from initfrom
30428- stack[base + 33LLU] = 2511LLU/*throw to this address*/;
30494+ stack[base + 33LLU] = 2516LLU/*throw to this address*/;
3042930495 stack[base + 34LLU] = base;
30430- stack[base + 35LLU] = 2512LLU;
30496+ stack[base + 35LLU] = 2517LLU;
3043130497 // arguments for call to matchsym
3043230498 stack[base + 36LLU] = stack[base + 0]/*fnid*/;
3043330499 stack[base + 37LLU] = 44LLU;
@@ -30437,32 +30503,32 @@
3043730503 label = 212LLU; // matchsym
3043830504 break;
3043930505 }
30440- case 2511LLU: // copy-back deleter (matchsym to initfrom)
30506+ case 2516LLU: // copy-back deleter (matchsym to initfrom)
3044130507 {
3044230508 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3044330509 // copy mutable arguments back from call to matchsym
3044430510 stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30445- label = 2508LLU; // continue to roll stack
30511+ label = 2513LLU; // continue to roll stack
3044630512 break;
3044730513 }
30448- case 2512LLU: // return from matchsym to initfrom
30514+ case 2517LLU: // return from matchsym to initfrom
3044930515 {
3045030516 // copy mutable arguments back from call to matchsym
3045130517 stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30452- label = 2510LLU; // consequent complete
30518+ label = 2515LLU; // consequent complete
3045330519 break;
3045430520 }
30455- case 2509LLU: // alternative
30521+ case 2514LLU: // alternative
3045630522 {
30457- label = 2510LLU; // alternative complete
30523+ label = 2515LLU; // alternative complete
3045830524 break;
3045930525 }
30460- case 2510LLU: // completed if-then-else
30526+ case 2515LLU: // completed if-then-else
3046130527 {
3046230528 // call ParseToken from initfrom
30463- stack[base + 33LLU] = 2513LLU/*throw to this address*/;
30529+ stack[base + 33LLU] = 2518LLU/*throw to this address*/;
3046430530 stack[base + 34LLU] = base;
30465- stack[base + 35LLU] = 2514LLU;
30531+ stack[base + 35LLU] = 2519LLU;
3046630532 // arguments for call to ParseToken
3046730533 stack[base + 38LLU] = stack[base + 7]/*lookahead*/;
3046830534 // set stack-base & callee-address
@@ -30470,15 +30536,15 @@
3047030536 label = 3LLU; // ParseToken
3047130537 break;
3047230538 }
30473- case 2513LLU: // copy-back deleter (ParseToken to initfrom)
30539+ case 2518LLU: // copy-back deleter (ParseToken to initfrom)
3047430540 {
3047530541 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
3047630542 // copy mutable arguments back from call to ParseToken
3047730543 stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
30478- label = 2508LLU; // continue to roll stack
30544+ label = 2513LLU; // continue to roll stack
3047930545 break;
3048030546 }
30481- case 2514LLU: // return from ParseToken to initfrom
30547+ case 2519LLU: // return from ParseToken to initfrom
3048230548 {
3048330549 // copy mutable arguments back from call to ParseToken
3048430550 stack[base + 7]/*lookahead*/ = stack[base + 38LLU];
@@ -30486,9 +30552,9 @@
3048630552 stack[base + 12] = stack[base + 36LLU];
3048730553 stack[base + 13] = stack[base + 37LLU];
3048830554 // call equ from initfrom
30489- stack[base + 33LLU] = 2515LLU/*throw to this address*/;
30555+ stack[base + 33LLU] = 2520LLU/*throw to this address*/;
3049030556 stack[base + 34LLU] = base;
30491- stack[base + 35LLU] = 2516LLU;
30557+ stack[base + 35LLU] = 2521LLU;
3049230558 // arguments for call to equ
3049330559 stack[base + 37LLU] = stack[base + 12]/*variant*/;
3049430560 stack[base + 38LLU] = 4LLU;
@@ -30497,14 +30563,14 @@
3049730563 label = 18446744073709551600LLU; // equ
3049830564 break;
3049930565 }
30500- case 2515LLU: // copy-back deleter (equ to initfrom)
30566+ case 2520LLU: // copy-back deleter (equ to initfrom)
3050130567 {
3050230568 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3050330569 // copy mutable arguments back from call to equ
30504- label = 2508LLU; // continue to roll stack
30570+ label = 2513LLU; // continue to roll stack
3050530571 break;
3050630572 }
30507- case 2516LLU: // return from equ to initfrom
30573+ case 2521LLU: // return from equ to initfrom
3050830574 {
3050930575 // copy mutable arguments back from call to equ
3051030576 // copy back results provided by call to equ
@@ -30511,21 +30577,21 @@
3051130577 stack[base + 10] = stack[base + 36LLU];
3051230578 if(!stack[base + 10]/*isequal*/)
3051330579 {
30514- label = 2517LLU; // jump to alternative
30580+ label = 2522LLU; // jump to alternative
3051530581 break;
3051630582 }
3051730583
3051830584 // consequent
30519- label = 2518LLU; // consequent complete
30585+ label = 2523LLU; // consequent complete
3052030586 break;
3052130587 }
30522- case 2517LLU: // alternative
30588+ case 2522LLU: // alternative
3052330589 {
3052430590 fprintf(stderr, "%s", "constructor requires variables but found ");
3052530591 // call reporttok from initfrom
30526- stack[base + 33LLU] = 2519LLU/*throw to this address*/;
30592+ stack[base + 33LLU] = 2524LLU/*throw to this address*/;
3052730593 stack[base + 34LLU] = base;
30528- stack[base + 35LLU] = 2520LLU;
30594+ stack[base + 35LLU] = 2525LLU;
3052930595 // arguments for call to reporttok
3053030596 stack[base + 36LLU] = stack[base + 12]/*variant*/;
3053130597 stack[base + 37LLU] = stack[base + 13]/*content*/;
@@ -30534,27 +30600,27 @@
3053430600 label = 18446744073709551582LLU; // reporttok
3053530601 break;
3053630602 }
30537- case 2519LLU: // copy-back deleter (reporttok to initfrom)
30603+ case 2524LLU: // copy-back deleter (reporttok to initfrom)
3053830604 {
3053930605 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
3054030606 // copy mutable arguments back from call to reporttok
30541- label = 2508LLU; // continue to roll stack
30607+ label = 2513LLU; // continue to roll stack
3054230608 break;
3054330609 }
30544- case 2520LLU: // return from reporttok to initfrom
30610+ case 2525LLU: // return from reporttok to initfrom
3054530611 {
3054630612 // copy mutable arguments back from call to reporttok
3054730613 fprintf(stderr, "%s", "\n");
3054830614 exit(-1);
30549- label = 2518LLU; // alternative complete
30615+ label = 2523LLU; // alternative complete
3055030616 break;
3055130617 }
30552- case 2518LLU: // completed if-then-else
30618+ case 2523LLU: // completed if-then-else
3055330619 {
3055430620 // call getlettype from initfrom
30555- stack[base + 34LLU] = 2521LLU/*throw to this address*/;
30621+ stack[base + 34LLU] = 2526LLU/*throw to this address*/;
3055630622 stack[base + 35LLU] = base;
30557- stack[base + 36LLU] = 2522LLU;
30623+ stack[base + 36LLU] = 2527LLU;
3055830624 // arguments for call to getlettype
3055930625 stack[base + 38LLU] = stack[base + 0]/*fnid*/;
3056030626 stack[base + 39LLU] = stack[base + 13]/*content*/;
@@ -30565,14 +30631,14 @@
3056530631 label = 651LLU; // getlettype
3056630632 break;
3056730633 }
30568- case 2521LLU: // copy-back deleter (getlettype to initfrom)
30634+ case 2526LLU: // copy-back deleter (getlettype to initfrom)
3056930635 {
3057030636 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
3057130637 // copy mutable arguments back from call to getlettype
30572- label = 2508LLU; // continue to roll stack
30638+ label = 2513LLU; // continue to roll stack
3057330639 break;
3057430640 }
30575- case 2522LLU: // return from getlettype to initfrom
30641+ case 2527LLU: // return from getlettype to initfrom
3057630642 {
3057730643 // copy mutable arguments back from call to getlettype
3057830644 // copy back results provided by call to getlettype
@@ -30580,7 +30646,7 @@
3058030646 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
3058130647 if(!newstack)
3058230648 {
30583- label = 2508LLU; // throw: begin to unroll stack
30649+ label = 2513LLU; // throw: begin to unroll stack
3058430650 break;
3058530651 }
3058630652
@@ -30587,9 +30653,9 @@
3058730653 newstack[15LLU] = 9876543210LLU; // overflow-marker
3058830654 // call equtype from initfrom
3058930655 newstack[0] = (uint64_t)stack; // backup stack location
30590- newstack[1] = 2523LLU;
30656+ newstack[1] = 2528LLU;
3059130657 newstack[2] = base;
30592- newstack[3] = 2524LLU;
30658+ newstack[3] = 2529LLU;
3059330659 // arguments for call to equtype
3059430660 newstack[5LLU] = stack[base + 31]/*dsttype*/;
3059530661 newstack[6LLU] = stack[base + 33]/*srctype*/;
@@ -30599,7 +30665,7 @@
3059930665 label = 342LLU; // equtype
3060030666 break;
3060130667 }
30602- case 2523LLU: // copy-back deleter (equtype to initfrom)
30668+ case 2528LLU: // copy-back deleter (equtype to initfrom)
3060330669 {
3060430670 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
3060530671 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -30611,10 +30677,10 @@
3061130677 }
3061230678 Free(15LLU + 1, sizeof(uint64_t), stack);
3061330679 stack = oldstack;
30614- label = 2508LLU; // continue to unroll stack
30680+ label = 2513LLU; // continue to unroll stack
3061530681 break;
3061630682 }
30617- case 2524LLU: // return from equtype to initfrom
30683+ case 2529LLU: // return from equtype to initfrom
3061830684 {
3061930685 uint64_t *oldstack = (uint64_t *)stack[0];
3062030686 // copy mutable arguments back from call to equtype
@@ -30629,7 +30695,7 @@
3062930695 stack = oldstack;
3063030696 if(!stack[base + 10]/*isequal*/)
3063130697 {
30632- label = 2525LLU; // jump to alternative
30698+ label = 2530LLU; // jump to alternative
3063330699 break;
3063430700 }
3063530701
@@ -30636,7 +30702,7 @@
3063630702 // consequent
3063730703 if(/*typename*/0 != ((uint64_t *)(stack[base + 31]/*dsttype*/))[0])
3063830704 {
30639- label = 2528LLU; // jump to alternative
30705+ label = 2533LLU; // jump to alternative
3064030706 break;
3064130707 }
3064230708
@@ -30644,9 +30710,9 @@
3064430710
3064530711 // case
3064630712 // call equ from initfrom
30647- stack[base + 35LLU] = 2530LLU/*throw to this address*/;
30713+ stack[base + 35LLU] = 2535LLU/*throw to this address*/;
3064830714 stack[base + 36LLU] = base;
30649- stack[base + 37LLU] = 2531LLU;
30715+ stack[base + 37LLU] = 2536LLU;
3065030716 // arguments for call to equ
3065130717 stack[base + 39LLU] = 881834713755418624LLU;
3065230718 stack[base + 40LLU] = stack[base + 34]/*name*/;
@@ -30655,14 +30721,14 @@
3065530721 label = 18446744073709551600LLU; // equ
3065630722 break;
3065730723 }
30658- case 2530LLU: // copy-back deleter (equ to initfrom)
30724+ case 2535LLU: // copy-back deleter (equ to initfrom)
3065930725 {
3066030726 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3066130727 // copy mutable arguments back from call to equ
30662- label = 2529LLU; // continue to roll stack
30728+ label = 2534LLU; // continue to roll stack
3066330729 break;
3066430730 }
30665- case 2531LLU: // return from equ to initfrom
30731+ case 2536LLU: // return from equ to initfrom
3066630732 {
3066730733 // copy mutable arguments back from call to equ
3066830734 // copy back results provided by call to equ
@@ -30669,7 +30735,7 @@
3066930735 stack[base + 10] = stack[base + 38LLU];
3067030736 if(!stack[base + 10]/*isequal*/)
3067130737 {
30672- label = 2532LLU; // jump to alternative
30738+ label = 2537LLU; // jump to alternative
3067330739 break;
3067430740 }
3067530741
@@ -30676,9 +30742,9 @@
3067630742 // consequent
3067730743 printf("%s", "\n (((uint64_t **)(");
3067830744 // call emitvaridx from initfrom
30679- stack[base + 35LLU] = 2534LLU/*throw to this address*/;
30745+ stack[base + 35LLU] = 2539LLU/*throw to this address*/;
3068030746 stack[base + 36LLU] = base;
30681- stack[base + 37LLU] = 2535LLU;
30747+ stack[base + 37LLU] = 2540LLU;
3068230748 // arguments for call to emitvaridx
3068330749 stack[base + 38LLU] = stack[base + 3]/*dstindex*/;
3068430750 // set stack-base & callee-address
@@ -30686,21 +30752,21 @@
3068630752 label = 691LLU; // emitvaridx
3068730753 break;
3068830754 }
30689- case 2534LLU: // copy-back deleter (emitvaridx to initfrom)
30755+ case 2539LLU: // copy-back deleter (emitvaridx to initfrom)
3069030756 {
3069130757 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3069230758 // copy mutable arguments back from call to emitvaridx
30693- label = 2529LLU; // continue to roll stack
30759+ label = 2534LLU; // continue to roll stack
3069430760 break;
3069530761 }
30696- case 2535LLU: // return from emitvaridx to initfrom
30762+ case 2540LLU: // return from emitvaridx to initfrom
3069730763 {
3069830764 // copy mutable arguments back from call to emitvaridx
3069930765 printf("%s", "))[1][");
3070030766 // call printnr from initfrom
30701- stack[base + 35LLU] = 2536LLU/*throw to this address*/;
30767+ stack[base + 35LLU] = 2541LLU/*throw to this address*/;
3070230768 stack[base + 36LLU] = base;
30703- stack[base + 37LLU] = 2537LLU;
30769+ stack[base + 37LLU] = 2542LLU;
3070430770 // arguments for call to printnr
3070530771 stack[base + 38LLU] = stack[base + 27]/*elemindex*/;
3070630772 // set stack-base & callee-address
@@ -30708,21 +30774,21 @@
3070830774 label = 18446744073709551590LLU; // printnr
3070930775 break;
3071030776 }
30711- case 2536LLU: // copy-back deleter (printnr to initfrom)
30777+ case 2541LLU: // copy-back deleter (printnr to initfrom)
3071230778 {
3071330779 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3071430780 // copy mutable arguments back from call to printnr
30715- label = 2529LLU; // continue to roll stack
30781+ label = 2534LLU; // continue to roll stack
3071630782 break;
3071730783 }
30718- case 2537LLU: // return from printnr to initfrom
30784+ case 2542LLU: // return from printnr to initfrom
3071930785 {
3072030786 // copy mutable arguments back from call to printnr
3072130787 printf("%s", "]) = ");
3072230788 // call emitvar from initfrom
30723- stack[base + 35LLU] = 2538LLU/*throw to this address*/;
30789+ stack[base + 35LLU] = 2543LLU/*throw to this address*/;
3072430790 stack[base + 36LLU] = base;
30725- stack[base + 37LLU] = 2539LLU;
30791+ stack[base + 37LLU] = 2544LLU;
3072630792 // arguments for call to emitvar
3072730793 stack[base + 38LLU] = stack[base + 0]/*fnid*/;
3072830794 stack[base + 39LLU] = stack[base + 13]/*content*/;
@@ -30733,27 +30799,27 @@
3073330799 label = 695LLU; // emitvar
3073430800 break;
3073530801 }
30736- case 2538LLU: // copy-back deleter (emitvar to initfrom)
30802+ case 2543LLU: // copy-back deleter (emitvar to initfrom)
3073730803 {
3073830804 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3073930805 // copy mutable arguments back from call to emitvar
30740- label = 2529LLU; // continue to roll stack
30806+ label = 2534LLU; // continue to roll stack
3074130807 break;
3074230808 }
30743- case 2539LLU: // return from emitvar to initfrom
30809+ case 2544LLU: // return from emitvar to initfrom
3074430810 {
3074530811 // copy mutable arguments back from call to emitvar
3074630812 printf("%s", ";");
30747- label = 2533LLU; // consequent complete
30813+ label = 2538LLU; // consequent complete
3074830814 break;
3074930815 }
30750- case 2532LLU: // alternative
30816+ case 2537LLU: // alternative
3075130817 {
3075230818 printf("%s", "\n INIT(&(((uint64_t **)(");
3075330819 // call emitvaridx from initfrom
30754- stack[base + 35LLU] = 2540LLU/*throw to this address*/;
30820+ stack[base + 35LLU] = 2545LLU/*throw to this address*/;
3075530821 stack[base + 36LLU] = base;
30756- stack[base + 37LLU] = 2541LLU;
30822+ stack[base + 37LLU] = 2546LLU;
3075730823 // arguments for call to emitvaridx
3075830824 stack[base + 38LLU] = stack[base + 3]/*dstindex*/;
3075930825 // set stack-base & callee-address
@@ -30761,21 +30827,21 @@
3076130827 label = 691LLU; // emitvaridx
3076230828 break;
3076330829 }
30764- case 2540LLU: // copy-back deleter (emitvaridx to initfrom)
30830+ case 2545LLU: // copy-back deleter (emitvaridx to initfrom)
3076530831 {
3076630832 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3076730833 // copy mutable arguments back from call to emitvaridx
30768- label = 2529LLU; // continue to roll stack
30834+ label = 2534LLU; // continue to roll stack
3076930835 break;
3077030836 }
30771- case 2541LLU: // return from emitvaridx to initfrom
30837+ case 2546LLU: // return from emitvaridx to initfrom
3077230838 {
3077330839 // copy mutable arguments back from call to emitvaridx
3077430840 printf("%s", "))[1][");
3077530841 // call printnr from initfrom
30776- stack[base + 35LLU] = 2542LLU/*throw to this address*/;
30842+ stack[base + 35LLU] = 2547LLU/*throw to this address*/;
3077730843 stack[base + 36LLU] = base;
30778- stack[base + 37LLU] = 2543LLU;
30844+ stack[base + 37LLU] = 2548LLU;
3077930845 // arguments for call to printnr
3078030846 stack[base + 38LLU] = stack[base + 27]/*elemindex*/;
3078130847 // set stack-base & callee-address
@@ -30783,21 +30849,21 @@
3078330849 label = 18446744073709551590LLU; // printnr
3078430850 break;
3078530851 }
30786- case 2542LLU: // copy-back deleter (printnr to initfrom)
30852+ case 2547LLU: // copy-back deleter (printnr to initfrom)
3078730853 {
3078830854 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3078930855 // copy mutable arguments back from call to printnr
30790- label = 2529LLU; // continue to roll stack
30856+ label = 2534LLU; // continue to roll stack
3079130857 break;
3079230858 }
30793- case 2543LLU: // return from printnr to initfrom
30859+ case 2548LLU: // return from printnr to initfrom
3079430860 {
3079530861 // copy mutable arguments back from call to printnr
3079630862 printf("%s", "]), &");
3079730863 // call emitvar from initfrom
30798- stack[base + 35LLU] = 2544LLU/*throw to this address*/;
30864+ stack[base + 35LLU] = 2549LLU/*throw to this address*/;
3079930865 stack[base + 36LLU] = base;
30800- stack[base + 37LLU] = 2545LLU;
30866+ stack[base + 37LLU] = 2550LLU;
3080130867 // arguments for call to emitvar
3080230868 stack[base + 38LLU] = stack[base + 0]/*fnid*/;
3080330869 stack[base + 39LLU] = stack[base + 13]/*content*/;
@@ -30808,21 +30874,21 @@
3080830874 label = 695LLU; // emitvar
3080930875 break;
3081030876 }
30811- case 2544LLU: // copy-back deleter (emitvar to initfrom)
30877+ case 2549LLU: // copy-back deleter (emitvar to initfrom)
3081230878 {
3081330879 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3081430880 // copy mutable arguments back from call to emitvar
30815- label = 2529LLU; // continue to roll stack
30881+ label = 2534LLU; // continue to roll stack
3081630882 break;
3081730883 }
30818- case 2545LLU: // return from emitvar to initfrom
30884+ case 2550LLU: // return from emitvar to initfrom
3081930885 {
3082030886 // copy mutable arguments back from call to emitvar
3082130887 printf("%s", ");");
3082230888 // call unscopelet from initfrom
30823- stack[base + 35LLU] = 2546LLU/*throw to this address*/;
30889+ stack[base + 35LLU] = 2551LLU/*throw to this address*/;
3082430890 stack[base + 36LLU] = base;
30825- stack[base + 37LLU] = 2547LLU;
30891+ stack[base + 37LLU] = 2552LLU;
3082630892 // arguments for call to unscopelet
3082730893 stack[base + 38LLU] = stack[base + 0]/*fnid*/;
3082830894 stack[base + 39LLU] = stack[base + 6]/*scope*/;
@@ -30832,41 +30898,41 @@
3083230898 label = 761LLU; // unscopelet
3083330899 break;
3083430900 }
30835- case 2546LLU: // copy-back deleter (unscopelet to initfrom)
30901+ case 2551LLU: // copy-back deleter (unscopelet to initfrom)
3083630902 {
3083730903 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3083830904 // copy mutable arguments back from call to unscopelet
3083930905 stack[base + 6]/*scope*/ = stack[base + 39LLU];
30840- label = 2529LLU; // continue to roll stack
30906+ label = 2534LLU; // continue to roll stack
3084130907 break;
3084230908 }
30843- case 2547LLU: // return from unscopelet to initfrom
30909+ case 2552LLU: // return from unscopelet to initfrom
3084430910 {
3084530911 // copy mutable arguments back from call to unscopelet
3084630912 stack[base + 6]/*scope*/ = stack[base + 39LLU];
30847- label = 2533LLU; // alternative complete
30913+ label = 2538LLU; // alternative complete
3084830914 break;
3084930915 }
30850- case 2533LLU: // completed if-then-else
30916+ case 2538LLU: // completed if-then-else
3085130917 {
3085230918 ((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30853- label = 2527LLU; // case complete
30919+ label = 2532LLU; // case complete
3085430920 break;
3085530921 }
30856- case 2529LLU: // copy-back deleter (switch)
30922+ case 2534LLU: // copy-back deleter (switch)
3085730923 {
3085830924 ((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30859- label = 2508LLU; // continue to unroll stack
30925+ label = 2513LLU; // continue to unroll stack
3086030926 break;
3086130927 }
30862- case 2528LLU: // try next case
30928+ case 2533LLU: // try next case
3086330929 {
3086430930 // default
3086530931 printf("%s", "\n INIT(&(((uint64_t **)(");
3086630932 // call emitvaridx from initfrom
30867- stack[base + 34LLU] = 2548LLU/*throw to this address*/;
30933+ stack[base + 34LLU] = 2553LLU/*throw to this address*/;
3086830934 stack[base + 35LLU] = base;
30869- stack[base + 36LLU] = 2549LLU;
30935+ stack[base + 36LLU] = 2554LLU;
3087030936 // arguments for call to emitvaridx
3087130937 stack[base + 37LLU] = stack[base + 3]/*dstindex*/;
3087230938 // set stack-base & callee-address
@@ -30874,21 +30940,21 @@
3087430940 label = 691LLU; // emitvaridx
3087530941 break;
3087630942 }
30877- case 2548LLU: // copy-back deleter (emitvaridx to initfrom)
30943+ case 2553LLU: // copy-back deleter (emitvaridx to initfrom)
3087830944 {
3087930945 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3088030946 // copy mutable arguments back from call to emitvaridx
30881- label = 2508LLU; // continue to roll stack
30947+ label = 2513LLU; // continue to roll stack
3088230948 break;
3088330949 }
30884- case 2549LLU: // return from emitvaridx to initfrom
30950+ case 2554LLU: // return from emitvaridx to initfrom
3088530951 {
3088630952 // copy mutable arguments back from call to emitvaridx
3088730953 printf("%s", "))[1][");
3088830954 // call printnr from initfrom
30889- stack[base + 34LLU] = 2550LLU/*throw to this address*/;
30955+ stack[base + 34LLU] = 2555LLU/*throw to this address*/;
3089030956 stack[base + 35LLU] = base;
30891- stack[base + 36LLU] = 2551LLU;
30957+ stack[base + 36LLU] = 2556LLU;
3089230958 // arguments for call to printnr
3089330959 stack[base + 37LLU] = stack[base + 27]/*elemindex*/;
3089430960 // set stack-base & callee-address
@@ -30896,21 +30962,21 @@
3089630962 label = 18446744073709551590LLU; // printnr
3089730963 break;
3089830964 }
30899- case 2550LLU: // copy-back deleter (printnr to initfrom)
30965+ case 2555LLU: // copy-back deleter (printnr to initfrom)
3090030966 {
3090130967 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3090230968 // copy mutable arguments back from call to printnr
30903- label = 2508LLU; // continue to roll stack
30969+ label = 2513LLU; // continue to roll stack
3090430970 break;
3090530971 }
30906- case 2551LLU: // return from printnr to initfrom
30972+ case 2556LLU: // return from printnr to initfrom
3090730973 {
3090830974 // copy mutable arguments back from call to printnr
3090930975 printf("%s", "]), &");
3091030976 // call emitvar from initfrom
30911- stack[base + 34LLU] = 2552LLU/*throw to this address*/;
30977+ stack[base + 34LLU] = 2557LLU/*throw to this address*/;
3091230978 stack[base + 35LLU] = base;
30913- stack[base + 36LLU] = 2553LLU;
30979+ stack[base + 36LLU] = 2558LLU;
3091430980 // arguments for call to emitvar
3091530981 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
3091630982 stack[base + 38LLU] = stack[base + 13]/*content*/;
@@ -30921,21 +30987,21 @@
3092130987 label = 695LLU; // emitvar
3092230988 break;
3092330989 }
30924- case 2552LLU: // copy-back deleter (emitvar to initfrom)
30990+ case 2557LLU: // copy-back deleter (emitvar to initfrom)
3092530991 {
3092630992 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3092730993 // copy mutable arguments back from call to emitvar
30928- label = 2508LLU; // continue to roll stack
30994+ label = 2513LLU; // continue to roll stack
3092930995 break;
3093030996 }
30931- case 2553LLU: // return from emitvar to initfrom
30997+ case 2558LLU: // return from emitvar to initfrom
3093230998 {
3093330999 // copy mutable arguments back from call to emitvar
3093431000 printf("%s", ");");
3093531001 // call unscopelet from initfrom
30936- stack[base + 34LLU] = 2554LLU/*throw to this address*/;
31002+ stack[base + 34LLU] = 2559LLU/*throw to this address*/;
3093731003 stack[base + 35LLU] = base;
30938- stack[base + 36LLU] = 2555LLU;
31004+ stack[base + 36LLU] = 2560LLU;
3093931005 // arguments for call to unscopelet
3094031006 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
3094131007 stack[base + 38LLU] = stack[base + 6]/*scope*/;
@@ -30945,33 +31011,33 @@
3094531011 label = 761LLU; // unscopelet
3094631012 break;
3094731013 }
30948- case 2554LLU: // copy-back deleter (unscopelet to initfrom)
31014+ case 2559LLU: // copy-back deleter (unscopelet to initfrom)
3094931015 {
3095031016 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3095131017 // copy mutable arguments back from call to unscopelet
3095231018 stack[base + 6]/*scope*/ = stack[base + 38LLU];
30953- label = 2508LLU; // continue to roll stack
31019+ label = 2513LLU; // continue to roll stack
3095431020 break;
3095531021 }
30956- case 2555LLU: // return from unscopelet to initfrom
31022+ case 2560LLU: // return from unscopelet to initfrom
3095731023 {
3095831024 // copy mutable arguments back from call to unscopelet
3095931025 stack[base + 6]/*scope*/ = stack[base + 38LLU];
30960- label = 2527LLU; // default complete
31026+ label = 2532LLU; // default complete
3096131027 break;
3096231028 }
30963- case 2527LLU: // completed switch
31029+ case 2532LLU: // completed switch
3096431030 {
30965- label = 2526LLU; // consequent complete
31031+ label = 2531LLU; // consequent complete
3096631032 break;
3096731033 }
30968- case 2525LLU: // alternative
31034+ case 2530LLU: // alternative
3096931035 {
3097031036 fprintf(stderr, "%s", "in function ");
3097131037 // call reportid from initfrom
30972- stack[base + 34LLU] = 2556LLU/*throw to this address*/;
31038+ stack[base + 34LLU] = 2561LLU/*throw to this address*/;
3097331039 stack[base + 35LLU] = base;
30974- stack[base + 36LLU] = 2557LLU;
31040+ stack[base + 36LLU] = 2562LLU;
3097531041 // arguments for call to reportid
3097631042 stack[base + 37LLU] = stack[base + 0]/*fnid*/;
3097731043 // set stack-base & callee-address
@@ -30979,14 +31045,14 @@
3097931045 label = 18446744073709551586LLU; // reportid
3098031046 break;
3098131047 }
30982- case 2556LLU: // copy-back deleter (reportid to initfrom)
31048+ case 2561LLU: // copy-back deleter (reportid to initfrom)
3098331049 {
3098431050 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3098531051 // copy mutable arguments back from call to reportid
30986- label = 2508LLU; // continue to roll stack
31052+ label = 2513LLU; // continue to roll stack
3098731053 break;
3098831054 }
30989- case 2557LLU: // return from reportid to initfrom
31055+ case 2562LLU: // return from reportid to initfrom
3099031056 {
3099131057 // copy mutable arguments back from call to reportid
3099231058 fprintf(stderr, "%s", ": constructor of type ");
@@ -30993,7 +31059,7 @@
3099331059 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3099431060 if(!newstack)
3099531061 {
30996- label = 2508LLU; // throw: begin to unroll stack
31062+ label = 2513LLU; // throw: begin to unroll stack
3099731063 break;
3099831064 }
3099931065
@@ -31000,9 +31066,9 @@
3100031066 newstack[10LLU] = 9876543210LLU; // overflow-marker
3100131067 // call reporttype from initfrom
3100231068 newstack[0] = (uint64_t)stack; // backup stack location
31003- newstack[1] = 2558LLU;
31069+ newstack[1] = 2563LLU;
3100431070 newstack[2] = base;
31005- newstack[3] = 2559LLU;
31071+ newstack[3] = 2564LLU;
3100631072 // arguments for call to reporttype
3100731073 newstack[4LLU] = stack[base + 31]/*dsttype*/;
3100831074 stack = newstack;
@@ -31011,7 +31077,7 @@
3101131077 label = 316LLU; // reporttype
3101231078 break;
3101331079 }
31014- case 2558LLU: // copy-back deleter (reporttype to initfrom)
31080+ case 2563LLU: // copy-back deleter (reporttype to initfrom)
3101531081 {
3101631082 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3101731083 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31023,10 +31089,10 @@
3102331089 }
3102431090 Free(10LLU + 1, sizeof(uint64_t), stack);
3102531091 stack = oldstack;
31026- label = 2508LLU; // continue to unroll stack
31092+ label = 2513LLU; // continue to unroll stack
3102731093 break;
3102831094 }
31029- case 2559LLU: // return from reporttype to initfrom
31095+ case 2564LLU: // return from reporttype to initfrom
3103031096 {
3103131097 uint64_t *oldstack = (uint64_t *)stack[0];
3103231098 // copy mutable arguments back from call to reporttype
@@ -31041,7 +31107,7 @@
3104131107 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3104231108 if(!newstack)
3104331109 {
31044- label = 2508LLU; // throw: begin to unroll stack
31110+ label = 2513LLU; // throw: begin to unroll stack
3104531111 break;
3104631112 }
3104731113
@@ -31048,9 +31114,9 @@
3104831114 newstack[10LLU] = 9876543210LLU; // overflow-marker
3104931115 // call reporttype from initfrom
3105031116 newstack[0] = (uint64_t)stack; // backup stack location
31051- newstack[1] = 2560LLU;
31117+ newstack[1] = 2565LLU;
3105231118 newstack[2] = base;
31053- newstack[3] = 2561LLU;
31119+ newstack[3] = 2566LLU;
3105431120 // arguments for call to reporttype
3105531121 newstack[4LLU] = stack[base + 31]/*dsttype*/;
3105631122 stack = newstack;
@@ -31059,7 +31125,7 @@
3105931125 label = 316LLU; // reporttype
3106031126 break;
3106131127 }
31062- case 2560LLU: // copy-back deleter (reporttype to initfrom)
31128+ case 2565LLU: // copy-back deleter (reporttype to initfrom)
3106331129 {
3106431130 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3106531131 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31071,10 +31137,10 @@
3107131137 }
3107231138 Free(10LLU + 1, sizeof(uint64_t), stack);
3107331139 stack = oldstack;
31074- label = 2508LLU; // continue to unroll stack
31140+ label = 2513LLU; // continue to unroll stack
3107531141 break;
3107631142 }
31077- case 2561LLU: // return from reporttype to initfrom
31143+ case 2566LLU: // return from reporttype to initfrom
3107831144 {
3107931145 uint64_t *oldstack = (uint64_t *)stack[0];
3108031146 // copy mutable arguments back from call to reporttype
@@ -31089,7 +31155,7 @@
3108931155 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3109031156 if(!newstack)
3109131157 {
31092- label = 2508LLU; // throw: begin to unroll stack
31158+ label = 2513LLU; // throw: begin to unroll stack
3109331159 break;
3109431160 }
3109531161
@@ -31096,9 +31162,9 @@
3109631162 newstack[10LLU] = 9876543210LLU; // overflow-marker
3109731163 // call reporttype from initfrom
3109831164 newstack[0] = (uint64_t)stack; // backup stack location
31099- newstack[1] = 2562LLU;
31165+ newstack[1] = 2567LLU;
3110031166 newstack[2] = base;
31101- newstack[3] = 2563LLU;
31167+ newstack[3] = 2568LLU;
3110231168 // arguments for call to reporttype
3110331169 newstack[4LLU] = stack[base + 33]/*srctype*/;
3110431170 stack = newstack;
@@ -31107,7 +31173,7 @@
3110731173 label = 316LLU; // reporttype
3110831174 break;
3110931175 }
31110- case 2562LLU: // copy-back deleter (reporttype to initfrom)
31176+ case 2567LLU: // copy-back deleter (reporttype to initfrom)
3111131177 {
3111231178 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3111331179 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31119,10 +31185,10 @@
3111931185 }
3112031186 Free(10LLU + 1, sizeof(uint64_t), stack);
3112131187 stack = oldstack;
31122- label = 2508LLU; // continue to unroll stack
31188+ label = 2513LLU; // continue to unroll stack
3112331189 break;
3112431190 }
31125- case 2563LLU: // return from reporttype to initfrom
31191+ case 2568LLU: // return from reporttype to initfrom
3112631192 {
3112731193 uint64_t *oldstack = (uint64_t *)stack[0];
3112831194 // copy mutable arguments back from call to reporttype
@@ -31135,9 +31201,9 @@
3113531201 stack = oldstack;
3113631202 fprintf(stderr, "%s", " ");
3113731203 // call reportid from initfrom
31138- stack[base + 34LLU] = 2564LLU/*throw to this address*/;
31204+ stack[base + 34LLU] = 2569LLU/*throw to this address*/;
3113931205 stack[base + 35LLU] = base;
31140- stack[base + 36LLU] = 2565LLU;
31206+ stack[base + 36LLU] = 2570LLU;
3114131207 // arguments for call to reportid
3114231208 stack[base + 37LLU] = stack[base + 13]/*content*/;
3114331209 // set stack-base & callee-address
@@ -31145,22 +31211,22 @@
3114531211 label = 18446744073709551586LLU; // reportid
3114631212 break;
3114731213 }
31148- case 2564LLU: // copy-back deleter (reportid to initfrom)
31214+ case 2569LLU: // copy-back deleter (reportid to initfrom)
3114931215 {
3115031216 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3115131217 // copy mutable arguments back from call to reportid
31152- label = 2508LLU; // continue to roll stack
31218+ label = 2513LLU; // continue to roll stack
3115331219 break;
3115431220 }
31155- case 2565LLU: // return from reportid to initfrom
31221+ case 2570LLU: // return from reportid to initfrom
3115631222 {
3115731223 // copy mutable arguments back from call to reportid
3115831224 fprintf(stderr, "%s", "\n");
3115931225 exit(-1);
31160- label = 2526LLU; // alternative complete
31226+ label = 2531LLU; // alternative complete
3116131227 break;
3116231228 }
31163- case 2526LLU: // completed if-then-else
31229+ case 2531LLU: // completed if-then-else
3116431230 {
3116531231
3116631232 uint64_t *newstack = (uint64_t *)(stack[base + 33] - sizeof(uint64_t) * 4);
@@ -31168,7 +31234,7 @@
3116831234 newstack[0] = (uint64_t)stack; // backup stack location
3116931235 newstack[1] = 1234567890;
3117031236 newstack[2] = base;
31171- newstack[3] = 2566LLU;
31237+ newstack[3] = 2571LLU;
3117231238 stack = newstack;
3117331239 // set stack-base & callee-address
3117431240 base = 4/*deloffset*/;
@@ -31175,7 +31241,7 @@
3117531241 label = 296LLU; // ~type
3117631242 break;
3117731243 }
31178- case 2566LLU: // return from ~type to initfrom
31244+ case 2571LLU: // return from ~type to initfrom
3117931245 {
3118031246 stack = (uint64_t *)stack[0];
3118131247 // releasing toplevel container
@@ -31183,27 +31249,27 @@
3118331249
3118431250 ((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
3118531251 ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31186- label = 2506LLU; // case complete
31252+ label = 2511LLU; // case complete
3118731253 break;
3118831254 }
31189- case 2508LLU: // copy-back deleter (switch)
31255+ case 2513LLU: // copy-back deleter (switch)
3119031256 {
3119131257 ((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
3119231258 ((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31193- label = 2505LLU; // continue to unroll stack
31259+ label = 2510LLU; // continue to unroll stack
3119431260 break;
3119531261 }
31196- case 2507LLU: // try next case
31262+ case 2512LLU: // try next case
3119731263 {
3119831264 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3119931265 exit(-1);
3120031266 }
31201- case 2506LLU: // completed switch
31267+ case 2511LLU: // completed switch
3120231268 {
3120331269 // call add from initfrom
31204- stack[base + 31LLU] = 2567LLU/*throw to this address*/;
31270+ stack[base + 31LLU] = 2572LLU/*throw to this address*/;
3120531271 stack[base + 32LLU] = base;
31206- stack[base + 33LLU] = 2568LLU;
31272+ stack[base + 33LLU] = 2573LLU;
3120731273 // arguments for call to add
3120831274 stack[base + 35LLU] = stack[base + 27]/*elemindex*/;
3120931275 stack[base + 36LLU] = 1LLU;
@@ -31212,34 +31278,34 @@
3121231278 label = 18446744073709551605LLU; // add
3121331279 break;
3121431280 }
31215- case 2567LLU: // copy-back deleter (add to initfrom)
31281+ case 2572LLU: // copy-back deleter (add to initfrom)
3121631282 {
3121731283 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
3121831284 // copy mutable arguments back from call to add
31219- label = 2505LLU; // continue to roll stack
31285+ label = 2510LLU; // continue to roll stack
3122031286 break;
3122131287 }
31222- case 2568LLU: // return from add to initfrom
31288+ case 2573LLU: // return from add to initfrom
3122331289 {
3122431290 // copy mutable arguments back from call to add
3122531291 // copy back results provided by call to add
3122631292 stack[base + 27] = stack[base + 34LLU];
3122731293 ((struct listnode *)(stack[base + 30]/*previous*/))->data = stack[base + 29];
31228- label = 2503LLU; // repeat
31294+ label = 2508LLU; // repeat
3122931295 break;
3123031296 }
31231- case 2505LLU: // copy-back deleter for while next
31297+ case 2510LLU: // copy-back deleter for while next
3123231298 {
3123331299 ((struct listnode *)(stack[base + 30]/*previous*/))->data = stack[base + 29];
31234- label = 2501LLU; // continue to unroll stack
31300+ label = 2506LLU; // continue to unroll stack
3123531301 break;
3123631302 }
31237- case 2504LLU: // loop finished
31303+ case 2509LLU: // loop finished
3123831304 {
3123931305 // call matchsym from initfrom
31240- stack[base + 31LLU] = 2569LLU/*throw to this address*/;
31306+ stack[base + 31LLU] = 2574LLU/*throw to this address*/;
3124131307 stack[base + 32LLU] = base;
31242- stack[base + 33LLU] = 2570LLU;
31308+ stack[base + 33LLU] = 2575LLU;
3124331309 // arguments for call to matchsym
3124431310 stack[base + 34LLU] = stack[base + 0]/*fnid*/;
3124531311 stack[base + 35LLU] = 41LLU;
@@ -31249,36 +31315,36 @@
3124931315 label = 212LLU; // matchsym
3125031316 break;
3125131317 }
31252- case 2569LLU: // copy-back deleter (matchsym to initfrom)
31318+ case 2574LLU: // copy-back deleter (matchsym to initfrom)
3125331319 {
3125431320 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3125531321 // copy mutable arguments back from call to matchsym
3125631322 stack[base + 7]/*lookahead*/ = stack[base + 36LLU];
31257- label = 2501LLU; // continue to roll stack
31323+ label = 2506LLU; // continue to roll stack
3125831324 break;
3125931325 }
31260- case 2570LLU: // return from matchsym to initfrom
31326+ case 2575LLU: // return from matchsym to initfrom
3126131327 {
3126231328 // copy mutable arguments back from call to matchsym
3126331329 stack[base + 7]/*lookahead*/ = stack[base + 36LLU];
3126431330 ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
3126531331 ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31266- label = 2478LLU; // case complete
31332+ label = 2483LLU; // case complete
3126731333 break;
3126831334 }
31269- case 2480LLU: // copy-back deleter (switch)
31335+ case 2485LLU: // copy-back deleter (switch)
3127031336 {
3127131337 ((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
3127231338 ((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31273- label = 2475LLU; // continue to unroll stack
31339+ label = 2480LLU; // continue to unroll stack
3127431340 break;
3127531341 }
31276- case 2479LLU: // try next case
31342+ case 2484LLU: // try next case
3127731343 {
3127831344 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3127931345 exit(-1);
3128031346 }
31281- case 2478LLU: // completed switch
31347+ case 2483LLU: // completed switch
3128231348 {
3128331349
3128431350 uint64_t *newstack = (uint64_t *)(stack[base + 23] - sizeof(uint64_t) * 4);
@@ -31286,7 +31352,7 @@
3128631352 newstack[0] = (uint64_t)stack; // backup stack location
3128731353 newstack[1] = 1234567890;
3128831354 newstack[2] = base;
31289- newstack[3] = 2571LLU;
31355+ newstack[3] = 2576LLU;
3129031356 stack = newstack;
3129131357 // set stack-base & callee-address
3129231358 base = 4/*deloffset*/;
@@ -31293,7 +31359,7 @@
3129331359 label = 870LLU; // ~variant
3129431360 break;
3129531361 }
31296- case 2571LLU: // return from ~variant to initfrom
31362+ case 2576LLU: // return from ~variant to initfrom
3129731363 {
3129831364 stack = (uint64_t *)stack[0];
3129931365 // releasing toplevel container
@@ -31302,23 +31368,23 @@
3130231368 ((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
3130331369 ((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
3130431370 ((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31305- label = 2473LLU; // case complete
31371+ label = 2478LLU; // case complete
3130631372 break;
3130731373 }
31308- case 2475LLU: // copy-back deleter (switch)
31374+ case 2480LLU: // copy-back deleter (switch)
3130931375 {
3131031376 ((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
3131131377 ((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
3131231378 ((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31313- label = 2460LLU; // continue to unroll stack
31379+ label = 2465LLU; // continue to unroll stack
3131431380 break;
3131531381 }
31316- case 2474LLU: // try next case
31382+ case 2479LLU: // try next case
3131731383 {
3131831384 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3131931385 exit(-1);
3132031386 }
31321- case 2473LLU: // completed switch
31387+ case 2478LLU: // completed switch
3132231388 {
3132331389
3132431390 uint64_t *newstack = (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4);
@@ -31326,7 +31392,7 @@
3132631392 newstack[0] = (uint64_t)stack; // backup stack location
3132731393 newstack[1] = 1234567890;
3132831394 newstack[2] = base;
31329- newstack[3] = 2572LLU;
31395+ newstack[3] = 2577LLU;
3133031396 stack = newstack;
3133131397 // set stack-base & callee-address
3133231398 base = 4/*deloffset*/;
@@ -31333,7 +31399,7 @@
3133331399 label = 945LLU; // ~datadef
3133431400 break;
3133531401 }
31336- case 2572LLU: // return from ~datadef to initfrom
31402+ case 2577LLU: // return from ~datadef to initfrom
3133731403 {
3133831404 stack = (uint64_t *)stack[0];
3133931405 // releasing toplevel container
@@ -31340,23 +31406,23 @@
3134031406 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 18] - sizeof(uint64_t) * 4));
3134131407
3134231408 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31343- label = 2458LLU; // case complete
31409+ label = 2463LLU; // case complete
3134431410 break;
3134531411 }
31346- case 2460LLU: // copy-back deleter (switch)
31412+ case 2465LLU: // copy-back deleter (switch)
3134731413 {
3134831414 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31349- label = 2259LLU; // continue to unroll stack
31415+ label = 2295LLU; // continue to unroll stack
3135031416 break;
3135131417 }
31352- case 2459LLU: // try next case
31418+ case 2464LLU: // try next case
3135331419 {
3135431420 // default
3135531421 fprintf(stderr, "%s", "in function ");
3135631422 // call reportid from initfrom
31357- stack[base + 17LLU] = 2573LLU/*throw to this address*/;
31423+ stack[base + 17LLU] = 2578LLU/*throw to this address*/;
3135831424 stack[base + 18LLU] = base;
31359- stack[base + 19LLU] = 2574LLU;
31425+ stack[base + 19LLU] = 2579LLU;
3136031426 // arguments for call to reportid
3136131427 stack[base + 20LLU] = stack[base + 0]/*fnid*/;
3136231428 // set stack-base & callee-address
@@ -31364,14 +31430,14 @@
3136431430 label = 18446744073709551586LLU; // reportid
3136531431 break;
3136631432 }
31367- case 2573LLU: // copy-back deleter (reportid to initfrom)
31433+ case 2578LLU: // copy-back deleter (reportid to initfrom)
3136831434 {
3136931435 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3137031436 // copy mutable arguments back from call to reportid
31371- label = 2259LLU; // continue to roll stack
31437+ label = 2295LLU; // continue to roll stack
3137231438 break;
3137331439 }
31374- case 2574LLU: // return from reportid to initfrom
31440+ case 2579LLU: // return from reportid to initfrom
3137531441 {
3137631442 // copy mutable arguments back from call to reportid
3137731443 fprintf(stderr, "%s", ": type ");
@@ -31378,7 +31444,7 @@
3137831444 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3137931445 if(!newstack)
3138031446 {
31381- label = 2259LLU; // throw: begin to unroll stack
31447+ label = 2295LLU; // throw: begin to unroll stack
3138231448 break;
3138331449 }
3138431450
@@ -31385,9 +31451,9 @@
3138531451 newstack[10LLU] = 9876543210LLU; // overflow-marker
3138631452 // call reporttype from initfrom
3138731453 newstack[0] = (uint64_t)stack; // backup stack location
31388- newstack[1] = 2575LLU;
31454+ newstack[1] = 2580LLU;
3138931455 newstack[2] = base;
31390- newstack[3] = 2576LLU;
31456+ newstack[3] = 2581LLU;
3139131457 // arguments for call to reporttype
3139231458 newstack[4LLU] = stack[base + 1]/*dsttype*/;
3139331459 stack = newstack;
@@ -31396,7 +31462,7 @@
3139631462 label = 316LLU; // reporttype
3139731463 break;
3139831464 }
31399- case 2575LLU: // copy-back deleter (reporttype to initfrom)
31465+ case 2580LLU: // copy-back deleter (reporttype to initfrom)
3140031466 {
3140131467 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3140231468 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31408,10 +31474,10 @@
3140831474 }
3140931475 Free(10LLU + 1, sizeof(uint64_t), stack);
3141031476 stack = oldstack;
31411- label = 2259LLU; // continue to unroll stack
31477+ label = 2295LLU; // continue to unroll stack
3141231478 break;
3141331479 }
31414- case 2576LLU: // return from reporttype to initfrom
31480+ case 2581LLU: // return from reporttype to initfrom
3141531481 {
3141631482 uint64_t *oldstack = (uint64_t *)stack[0];
3141731483 // copy mutable arguments back from call to reporttype
@@ -31424,9 +31490,9 @@
3142431490 stack = oldstack;
3142531491 fprintf(stderr, "%s", " has no constructor ");
3142631492 // call reportid from initfrom
31427- stack[base + 17LLU] = 2577LLU/*throw to this address*/;
31493+ stack[base + 17LLU] = 2582LLU/*throw to this address*/;
3142831494 stack[base + 18LLU] = base;
31429- stack[base + 19LLU] = 2578LLU;
31495+ stack[base + 19LLU] = 2583LLU;
3143031496 // arguments for call to reportid
3143131497 stack[base + 20LLU] = stack[base + 13]/*content*/;
3143231498 // set stack-base & callee-address
@@ -31434,32 +31500,32 @@
3143431500 label = 18446744073709551586LLU; // reportid
3143531501 break;
3143631502 }
31437- case 2577LLU: // copy-back deleter (reportid to initfrom)
31503+ case 2582LLU: // copy-back deleter (reportid to initfrom)
3143831504 {
3143931505 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3144031506 // copy mutable arguments back from call to reportid
31441- label = 2259LLU; // continue to roll stack
31507+ label = 2295LLU; // continue to roll stack
3144231508 break;
3144331509 }
31444- case 2578LLU: // return from reportid to initfrom
31510+ case 2583LLU: // return from reportid to initfrom
3144531511 {
3144631512 // copy mutable arguments back from call to reportid
3144731513 fprintf(stderr, "%s", " - if you mean call enclose type and variable-name in perentheses\n");
3144831514 exit(-1);
31449- label = 2458LLU; // default complete
31515+ label = 2463LLU; // default complete
3145031516 break;
3145131517 }
31452- case 2458LLU: // completed switch
31518+ case 2463LLU: // completed switch
3145331519 {
31454- label = 2457LLU; // consequent complete
31520+ label = 2462LLU; // consequent complete
3145531521 break;
3145631522 }
31457- case 2456LLU: // alternative
31523+ case 2461LLU: // alternative
3145831524 {
3145931525 // call getlettype from initfrom
31460- stack[base + 18LLU] = 2579LLU/*throw to this address*/;
31526+ stack[base + 18LLU] = 2584LLU/*throw to this address*/;
3146131527 stack[base + 19LLU] = base;
31462- stack[base + 20LLU] = 2580LLU;
31528+ stack[base + 20LLU] = 2585LLU;
3146331529 // arguments for call to getlettype
3146431530 stack[base + 22LLU] = stack[base + 0]/*fnid*/;
3146531531 stack[base + 23LLU] = stack[base + 13]/*content*/;
@@ -31470,14 +31536,14 @@
3147031536 label = 651LLU; // getlettype
3147131537 break;
3147231538 }
31473- case 2579LLU: // copy-back deleter (getlettype to initfrom)
31539+ case 2584LLU: // copy-back deleter (getlettype to initfrom)
3147431540 {
3147531541 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
3147631542 // copy mutable arguments back from call to getlettype
31477- label = 2259LLU; // continue to roll stack
31543+ label = 2295LLU; // continue to roll stack
3147831544 break;
3147931545 }
31480- case 2580LLU: // return from getlettype to initfrom
31546+ case 2585LLU: // return from getlettype to initfrom
3148131547 {
3148231548 // copy mutable arguments back from call to getlettype
3148331549 // copy back results provided by call to getlettype
@@ -31484,7 +31550,7 @@
3148431550 stack[base + 17] = stack[base + 21LLU];
3148531551 if(/*typename*/0 != ((uint64_t *)(stack[base + 17]/*dsttype*/))[0])
3148631552 {
31487- label = 2582LLU; // jump to alternative
31553+ label = 2587LLU; // jump to alternative
3148831554 break;
3148931555 }
3149031556
@@ -31492,9 +31558,9 @@
3149231558
3149331559 // case
3149431560 // call equ from initfrom
31495- stack[base + 19LLU] = 2584LLU/*throw to this address*/;
31561+ stack[base + 19LLU] = 2589LLU/*throw to this address*/;
3149631562 stack[base + 20LLU] = base;
31497- stack[base + 21LLU] = 2585LLU;
31563+ stack[base + 21LLU] = 2590LLU;
3149831564 // arguments for call to equ
3149931565 stack[base + 23LLU] = stack[base + 18]/*name*/;
3150031566 stack[base + 24LLU] = 881834713755418624LLU;
@@ -31503,14 +31569,14 @@
3150331569 label = 18446744073709551600LLU; // equ
3150431570 break;
3150531571 }
31506- case 2584LLU: // copy-back deleter (equ to initfrom)
31572+ case 2589LLU: // copy-back deleter (equ to initfrom)
3150731573 {
3150831574 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3150931575 // copy mutable arguments back from call to equ
31510- label = 2583LLU; // continue to roll stack
31576+ label = 2588LLU; // continue to roll stack
3151131577 break;
3151231578 }
31513- case 2585LLU: // return from equ to initfrom
31579+ case 2590LLU: // return from equ to initfrom
3151431580 {
3151531581 // copy mutable arguments back from call to equ
3151631582 // copy back results provided by call to equ
@@ -31517,7 +31583,7 @@
3151731583 stack[base + 10] = stack[base + 22LLU];
3151831584 if(!stack[base + 10]/*isequal*/)
3151931585 {
31520- label = 2586LLU; // jump to alternative
31586+ label = 2591LLU; // jump to alternative
3152131587 break;
3152231588 }
3152331589
@@ -31524,9 +31590,9 @@
3152431590 // consequent
3152531591 printf("%s", "\n ");
3152631592 // call emitvaridx from initfrom
31527- stack[base + 19LLU] = 2588LLU/*throw to this address*/;
31593+ stack[base + 19LLU] = 2593LLU/*throw to this address*/;
3152831594 stack[base + 20LLU] = base;
31529- stack[base + 21LLU] = 2589LLU;
31595+ stack[base + 21LLU] = 2594LLU;
3153031596 // arguments for call to emitvaridx
3153131597 stack[base + 22LLU] = stack[base + 3]/*dstindex*/;
3153231598 // set stack-base & callee-address
@@ -31534,21 +31600,21 @@
3153431600 label = 691LLU; // emitvaridx
3153531601 break;
3153631602 }
31537- case 2588LLU: // copy-back deleter (emitvaridx to initfrom)
31603+ case 2593LLU: // copy-back deleter (emitvaridx to initfrom)
3153831604 {
3153931605 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3154031606 // copy mutable arguments back from call to emitvaridx
31541- label = 2583LLU; // continue to roll stack
31607+ label = 2588LLU; // continue to roll stack
3154231608 break;
3154331609 }
31544- case 2589LLU: // return from emitvaridx to initfrom
31610+ case 2594LLU: // return from emitvaridx to initfrom
3154531611 {
3154631612 // copy mutable arguments back from call to emitvaridx
3154731613 printf("%s", " = ");
3154831614 // call emitvar from initfrom
31549- stack[base + 19LLU] = 2590LLU/*throw to this address*/;
31615+ stack[base + 19LLU] = 2595LLU/*throw to this address*/;
3155031616 stack[base + 20LLU] = base;
31551- stack[base + 21LLU] = 2591LLU;
31617+ stack[base + 21LLU] = 2596LLU;
3155231618 // arguments for call to emitvar
3155331619 stack[base + 22LLU] = stack[base + 0]/*fnid*/;
3155431620 stack[base + 23LLU] = stack[base + 13]/*content*/;
@@ -31559,27 +31625,27 @@
3155931625 label = 695LLU; // emitvar
3156031626 break;
3156131627 }
31562- case 2590LLU: // copy-back deleter (emitvar to initfrom)
31628+ case 2595LLU: // copy-back deleter (emitvar to initfrom)
3156331629 {
3156431630 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3156531631 // copy mutable arguments back from call to emitvar
31566- label = 2583LLU; // continue to roll stack
31632+ label = 2588LLU; // continue to roll stack
3156731633 break;
3156831634 }
31569- case 2591LLU: // return from emitvar to initfrom
31635+ case 2596LLU: // return from emitvar to initfrom
3157031636 {
3157131637 // copy mutable arguments back from call to emitvar
3157231638 printf("%s", ";");
31573- label = 2587LLU; // consequent complete
31639+ label = 2592LLU; // consequent complete
3157431640 break;
3157531641 }
31576- case 2586LLU: // alternative
31642+ case 2591LLU: // alternative
3157731643 {
3157831644 printf("%s", "\n INIT(&");
3157931645 // call emitvaridx from initfrom
31580- stack[base + 19LLU] = 2592LLU/*throw to this address*/;
31646+ stack[base + 19LLU] = 2597LLU/*throw to this address*/;
3158131647 stack[base + 20LLU] = base;
31582- stack[base + 21LLU] = 2593LLU;
31648+ stack[base + 21LLU] = 2598LLU;
3158331649 // arguments for call to emitvaridx
3158431650 stack[base + 22LLU] = stack[base + 3]/*dstindex*/;
3158531651 // set stack-base & callee-address
@@ -31587,21 +31653,21 @@
3158731653 label = 691LLU; // emitvaridx
3158831654 break;
3158931655 }
31590- case 2592LLU: // copy-back deleter (emitvaridx to initfrom)
31656+ case 2597LLU: // copy-back deleter (emitvaridx to initfrom)
3159131657 {
3159231658 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3159331659 // copy mutable arguments back from call to emitvaridx
31594- label = 2583LLU; // continue to roll stack
31660+ label = 2588LLU; // continue to roll stack
3159531661 break;
3159631662 }
31597- case 2593LLU: // return from emitvaridx to initfrom
31663+ case 2598LLU: // return from emitvaridx to initfrom
3159831664 {
3159931665 // copy mutable arguments back from call to emitvaridx
3160031666 printf("%s", ", &");
3160131667 // call emitvar from initfrom
31602- stack[base + 19LLU] = 2594LLU/*throw to this address*/;
31668+ stack[base + 19LLU] = 2599LLU/*throw to this address*/;
3160331669 stack[base + 20LLU] = base;
31604- stack[base + 21LLU] = 2595LLU;
31670+ stack[base + 21LLU] = 2600LLU;
3160531671 // arguments for call to emitvar
3160631672 stack[base + 22LLU] = stack[base + 0]/*fnid*/;
3160731673 stack[base + 23LLU] = stack[base + 13]/*content*/;
@@ -31612,21 +31678,21 @@
3161231678 label = 695LLU; // emitvar
3161331679 break;
3161431680 }
31615- case 2594LLU: // copy-back deleter (emitvar to initfrom)
31681+ case 2599LLU: // copy-back deleter (emitvar to initfrom)
3161631682 {
3161731683 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3161831684 // copy mutable arguments back from call to emitvar
31619- label = 2583LLU; // continue to roll stack
31685+ label = 2588LLU; // continue to roll stack
3162031686 break;
3162131687 }
31622- case 2595LLU: // return from emitvar to initfrom
31688+ case 2600LLU: // return from emitvar to initfrom
3162331689 {
3162431690 // copy mutable arguments back from call to emitvar
3162531691 printf("%s", ");");
3162631692 // call unscopelet from initfrom
31627- stack[base + 19LLU] = 2596LLU/*throw to this address*/;
31693+ stack[base + 19LLU] = 2601LLU/*throw to this address*/;
3162831694 stack[base + 20LLU] = base;
31629- stack[base + 21LLU] = 2597LLU;
31695+ stack[base + 21LLU] = 2602LLU;
3163031696 // arguments for call to unscopelet
3163131697 stack[base + 22LLU] = stack[base + 0]/*fnid*/;
3163231698 stack[base + 23LLU] = stack[base + 6]/*scope*/;
@@ -31636,41 +31702,41 @@
3163631702 label = 761LLU; // unscopelet
3163731703 break;
3163831704 }
31639- case 2596LLU: // copy-back deleter (unscopelet to initfrom)
31705+ case 2601LLU: // copy-back deleter (unscopelet to initfrom)
3164031706 {
3164131707 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3164231708 // copy mutable arguments back from call to unscopelet
3164331709 stack[base + 6]/*scope*/ = stack[base + 23LLU];
31644- label = 2583LLU; // continue to roll stack
31710+ label = 2588LLU; // continue to roll stack
3164531711 break;
3164631712 }
31647- case 2597LLU: // return from unscopelet to initfrom
31713+ case 2602LLU: // return from unscopelet to initfrom
3164831714 {
3164931715 // copy mutable arguments back from call to unscopelet
3165031716 stack[base + 6]/*scope*/ = stack[base + 23LLU];
31651- label = 2587LLU; // alternative complete
31717+ label = 2592LLU; // alternative complete
3165231718 break;
3165331719 }
31654- case 2587LLU: // completed if-then-else
31720+ case 2592LLU: // completed if-then-else
3165531721 {
3165631722 ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31657- label = 2581LLU; // case complete
31723+ label = 2586LLU; // case complete
3165831724 break;
3165931725 }
31660- case 2583LLU: // copy-back deleter (switch)
31726+ case 2588LLU: // copy-back deleter (switch)
3166131727 {
3166231728 ((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31663- label = 2259LLU; // continue to unroll stack
31729+ label = 2295LLU; // continue to unroll stack
3166431730 break;
3166531731 }
31666- case 2582LLU: // try next case
31732+ case 2587LLU: // try next case
3166731733 {
3166831734 // default
3166931735 printf("%s", "\n INIT(&");
3167031736 // call emitvaridx from initfrom
31671- stack[base + 18LLU] = 2598LLU/*throw to this address*/;
31737+ stack[base + 18LLU] = 2603LLU/*throw to this address*/;
3167231738 stack[base + 19LLU] = base;
31673- stack[base + 20LLU] = 2599LLU;
31739+ stack[base + 20LLU] = 2604LLU;
3167431740 // arguments for call to emitvaridx
3167531741 stack[base + 21LLU] = stack[base + 3]/*dstindex*/;
3167631742 // set stack-base & callee-address
@@ -31678,21 +31744,21 @@
3167831744 label = 691LLU; // emitvaridx
3167931745 break;
3168031746 }
31681- case 2598LLU: // copy-back deleter (emitvaridx to initfrom)
31747+ case 2603LLU: // copy-back deleter (emitvaridx to initfrom)
3168231748 {
3168331749 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3168431750 // copy mutable arguments back from call to emitvaridx
31685- label = 2259LLU; // continue to roll stack
31751+ label = 2295LLU; // continue to roll stack
3168631752 break;
3168731753 }
31688- case 2599LLU: // return from emitvaridx to initfrom
31754+ case 2604LLU: // return from emitvaridx to initfrom
3168931755 {
3169031756 // copy mutable arguments back from call to emitvaridx
3169131757 printf("%s", ", &");
3169231758 // call emitvar from initfrom
31693- stack[base + 18LLU] = 2600LLU/*throw to this address*/;
31759+ stack[base + 18LLU] = 2605LLU/*throw to this address*/;
3169431760 stack[base + 19LLU] = base;
31695- stack[base + 20LLU] = 2601LLU;
31761+ stack[base + 20LLU] = 2606LLU;
3169631762 // arguments for call to emitvar
3169731763 stack[base + 21LLU] = stack[base + 0]/*fnid*/;
3169831764 stack[base + 22LLU] = stack[base + 13]/*content*/;
@@ -31703,21 +31769,21 @@
3170331769 label = 695LLU; // emitvar
3170431770 break;
3170531771 }
31706- case 2600LLU: // copy-back deleter (emitvar to initfrom)
31772+ case 2605LLU: // copy-back deleter (emitvar to initfrom)
3170731773 {
3170831774 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
3170931775 // copy mutable arguments back from call to emitvar
31710- label = 2259LLU; // continue to roll stack
31776+ label = 2295LLU; // continue to roll stack
3171131777 break;
3171231778 }
31713- case 2601LLU: // return from emitvar to initfrom
31779+ case 2606LLU: // return from emitvar to initfrom
3171431780 {
3171531781 // copy mutable arguments back from call to emitvar
3171631782 printf("%s", ");");
3171731783 // call unscopelet from initfrom
31718- stack[base + 18LLU] = 2602LLU/*throw to this address*/;
31784+ stack[base + 18LLU] = 2607LLU/*throw to this address*/;
3171931785 stack[base + 19LLU] = base;
31720- stack[base + 20LLU] = 2603LLU;
31786+ stack[base + 20LLU] = 2608LLU;
3172131787 // arguments for call to unscopelet
3172231788 stack[base + 21LLU] = stack[base + 0]/*fnid*/;
3172331789 stack[base + 22LLU] = stack[base + 6]/*scope*/;
@@ -31727,22 +31793,22 @@
3172731793 label = 761LLU; // unscopelet
3172831794 break;
3172931795 }
31730- case 2602LLU: // copy-back deleter (unscopelet to initfrom)
31796+ case 2607LLU: // copy-back deleter (unscopelet to initfrom)
3173131797 {
3173231798 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
3173331799 // copy mutable arguments back from call to unscopelet
3173431800 stack[base + 6]/*scope*/ = stack[base + 22LLU];
31735- label = 2259LLU; // continue to roll stack
31801+ label = 2295LLU; // continue to roll stack
3173631802 break;
3173731803 }
31738- case 2603LLU: // return from unscopelet to initfrom
31804+ case 2608LLU: // return from unscopelet to initfrom
3173931805 {
3174031806 // copy mutable arguments back from call to unscopelet
3174131807 stack[base + 6]/*scope*/ = stack[base + 22LLU];
31742- label = 2581LLU; // default complete
31808+ label = 2586LLU; // default complete
3174331809 break;
3174431810 }
31745- case 2581LLU: // completed switch
31811+ case 2586LLU: // completed switch
3174631812 {
3174731813
3174831814 uint64_t *newstack = (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4);
@@ -31750,7 +31816,7 @@
3175031816 newstack[0] = (uint64_t)stack; // backup stack location
3175131817 newstack[1] = 1234567890;
3175231818 newstack[2] = base;
31753- newstack[3] = 2604LLU;
31819+ newstack[3] = 2609LLU;
3175431820 stack = newstack;
3175531821 // set stack-base & callee-address
3175631822 base = 4/*deloffset*/;
@@ -31757,30 +31823,30 @@
3175731823 label = 296LLU; // ~type
3175831824 break;
3175931825 }
31760- case 2604LLU: // return from ~type to initfrom
31826+ case 2609LLU: // return from ~type to initfrom
3176131827 {
3176231828 stack = (uint64_t *)stack[0];
3176331829 // releasing toplevel container
3176431830 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 17] - sizeof(uint64_t) * 4));
3176531831
31766- label = 2457LLU; // alternative complete
31832+ label = 2462LLU; // alternative complete
3176731833 break;
3176831834 }
31769- case 2457LLU: // completed if-then-else
31835+ case 2462LLU: // completed if-then-else
3177031836 {
31771- label = 2315LLU; // alternative complete
31837+ label = 2320LLU; // alternative complete
3177231838 break;
3177331839 }
31774- case 2315LLU: // completed if-then-else
31840+ case 2320LLU: // completed if-then-else
3177531841 {
31776- label = 2309LLU; // consequent complete
31842+ label = 2314LLU; // consequent complete
3177731843 break;
3177831844 }
31779- case 2308LLU: // alternative
31845+ case 2313LLU: // alternative
3178031846 {
3178131847 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*dsttype*/))[0])
3178231848 {
31783- label = 2606LLU; // jump to alternative
31849+ label = 2611LLU; // jump to alternative
3178431850 break;
3178531851 }
3178631852
@@ -31788,9 +31854,9 @@
3178831854
3178931855 // case
3179031856 // call equ from initfrom
31791- stack[base + 16LLU] = 2608LLU/*throw to this address*/;
31857+ stack[base + 16LLU] = 2613LLU/*throw to this address*/;
3179231858 stack[base + 17LLU] = base;
31793- stack[base + 18LLU] = 2609LLU;
31859+ stack[base + 18LLU] = 2614LLU;
3179431860 // arguments for call to equ
3179531861 stack[base + 20LLU] = 881834713755418624LLU;
3179631862 stack[base + 21LLU] = stack[base + 15]/*name*/;
@@ -31799,14 +31865,14 @@
3179931865 label = 18446744073709551600LLU; // equ
3180031866 break;
3180131867 }
31802- case 2608LLU: // copy-back deleter (equ to initfrom)
31868+ case 2613LLU: // copy-back deleter (equ to initfrom)
3180331869 {
3180431870 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
3180531871 // copy mutable arguments back from call to equ
31806- label = 2607LLU; // continue to roll stack
31872+ label = 2612LLU; // continue to roll stack
3180731873 break;
3180831874 }
31809- case 2609LLU: // return from equ to initfrom
31875+ case 2614LLU: // return from equ to initfrom
3181031876 {
3181131877 // copy mutable arguments back from call to equ
3181231878 // copy back results provided by call to equ
@@ -31813,15 +31879,15 @@
3181331879 stack[base + 10] = stack[base + 19LLU];
3181431880 if(!stack[base + 10]/*isequal*/)
3181531881 {
31816- label = 2610LLU; // jump to alternative
31882+ label = 2615LLU; // jump to alternative
3181731883 break;
3181831884 }
3181931885
3182031886 // consequent
3182131887 // call isncs from initfrom
31822- stack[base + 16LLU] = 2612LLU/*throw to this address*/;
31888+ stack[base + 16LLU] = 2617LLU/*throw to this address*/;
3182331889 stack[base + 17LLU] = base;
31824- stack[base + 18LLU] = 2613LLU;
31890+ stack[base + 18LLU] = 2618LLU;
3182531891 // arguments for call to isncs
3182631892 stack[base + 20LLU] = stack[base + 12]/*variant*/;
3182731893 // set stack-base & callee-address
@@ -31829,14 +31895,14 @@
3182931895 label = 272LLU; // isncs
3183031896 break;
3183131897 }
31832- case 2612LLU: // copy-back deleter (isncs to initfrom)
31898+ case 2617LLU: // copy-back deleter (isncs to initfrom)
3183331899 {
3183431900 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (isncs to initfrom)\n");
3183531901 // copy mutable arguments back from call to isncs
31836- label = 2607LLU; // continue to roll stack
31902+ label = 2612LLU; // continue to roll stack
3183731903 break;
3183831904 }
31839- case 2613LLU: // return from isncs to initfrom
31905+ case 2618LLU: // return from isncs to initfrom
3184031906 {
3184131907 // copy mutable arguments back from call to isncs
3184231908 // copy back results provided by call to isncs
@@ -31843,7 +31909,7 @@
3184331909 stack[base + 10] = stack[base + 19LLU];
3184431910 if(!stack[base + 10]/*isequal*/)
3184531911 {
31846- label = 2614LLU; // jump to alternative
31912+ label = 2619LLU; // jump to alternative
3184731913 break;
3184831914 }
3184931915
@@ -31850,9 +31916,9 @@
3185031916 // consequent
3185131917 printf("%s", "\n ");
3185231918 // call emitvaridx from initfrom
31853- stack[base + 16LLU] = 2616LLU/*throw to this address*/;
31919+ stack[base + 16LLU] = 2621LLU/*throw to this address*/;
3185431920 stack[base + 17LLU] = base;
31855- stack[base + 18LLU] = 2617LLU;
31921+ stack[base + 18LLU] = 2622LLU;
3185631922 // arguments for call to emitvaridx
3185731923 stack[base + 19LLU] = stack[base + 3]/*dstindex*/;
3185831924 // set stack-base & callee-address
@@ -31860,21 +31926,21 @@
3186031926 label = 691LLU; // emitvaridx
3186131927 break;
3186231928 }
31863- case 2616LLU: // copy-back deleter (emitvaridx to initfrom)
31929+ case 2621LLU: // copy-back deleter (emitvaridx to initfrom)
3186431930 {
3186531931 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3186631932 // copy mutable arguments back from call to emitvaridx
31867- label = 2607LLU; // continue to roll stack
31933+ label = 2612LLU; // continue to roll stack
3186831934 break;
3186931935 }
31870- case 2617LLU: // return from emitvaridx to initfrom
31936+ case 2622LLU: // return from emitvaridx to initfrom
3187131937 {
3187231938 // copy mutable arguments back from call to emitvaridx
3187331939 printf("%s", " = ");
3187431940 // call printnr from initfrom
31875- stack[base + 16LLU] = 2618LLU/*throw to this address*/;
31941+ stack[base + 16LLU] = 2623LLU/*throw to this address*/;
3187631942 stack[base + 17LLU] = base;
31877- stack[base + 18LLU] = 2619LLU;
31943+ stack[base + 18LLU] = 2624LLU;
3187831944 // arguments for call to printnr
3187931945 stack[base + 19LLU] = stack[base + 13]/*content*/;
3188031946 // set stack-base & callee-address
@@ -31882,21 +31948,21 @@
3188231948 label = 18446744073709551590LLU; // printnr
3188331949 break;
3188431950 }
31885- case 2618LLU: // copy-back deleter (printnr to initfrom)
31951+ case 2623LLU: // copy-back deleter (printnr to initfrom)
3188631952 {
3188731953 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
3188831954 // copy mutable arguments back from call to printnr
31889- label = 2607LLU; // continue to roll stack
31955+ label = 2612LLU; // continue to roll stack
3189031956 break;
3189131957 }
31892- case 2619LLU: // return from printnr to initfrom
31958+ case 2624LLU: // return from printnr to initfrom
3189331959 {
3189431960 // copy mutable arguments back from call to printnr
3189531961 printf("%s", ";");
31896- label = 2615LLU; // consequent complete
31962+ label = 2620LLU; // consequent complete
3189731963 break;
3189831964 }
31899- case 2614LLU: // alternative
31965+ case 2619LLU: // alternative
3190031966 {
3190131967 fprintf(stderr, "%s", "expected number/character/string or identifier (u64 variable) in ");
3190231968 fprintf(stderr, "%s", "initializing type ");
@@ -31903,7 +31969,7 @@
3190331969 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3190431970 if(!newstack)
3190531971 {
31906- label = 2607LLU; // throw: begin to unroll stack
31972+ label = 2612LLU; // throw: begin to unroll stack
3190731973 break;
3190831974 }
3190931975
@@ -31910,9 +31976,9 @@
3191031976 newstack[10LLU] = 9876543210LLU; // overflow-marker
3191131977 // call reporttype from initfrom
3191231978 newstack[0] = (uint64_t)stack; // backup stack location
31913- newstack[1] = 2620LLU;
31979+ newstack[1] = 2625LLU;
3191431980 newstack[2] = base;
31915- newstack[3] = 2621LLU;
31981+ newstack[3] = 2626LLU;
3191631982 // arguments for call to reporttype
3191731983 newstack[4LLU] = stack[base + 1]/*dsttype*/;
3191831984 stack = newstack;
@@ -31921,7 +31987,7 @@
3192131987 label = 316LLU; // reporttype
3192231988 break;
3192331989 }
31924- case 2620LLU: // copy-back deleter (reporttype to initfrom)
31990+ case 2625LLU: // copy-back deleter (reporttype to initfrom)
3192531991 {
3192631992 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3192731993 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -31933,10 +31999,10 @@
3193331999 }
3193432000 Free(10LLU + 1, sizeof(uint64_t), stack);
3193532001 stack = oldstack;
31936- label = 2607LLU; // continue to unroll stack
32002+ label = 2612LLU; // continue to unroll stack
3193732003 break;
3193832004 }
31939- case 2621LLU: // return from reporttype to initfrom
32005+ case 2626LLU: // return from reporttype to initfrom
3194032006 {
3194132007 uint64_t *oldstack = (uint64_t *)stack[0];
3194232008 // copy mutable arguments back from call to reporttype
@@ -31949,9 +32015,9 @@
3194932015 stack = oldstack;
3195032016 fprintf(stderr, "%s", " with ");
3195132017 // call reporttok from initfrom
31952- stack[base + 16LLU] = 2622LLU/*throw to this address*/;
32018+ stack[base + 16LLU] = 2627LLU/*throw to this address*/;
3195332019 stack[base + 17LLU] = base;
31954- stack[base + 18LLU] = 2623LLU;
32020+ stack[base + 18LLU] = 2628LLU;
3195532021 // arguments for call to reporttok
3195632022 stack[base + 19LLU] = stack[base + 12]/*variant*/;
3195732023 stack[base + 20LLU] = stack[base + 13]/*content*/;
@@ -31960,33 +32026,33 @@
3196032026 label = 18446744073709551582LLU; // reporttok
3196132027 break;
3196232028 }
31963- case 2622LLU: // copy-back deleter (reporttok to initfrom)
32029+ case 2627LLU: // copy-back deleter (reporttok to initfrom)
3196432030 {
3196532031 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
3196632032 // copy mutable arguments back from call to reporttok
31967- label = 2607LLU; // continue to roll stack
32033+ label = 2612LLU; // continue to roll stack
3196832034 break;
3196932035 }
31970- case 2623LLU: // return from reporttok to initfrom
32036+ case 2628LLU: // return from reporttok to initfrom
3197132037 {
3197232038 // copy mutable arguments back from call to reporttok
3197332039 fprintf(stderr, "%s", "\n");
3197432040 exit(-1);
31975- label = 2615LLU; // alternative complete
32041+ label = 2620LLU; // alternative complete
3197632042 break;
3197732043 }
31978- case 2615LLU: // completed if-then-else
32044+ case 2620LLU: // completed if-then-else
3197932045 {
31980- label = 2611LLU; // consequent complete
32046+ label = 2616LLU; // consequent complete
3198132047 break;
3198232048 }
31983- case 2610LLU: // alternative
32049+ case 2615LLU: // alternative
3198432050 {
3198532051 fprintf(stderr, "%s", "in function ");
3198632052 // call reportid from initfrom
31987- stack[base + 16LLU] = 2624LLU/*throw to this address*/;
32053+ stack[base + 16LLU] = 2629LLU/*throw to this address*/;
3198832054 stack[base + 17LLU] = base;
31989- stack[base + 18LLU] = 2625LLU;
32055+ stack[base + 18LLU] = 2630LLU;
3199032056 // arguments for call to reportid
3199132057 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
3199232058 // set stack-base & callee-address
@@ -31994,14 +32060,14 @@
3199432060 label = 18446744073709551586LLU; // reportid
3199532061 break;
3199632062 }
31997- case 2624LLU: // copy-back deleter (reportid to initfrom)
32063+ case 2629LLU: // copy-back deleter (reportid to initfrom)
3199832064 {
3199932065 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3200032066 // copy mutable arguments back from call to reportid
32001- label = 2607LLU; // continue to roll stack
32067+ label = 2612LLU; // continue to roll stack
3200232068 break;
3200332069 }
32004- case 2625LLU: // return from reportid to initfrom
32070+ case 2630LLU: // return from reportid to initfrom
3200532071 {
3200632072 // copy mutable arguments back from call to reportid
3200732073 fprintf(stderr, "%s", ": can't initialize type ");
@@ -32008,7 +32074,7 @@
3200832074 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3200932075 if(!newstack)
3201032076 {
32011- label = 2607LLU; // throw: begin to unroll stack
32077+ label = 2612LLU; // throw: begin to unroll stack
3201232078 break;
3201332079 }
3201432080
@@ -32015,9 +32081,9 @@
3201532081 newstack[10LLU] = 9876543210LLU; // overflow-marker
3201632082 // call reporttype from initfrom
3201732083 newstack[0] = (uint64_t)stack; // backup stack location
32018- newstack[1] = 2626LLU;
32084+ newstack[1] = 2631LLU;
3201932085 newstack[2] = base;
32020- newstack[3] = 2627LLU;
32086+ newstack[3] = 2632LLU;
3202132087 // arguments for call to reporttype
3202232088 newstack[4LLU] = stack[base + 1]/*dsttype*/;
3202332089 stack = newstack;
@@ -32026,7 +32092,7 @@
3202632092 label = 316LLU; // reporttype
3202732093 break;
3202832094 }
32029- case 2626LLU: // copy-back deleter (reporttype to initfrom)
32095+ case 2631LLU: // copy-back deleter (reporttype to initfrom)
3203032096 {
3203132097 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3203232098 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -32038,10 +32104,10 @@
3203832104 }
3203932105 Free(10LLU + 1, sizeof(uint64_t), stack);
3204032106 stack = oldstack;
32041- label = 2607LLU; // continue to unroll stack
32107+ label = 2612LLU; // continue to unroll stack
3204232108 break;
3204332109 }
32044- case 2627LLU: // return from reporttype to initfrom
32110+ case 2632LLU: // return from reporttype to initfrom
3204532111 {
3204632112 uint64_t *oldstack = (uint64_t *)stack[0];
3204732113 // copy mutable arguments back from call to reporttype
@@ -32054,9 +32120,9 @@
3205432120 stack = oldstack;
3205532121 fprintf(stderr, "%s", " with literal ");
3205632122 // call reporttok from initfrom
32057- stack[base + 16LLU] = 2628LLU/*throw to this address*/;
32123+ stack[base + 16LLU] = 2633LLU/*throw to this address*/;
3205832124 stack[base + 17LLU] = base;
32059- stack[base + 18LLU] = 2629LLU;
32125+ stack[base + 18LLU] = 2634LLU;
3206032126 // arguments for call to reporttok
3206132127 stack[base + 19LLU] = stack[base + 12]/*variant*/;
3206232128 stack[base + 20LLU] = stack[base + 13]/*content*/;
@@ -32065,38 +32131,38 @@
3206532131 label = 18446744073709551582LLU; // reporttok
3206632132 break;
3206732133 }
32068- case 2628LLU: // copy-back deleter (reporttok to initfrom)
32134+ case 2633LLU: // copy-back deleter (reporttok to initfrom)
3206932135 {
3207032136 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
3207132137 // copy mutable arguments back from call to reporttok
32072- label = 2607LLU; // continue to roll stack
32138+ label = 2612LLU; // continue to roll stack
3207332139 break;
3207432140 }
32075- case 2629LLU: // return from reporttok to initfrom
32141+ case 2634LLU: // return from reporttok to initfrom
3207632142 {
3207732143 // copy mutable arguments back from call to reporttok
3207832144 fprintf(stderr, "%s", " - use constructor instead\n");
3207932145 exit(-1);
32080- label = 2611LLU; // alternative complete
32146+ label = 2616LLU; // alternative complete
3208132147 break;
3208232148 }
32083- case 2611LLU: // completed if-then-else
32149+ case 2616LLU: // completed if-then-else
3208432150 {
3208532151 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32086- label = 2605LLU; // case complete
32152+ label = 2610LLU; // case complete
3208732153 break;
3208832154 }
32089- case 2607LLU: // copy-back deleter (switch)
32155+ case 2612LLU: // copy-back deleter (switch)
3209032156 {
3209132157 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32092- label = 2259LLU; // continue to unroll stack
32158+ label = 2295LLU; // continue to unroll stack
3209332159 break;
3209432160 }
32095- case 2606LLU: // try next case
32161+ case 2611LLU: // try next case
3209632162 {
3209732163 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*dsttype*/))[0])
3209832164 {
32099- label = 2630LLU; // jump to alternative
32165+ label = 2635LLU; // jump to alternative
3210032166 break;
3210132167 }
3210232168
@@ -32104,9 +32170,9 @@
3210432170
3210532171 // case
3210632172 // call issimple from initfrom
32107- stack[base + 16LLU] = 2632LLU/*throw to this address*/;
32173+ stack[base + 16LLU] = 2637LLU/*throw to this address*/;
3210832174 stack[base + 17LLU] = base;
32109- stack[base + 18LLU] = 2633LLU;
32175+ stack[base + 18LLU] = 2638LLU;
3211032176 // arguments for call to issimple
3211132177 stack[base + 20LLU] = stack[base + 12]/*variant*/;
3211232178 stack[base + 21LLU] = stack[base + 13]/*content*/;
@@ -32116,14 +32182,14 @@
3211632182 label = 158LLU; // issimple
3211732183 break;
3211832184 }
32119- case 2632LLU: // copy-back deleter (issimple to initfrom)
32185+ case 2637LLU: // copy-back deleter (issimple to initfrom)
3212032186 {
3212132187 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
3212232188 // copy mutable arguments back from call to issimple
32123- label = 2631LLU; // continue to roll stack
32189+ label = 2636LLU; // continue to roll stack
3212432190 break;
3212532191 }
32126- case 2633LLU: // return from issimple to initfrom
32192+ case 2638LLU: // return from issimple to initfrom
3212732193 {
3212832194 // copy mutable arguments back from call to issimple
3212932195 // copy back results provided by call to issimple
@@ -32130,15 +32196,15 @@
3213032196 stack[base + 10] = stack[base + 19LLU];
3213132197 if(!stack[base + 10]/*isequal*/)
3213232198 {
32133- label = 2634LLU; // jump to alternative
32199+ label = 2639LLU; // jump to alternative
3213432200 break;
3213532201 }
3213632202
3213732203 // consequent
3213832204 // call matchsym from initfrom
32139- stack[base + 16LLU] = 2636LLU/*throw to this address*/;
32205+ stack[base + 16LLU] = 2641LLU/*throw to this address*/;
3214032206 stack[base + 17LLU] = base;
32141- stack[base + 18LLU] = 2637LLU;
32207+ stack[base + 18LLU] = 2642LLU;
3214232208 // arguments for call to matchsym
3214332209 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
3214432210 stack[base + 20LLU] = 93LLU;
@@ -32148,23 +32214,23 @@
3214832214 label = 212LLU; // matchsym
3214932215 break;
3215032216 }
32151- case 2636LLU: // copy-back deleter (matchsym to initfrom)
32217+ case 2641LLU: // copy-back deleter (matchsym to initfrom)
3215232218 {
3215332219 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
3215432220 // copy mutable arguments back from call to matchsym
3215532221 stack[base + 7]/*lookahead*/ = stack[base + 21LLU];
32156- label = 2631LLU; // continue to roll stack
32222+ label = 2636LLU; // continue to roll stack
3215732223 break;
3215832224 }
32159- case 2637LLU: // return from matchsym to initfrom
32225+ case 2642LLU: // return from matchsym to initfrom
3216032226 {
3216132227 // copy mutable arguments back from call to matchsym
3216232228 stack[base + 7]/*lookahead*/ = stack[base + 21LLU];
3216332229 printf("%s", "\n ");
3216432230 // call emitvaridx from initfrom
32165- stack[base + 16LLU] = 2638LLU/*throw to this address*/;
32231+ stack[base + 16LLU] = 2643LLU/*throw to this address*/;
3216632232 stack[base + 17LLU] = base;
32167- stack[base + 18LLU] = 2639LLU;
32233+ stack[base + 18LLU] = 2644LLU;
3216832234 // arguments for call to emitvaridx
3216932235 stack[base + 19LLU] = stack[base + 3]/*dstindex*/;
3217032236 // set stack-base & callee-address
@@ -32172,27 +32238,27 @@
3217232238 label = 691LLU; // emitvaridx
3217332239 break;
3217432240 }
32175- case 2638LLU: // copy-back deleter (emitvaridx to initfrom)
32241+ case 2643LLU: // copy-back deleter (emitvaridx to initfrom)
3217632242 {
3217732243 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
3217832244 // copy mutable arguments back from call to emitvaridx
32179- label = 2631LLU; // continue to roll stack
32245+ label = 2636LLU; // continue to roll stack
3218032246 break;
3218132247 }
32182- case 2639LLU: // return from emitvaridx to initfrom
32248+ case 2644LLU: // return from emitvaridx to initfrom
3218332249 {
3218432250 // copy mutable arguments back from call to emitvaridx
3218532251 printf("%s", " = 0;");
32186- label = 2635LLU; // consequent complete
32252+ label = 2640LLU; // consequent complete
3218732253 break;
3218832254 }
32189- case 2634LLU: // alternative
32255+ case 2639LLU: // alternative
3219032256 {
3219132257 fprintf(stderr, "%s", "in function ");
3219232258 // call reportid from initfrom
32193- stack[base + 16LLU] = 2640LLU/*throw to this address*/;
32259+ stack[base + 16LLU] = 2645LLU/*throw to this address*/;
3219432260 stack[base + 17LLU] = base;
32195- stack[base + 18LLU] = 2641LLU;
32261+ stack[base + 18LLU] = 2646LLU;
3219632262 // arguments for call to reportid
3219732263 stack[base + 19LLU] = stack[base + 0]/*fnid*/;
3219832264 // set stack-base & callee-address
@@ -32200,14 +32266,14 @@
3220032266 label = 18446744073709551586LLU; // reportid
3220132267 break;
3220232268 }
32203- case 2640LLU: // copy-back deleter (reportid to initfrom)
32269+ case 2645LLU: // copy-back deleter (reportid to initfrom)
3220432270 {
3220532271 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
3220632272 // copy mutable arguments back from call to reportid
32207- label = 2631LLU; // continue to roll stack
32273+ label = 2636LLU; // continue to roll stack
3220832274 break;
3220932275 }
32210- case 2641LLU: // return from reportid to initfrom
32276+ case 2646LLU: // return from reportid to initfrom
3221132277 {
3221232278 // copy mutable arguments back from call to reportid
3221332279 fprintf(stderr, "%s", ": can't initialize type ");
@@ -32214,7 +32280,7 @@
3221432280 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3221532281 if(!newstack)
3221632282 {
32217- label = 2631LLU; // throw: begin to unroll stack
32283+ label = 2636LLU; // throw: begin to unroll stack
3221832284 break;
3221932285 }
3222032286
@@ -32221,9 +32287,9 @@
3222132287 newstack[10LLU] = 9876543210LLU; // overflow-marker
3222232288 // call reporttype from initfrom
3222332289 newstack[0] = (uint64_t)stack; // backup stack location
32224- newstack[1] = 2642LLU;
32290+ newstack[1] = 2647LLU;
3222532291 newstack[2] = base;
32226- newstack[3] = 2643LLU;
32292+ newstack[3] = 2648LLU;
3222732293 // arguments for call to reporttype
3222832294 newstack[4LLU] = stack[base + 1]/*dsttype*/;
3222932295 stack = newstack;
@@ -32232,7 +32298,7 @@
3223232298 label = 316LLU; // reporttype
3223332299 break;
3223432300 }
32235- case 2642LLU: // copy-back deleter (reporttype to initfrom)
32301+ case 2647LLU: // copy-back deleter (reporttype to initfrom)
3223632302 {
3223732303 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
3223832304 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -32244,10 +32310,10 @@
3224432310 }
3224532311 Free(10LLU + 1, sizeof(uint64_t), stack);
3224632312 stack = oldstack;
32247- label = 2631LLU; // continue to unroll stack
32313+ label = 2636LLU; // continue to unroll stack
3224832314 break;
3224932315 }
32250- case 2643LLU: // return from reporttype to initfrom
32316+ case 2648LLU: // return from reporttype to initfrom
3225132317 {
3225232318 uint64_t *oldstack = (uint64_t *)stack[0];
3225332319 // copy mutable arguments back from call to reporttype
@@ -32260,9 +32326,9 @@
3226032326 stack = oldstack;
3226132327 fprintf(stderr, "%s", " with ");
3226232328 // call reporttok from initfrom
32263- stack[base + 16LLU] = 2644LLU/*throw to this address*/;
32329+ stack[base + 16LLU] = 2649LLU/*throw to this address*/;
3226432330 stack[base + 17LLU] = base;
32265- stack[base + 18LLU] = 2645LLU;
32331+ stack[base + 18LLU] = 2650LLU;
3226632332 // arguments for call to reporttok
3226732333 stack[base + 19LLU] = stack[base + 12]/*variant*/;
3226832334 stack[base + 20LLU] = stack[base + 13]/*content*/;
@@ -32271,49 +32337,49 @@
3227132337 label = 18446744073709551582LLU; // reporttok
3227232338 break;
3227332339 }
32274- case 2644LLU: // copy-back deleter (reporttok to initfrom)
32340+ case 2649LLU: // copy-back deleter (reporttok to initfrom)
3227532341 {
3227632342 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
3227732343 // copy mutable arguments back from call to reporttok
32278- label = 2631LLU; // continue to roll stack
32344+ label = 2636LLU; // continue to roll stack
3227932345 break;
3228032346 }
32281- case 2645LLU: // return from reporttok to initfrom
32347+ case 2650LLU: // return from reporttok to initfrom
3228232348 {
3228332349 // copy mutable arguments back from call to reporttok
3228432350 fprintf(stderr, "%s", "\n");
3228532351 exit(-1);
32286- label = 2635LLU; // alternative complete
32352+ label = 2640LLU; // alternative complete
3228732353 break;
3228832354 }
32289- case 2635LLU: // completed if-then-else
32355+ case 2640LLU: // completed if-then-else
3229032356 {
3229132357 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32292- label = 2605LLU; // case complete
32358+ label = 2610LLU; // case complete
3229332359 break;
3229432360 }
32295- case 2631LLU: // copy-back deleter (switch)
32361+ case 2636LLU: // copy-back deleter (switch)
3229632362 {
3229732363 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32298- label = 2259LLU; // continue to unroll stack
32364+ label = 2295LLU; // continue to unroll stack
3229932365 break;
3230032366 }
32301- case 2630LLU: // try next case
32367+ case 2635LLU: // try next case
3230232368 {
3230332369 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3230432370 exit(-1);
3230532371 }
32306- case 2605LLU: // completed switch
32372+ case 2610LLU: // completed switch
3230732373 {
32308- label = 2309LLU; // alternative complete
32374+ label = 2314LLU; // alternative complete
3230932375 break;
3231032376 }
32311- case 2309LLU: // completed if-then-else
32377+ case 2314LLU: // completed if-then-else
3231232378 {
3231332379 // call linkthrow from initfrom
32314- stack[base + 15LLU] = 2646LLU/*throw to this address*/;
32380+ stack[base + 15LLU] = 2651LLU/*throw to this address*/;
3231532381 stack[base + 16LLU] = base;
32316- stack[base + 17LLU] = 2647LLU;
32382+ stack[base + 17LLU] = 2652LLU;
3231732383 // arguments for call to linkthrow
3231832384 stack[base + 18LLU] = stack[base + 6]/*scope*/;
3231932385 stack[base + 19LLU] = stack[base + 11]/*labelfail*/;
@@ -32322,15 +32388,15 @@
3232232388 label = 1554LLU; // linkthrow
3232332389 break;
3232432390 }
32325- case 2646LLU: // copy-back deleter (linkthrow to initfrom)
32391+ case 2651LLU: // copy-back deleter (linkthrow to initfrom)
3232632392 {
3232732393 fprintf(stderr, "in function initfrom: unrolling stack, copy-back (linkthrow to initfrom)\n");
3232832394 // copy mutable arguments back from call to linkthrow
3232932395 stack[base + 6]/*scope*/ = stack[base + 18LLU];
32330- label = 2259LLU; // continue to roll stack
32396+ label = 2295LLU; // continue to roll stack
3233132397 break;
3233232398 }
32333- case 2647LLU: // return from linkthrow to initfrom
32399+ case 2652LLU: // return from linkthrow to initfrom
3233432400 {
3233532401 // copy mutable arguments back from call to linkthrow
3233632402 stack[base + 6]/*scope*/ = stack[base + 18LLU];
@@ -32339,7 +32405,7 @@
3233932405 base = stack[base - 2];
3234032406 break;
3234132407 }
32342- case 2649LLU: // function PROCRETURN failed
32408+ case 2654LLU: // function PROCRETURN failed
3234332409 {
3234432410 fprintf(stderr, "function PROCRETURN failed\n");
3234532411 label = stack[base - 3];
@@ -32346,7 +32412,7 @@
3234632412 base = stack[base - 2];
3234732413 break;
3234832414 }
32349- case 2648LLU: // PROCRETURN
32415+ case 2653LLU: // PROCRETURN
3235032416 {
3235132417 //#define arg0 0
3235232418 //#define arg1 1
@@ -32366,29 +32432,29 @@
3236632432 //#define arg15 15
3236732433 //#define arg16 16
3236832434 //#define arg17 17
32369- label = 2651LLU; // skip deleter
32435+ label = 2656LLU; // skip deleter
3237032436 break;
3237132437 }
32372- case 2650LLU: // deleter
32438+ case 2655LLU: // deleter
3237332439 {
3237432440 // throw from PROCRETURN
3237532441 if(!stack[base + 18])
3237632442 {
3237732443 fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
32378- label = 2649LLU; // skip, variable already deleted/unscoped
32444+ label = 2654LLU; // skip, variable already deleted/unscoped
3237932445 break;
3238032446 }
3238132447 fprintf(stderr, "in function PROCRETURN: unrolling stack, variable u64 isequal\n");
32382- label = 2649LLU; // continue unrolling stack, delete next variable
32448+ label = 2654LLU; // continue unrolling stack, delete next variable
3238332449 break;
3238432450 }
32385- case 2651LLU: // skipped deleter
32451+ case 2656LLU: // skipped deleter
3238632452 {
3238732453 stack[base + 18] = 0;
3238832454 // call issimple from PROCRETURN
32389- stack[base + 19LLU] = 2652LLU/*throw to this address*/;
32455+ stack[base + 19LLU] = 2657LLU/*throw to this address*/;
3239032456 stack[base + 20LLU] = base;
32391- stack[base + 21LLU] = 2653LLU;
32457+ stack[base + 21LLU] = 2658LLU;
3239232458 // arguments for call to issimple
3239332459 stack[base + 23LLU] = stack[base + 15]/*variant*/;
3239432460 stack[base + 24LLU] = stack[base + 16]/*content*/;
@@ -32398,14 +32464,14 @@
3239832464 label = 158LLU; // issimple
3239932465 break;
3240032466 }
32401- case 2652LLU: // copy-back deleter (issimple to PROCRETURN)
32467+ case 2657LLU: // copy-back deleter (issimple to PROCRETURN)
3240232468 {
3240332469 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (issimple to PROCRETURN)\n");
3240432470 // copy mutable arguments back from call to issimple
32405- label = 2650LLU; // continue to roll stack
32471+ label = 2655LLU; // continue to roll stack
3240632472 break;
3240732473 }
32408- case 2653LLU: // return from issimple to PROCRETURN
32474+ case 2658LLU: // return from issimple to PROCRETURN
3240932475 {
3241032476 // copy mutable arguments back from call to issimple
3241132477 // copy back results provided by call to issimple
@@ -32412,20 +32478,20 @@
3241232478 stack[base + 18] = stack[base + 22LLU];
3241332479 if(!stack[base + 18]/*isequal*/)
3241432480 {
32415- label = 2654LLU; // jump to alternative
32481+ label = 2659LLU; // jump to alternative
3241632482 break;
3241732483 }
3241832484
3241932485 // consequent
3242032486 flippedassign(stack[base + 4]/*blkresults*/, &stack[base + 19]);
32421- label = 2656LLU; // start to repeat
32487+ label = 2661LLU; // start to repeat
3242232488 break;
3242332489 }
32424- case 2656LLU: // repeat from here
32490+ case 2661LLU: // repeat from here
3242532491 {
3242632492 if(!stack[base + 19])
3242732493 {
32428- label = 2657LLU; // break loop
32494+ label = 2662LLU; // break loop
3242932495 break;
3243032496 }
3243132497
@@ -32435,7 +32501,7 @@
3243532501 stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->next);
3243632502 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 20]/*typeidx*/))[0])
3243732503 {
32438- label = 2660LLU; // jump to alternative
32504+ label = 2665LLU; // jump to alternative
3243932505 break;
3244032506 }
3244132507
@@ -32444,9 +32510,9 @@
3244432510
3244532511 // case
3244632512 // call initfrom from PROCRETURN
32447- stack[base + 24LLU] = 2662LLU/*throw to this address*/;
32513+ stack[base + 24LLU] = 2667LLU/*throw to this address*/;
3244832514 stack[base + 25LLU] = base;
32449- stack[base + 26LLU] = 2663LLU;
32515+ stack[base + 26LLU] = 2668LLU;
3245032516 // arguments for call to initfrom
3245132517 stack[base + 27LLU] = stack[base + 9]/*fnid*/;
3245232518 stack[base + 28LLU] = stack[base + 22]/*type*/;
@@ -32460,10 +32526,10 @@
3246032526 stack[base + 36LLU] = stack[base + 8]/*fncanthrow*/;
3246132527 // set stack-base & callee-address
3246232528 base += 27LLU;
32463- label = 2253LLU; // initfrom
32529+ label = 2293LLU; // initfrom
3246432530 break;
3246532531 }
32466- case 2662LLU: // copy-back deleter (initfrom to PROCRETURN)
32532+ case 2667LLU: // copy-back deleter (initfrom to PROCRETURN)
3246732533 {
3246832534 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (initfrom to PROCRETURN)\n");
3246932535 // copy mutable arguments back from call to initfrom
@@ -32470,10 +32536,10 @@
3247032536 stack[base + 17]/*label*/ = stack[base + 35LLU];
3247132537 stack[base + 14]/*lookahead*/ = stack[base + 34LLU];
3247232538 stack[base + 3]/*scope*/ = stack[base + 33LLU];
32473- label = 2661LLU; // continue to roll stack
32539+ label = 2666LLU; // continue to roll stack
3247432540 break;
3247532541 }
32476- case 2663LLU: // return from initfrom to PROCRETURN
32542+ case 2668LLU: // return from initfrom to PROCRETURN
3247732543 {
3247832544 // copy mutable arguments back from call to initfrom
3247932545 stack[base + 17]/*label*/ = stack[base + 35LLU];
@@ -32481,15 +32547,15 @@
3248132547 stack[base + 3]/*scope*/ = stack[base + 33LLU];
3248232548 if(!stack[base + 19]/*blkresults*/)
3248332549 {
32484- label = 2664LLU; // jump to alternative
32550+ label = 2669LLU; // jump to alternative
3248532551 break;
3248632552 }
3248732553
3248832554 // consequent
3248932555 // call matchsym from PROCRETURN
32490- stack[base + 24LLU] = 2666LLU/*throw to this address*/;
32556+ stack[base + 24LLU] = 2671LLU/*throw to this address*/;
3249132557 stack[base + 25LLU] = base;
32492- stack[base + 26LLU] = 2667LLU;
32558+ stack[base + 26LLU] = 2672LLU;
3249332559 // arguments for call to matchsym
3249432560 stack[base + 27LLU] = stack[base + 9]/*fnid*/;
3249532561 stack[base + 28LLU] = 44LLU;
@@ -32499,63 +32565,63 @@
3249932565 label = 212LLU; // matchsym
3250032566 break;
3250132567 }
32502- case 2666LLU: // copy-back deleter (matchsym to PROCRETURN)
32568+ case 2671LLU: // copy-back deleter (matchsym to PROCRETURN)
3250332569 {
3250432570 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
3250532571 // copy mutable arguments back from call to matchsym
3250632572 stack[base + 14]/*lookahead*/ = stack[base + 29LLU];
32507- label = 2661LLU; // continue to roll stack
32573+ label = 2666LLU; // continue to roll stack
3250832574 break;
3250932575 }
32510- case 2667LLU: // return from matchsym to PROCRETURN
32576+ case 2672LLU: // return from matchsym to PROCRETURN
3251132577 {
3251232578 // copy mutable arguments back from call to matchsym
3251332579 stack[base + 14]/*lookahead*/ = stack[base + 29LLU];
32514- label = 2665LLU; // consequent complete
32580+ label = 2670LLU; // consequent complete
3251532581 break;
3251632582 }
32517- case 2664LLU: // alternative
32583+ case 2669LLU: // alternative
3251832584 {
32519- label = 2665LLU; // alternative complete
32585+ label = 2670LLU; // alternative complete
3252032586 break;
3252132587 }
32522- case 2665LLU: // completed if-then-else
32588+ case 2670LLU: // completed if-then-else
3252332589 {
3252432590 ((uint64_t **)(stack[base + 20]))[1][1] = stack[base + 23];
3252532591 ((uint64_t **)(stack[base + 20]))[1][0] = stack[base + 22];
32526- label = 2659LLU; // case complete
32592+ label = 2664LLU; // case complete
3252732593 break;
3252832594 }
32529- case 2661LLU: // copy-back deleter (switch)
32595+ case 2666LLU: // copy-back deleter (switch)
3253032596 {
3253132597 ((uint64_t **)(stack[base + 20]))[1][1] = stack[base + 23];
3253232598 ((uint64_t **)(stack[base + 20]))[1][0] = stack[base + 22];
32533- label = 2658LLU; // continue to unroll stack
32599+ label = 2663LLU; // continue to unroll stack
3253432600 break;
3253532601 }
32536- case 2660LLU: // try next case
32602+ case 2665LLU: // try next case
3253732603 {
3253832604 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3253932605 exit(-1);
3254032606 }
32541- case 2659LLU: // completed switch
32607+ case 2664LLU: // completed switch
3254232608 {
3254332609 ((struct listnode *)(stack[base + 21]/*previous*/))->data = stack[base + 20];
32544- label = 2656LLU; // repeat
32610+ label = 2661LLU; // repeat
3254532611 break;
3254632612 }
32547- case 2658LLU: // copy-back deleter for while next
32613+ case 2663LLU: // copy-back deleter for while next
3254832614 {
3254932615 ((struct listnode *)(stack[base + 21]/*previous*/))->data = stack[base + 20];
32550- label = 2650LLU; // continue to unroll stack
32616+ label = 2655LLU; // continue to unroll stack
3255132617 break;
3255232618 }
32553- case 2657LLU: // loop finished
32619+ case 2662LLU: // loop finished
3255432620 {
3255532621 // call matchsym from PROCRETURN
32556- stack[base + 22LLU] = 2668LLU/*throw to this address*/;
32622+ stack[base + 22LLU] = 2673LLU/*throw to this address*/;
3255732623 stack[base + 23LLU] = base;
32558- stack[base + 24LLU] = 2669LLU;
32624+ stack[base + 24LLU] = 2674LLU;
3255932625 // arguments for call to matchsym
3256032626 stack[base + 25LLU] = stack[base + 9]/*fnid*/;
3256132627 stack[base + 26LLU] = 41LLU;
@@ -32565,45 +32631,45 @@
3256532631 label = 212LLU; // matchsym
3256632632 break;
3256732633 }
32568- case 2668LLU: // copy-back deleter (matchsym to PROCRETURN)
32634+ case 2673LLU: // copy-back deleter (matchsym to PROCRETURN)
3256932635 {
3257032636 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
3257132637 // copy mutable arguments back from call to matchsym
3257232638 stack[base + 14]/*lookahead*/ = stack[base + 27LLU];
32573- label = 2650LLU; // continue to roll stack
32639+ label = 2655LLU; // continue to roll stack
3257432640 break;
3257532641 }
32576- case 2669LLU: // return from matchsym to PROCRETURN
32642+ case 2674LLU: // return from matchsym to PROCRETURN
3257732643 {
3257832644 // copy mutable arguments back from call to matchsym
3257932645 stack[base + 14]/*lookahead*/ = stack[base + 27LLU];
32580- label = 2655LLU; // consequent complete
32646+ label = 2660LLU; // consequent complete
3258132647 break;
3258232648 }
32583- case 2654LLU: // alternative
32649+ case 2659LLU: // alternative
3258432650 {
32585- label = 2671LLU; // skip deleter
32651+ label = 2676LLU; // skip deleter
3258632652 break;
3258732653 }
32588- case 2670LLU: // deleter
32654+ case 2675LLU: // deleter
3258932655 {
3259032656 // throw from PROCRETURN
3259132657 if(!stack[base + 19])
3259232658 {
3259332659 fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable [typeidx] dsttypeidx\n");
32594- label = 2650LLU; // skip, variable already deleted/unscoped
32660+ label = 2655LLU; // skip, variable already deleted/unscoped
3259532661 break;
3259632662 }
3259732663 fprintf(stderr, "in function PROCRETURN: unrolling stack, variable [typeidx] dsttypeidx\n");
3259832664 // delete list
32599- label = 2672LLU; // start to repeat
32665+ label = 2677LLU; // start to repeat
3260032666 break;
3260132667 }
32602- case 2672LLU: // repeat from here
32668+ case 2677LLU: // repeat from here
3260332669 {
3260432670 if(!stack[base + 19])
3260532671 {
32606- label = 2673LLU; // break loop
32672+ label = 2678LLU; // break loop
3260732673 break;
3260832674 }
3260932675
@@ -32614,7 +32680,7 @@
3261432680 newstack[0] = (uint64_t)stack; // backup stack location
3261532681 newstack[1] = 1234567890;
3261632682 newstack[2] = base;
32617- newstack[3] = 2674LLU;
32683+ newstack[3] = 2679LLU;
3261832684 stack = newstack;
3261932685 // set stack-base & callee-address
3262032686 base = 4/*deloffset*/;
@@ -32621,7 +32687,7 @@
3262132687 label = 379LLU; // ~typeidx
3262232688 break;
3262332689 }
32624- case 2674LLU: // return from ~typeidx to PROCRETURN
32690+ case 2679LLU: // return from ~typeidx to PROCRETURN
3262532691 {
3262632692 stack = (uint64_t *)stack[0];
3262732693 // releasing toplevel container
@@ -32632,39 +32698,39 @@
3263232698 stack[base + 19] = (uint64_t)list->next;
3263332699 Free(1, sizeof(struct listnode), list);
3263432700 }
32635- label = 2672LLU; // repeat
32701+ label = 2677LLU; // repeat
3263632702 break;
3263732703 }
32638- case 2673LLU: // loop finished
32704+ case 2678LLU: // loop finished
3263932705 {
32640- label = 2650LLU; // continue unrolling stack, delete next variable
32706+ label = 2655LLU; // continue unrolling stack, delete next variable
3264132707 break;
3264232708 }
32643- case 2671LLU: // skipped deleter
32709+ case 2676LLU: // skipped deleter
3264432710 {
3264532711 stack[base + 19] = 0;
32646- label = 2676LLU; // skip deleter
32712+ label = 2681LLU; // skip deleter
3264732713 break;
3264832714 }
32649- case 2675LLU: // deleter
32715+ case 2680LLU: // deleter
3265032716 {
3265132717 // throw from PROCRETURN
3265232718 if(!stack[base + 20])
3265332719 {
3265432720 fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable [typeidx] BLKRESULTS\n");
32655- label = 2670LLU; // skip, variable already deleted/unscoped
32721+ label = 2675LLU; // skip, variable already deleted/unscoped
3265632722 break;
3265732723 }
3265832724 fprintf(stderr, "in function PROCRETURN: unrolling stack, variable [typeidx] BLKRESULTS\n");
3265932725 // delete list
32660- label = 2677LLU; // start to repeat
32726+ label = 2682LLU; // start to repeat
3266132727 break;
3266232728 }
32663- case 2677LLU: // repeat from here
32729+ case 2682LLU: // repeat from here
3266432730 {
3266532731 if(!stack[base + 20])
3266632732 {
32667- label = 2678LLU; // break loop
32733+ label = 2683LLU; // break loop
3266832734 break;
3266932735 }
3267032736
@@ -32675,7 +32741,7 @@
3267532741 newstack[0] = (uint64_t)stack; // backup stack location
3267632742 newstack[1] = 1234567890;
3267732743 newstack[2] = base;
32678- newstack[3] = 2679LLU;
32744+ newstack[3] = 2684LLU;
3267932745 stack = newstack;
3268032746 // set stack-base & callee-address
3268132747 base = 4/*deloffset*/;
@@ -32682,7 +32748,7 @@
3268232748 label = 379LLU; // ~typeidx
3268332749 break;
3268432750 }
32685- case 2679LLU: // return from ~typeidx to PROCRETURN
32751+ case 2684LLU: // return from ~typeidx to PROCRETURN
3268632752 {
3268732753 stack = (uint64_t *)stack[0];
3268832754 // releasing toplevel container
@@ -32693,26 +32759,26 @@
3269332759 stack[base + 20] = (uint64_t)list->next;
3269432760 Free(1, sizeof(struct listnode), list);
3269532761 }
32696- label = 2677LLU; // repeat
32762+ label = 2682LLU; // repeat
3269732763 break;
3269832764 }
32699- case 2678LLU: // loop finished
32765+ case 2683LLU: // loop finished
3270032766 {
32701- label = 2670LLU; // continue unrolling stack, delete next variable
32767+ label = 2675LLU; // continue unrolling stack, delete next variable
3270232768 break;
3270332769 }
32704- case 2676LLU: // skipped deleter
32770+ case 2681LLU: // skipped deleter
3270532771 {
3270632772 stack[base + 20] = 0;
3270732773 flippedassign(stack[base + 4]/*blkresults*/, &stack[base + 21]);
32708- label = 2680LLU; // start to repeat
32774+ label = 2685LLU; // start to repeat
3270932775 break;
3271032776 }
32711- case 2680LLU: // repeat from here
32777+ case 2685LLU: // repeat from here
3271232778 {
3271332779 if(!stack[base + 21])
3271432780 {
32715- label = 2681LLU; // break loop
32781+ label = 2686LLU; // break loop
3271632782 break;
3271732783 }
3271832784
@@ -32721,9 +32787,9 @@
3272132787 stack[base + 23]/*previous*/ = stack[base + 21];
3272232788 stack[base + 21] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->next);
3272332789 // call cptypeidx from PROCRETURN
32724- stack[base + 25LLU] = 2683LLU/*throw to this address*/;
32790+ stack[base + 25LLU] = 2688LLU/*throw to this address*/;
3272532791 stack[base + 26LLU] = base;
32726- stack[base + 27LLU] = 2684LLU;
32792+ stack[base + 27LLU] = 2689LLU;
3272732793 // arguments for call to cptypeidx
3272832794 stack[base + 29LLU] = stack[base + 22]/*typeidx*/;
3272932795 // set stack-base & callee-address
@@ -32731,14 +32797,14 @@
3273132797 label = 382LLU; // cptypeidx
3273232798 break;
3273332799 }
32734- case 2683LLU: // copy-back deleter (cptypeidx to PROCRETURN)
32800+ case 2688LLU: // copy-back deleter (cptypeidx to PROCRETURN)
3273532801 {
3273632802 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (cptypeidx to PROCRETURN)\n");
3273732803 // copy mutable arguments back from call to cptypeidx
32738- label = 2682LLU; // continue to roll stack
32804+ label = 2687LLU; // continue to roll stack
3273932805 break;
3274032806 }
32741- case 2684LLU: // return from cptypeidx to PROCRETURN
32807+ case 2689LLU: // return from cptypeidx to PROCRETURN
3274232808 {
3274332809 // copy mutable arguments back from call to cptypeidx
3274432810 // copy back results provided by call to cptypeidx
@@ -32755,22 +32821,22 @@
3275532821 MOVE(&list->data, &stack[base + 24]/*copy*/);
3275632822 }
3275732823 ((struct listnode *)(stack[base + 23]/*previous*/))->data = stack[base + 22];
32758- label = 2680LLU; // repeat
32824+ label = 2685LLU; // repeat
3275932825 break;
3276032826 }
32761- case 2682LLU: // copy-back deleter for while next
32827+ case 2687LLU: // copy-back deleter for while next
3276232828 {
3276332829 ((struct listnode *)(stack[base + 23]/*previous*/))->data = stack[base + 22];
32764- label = 2675LLU; // continue to unroll stack
32830+ label = 2680LLU; // continue to unroll stack
3276532831 break;
3276632832 }
32767- case 2681LLU: // loop finished
32833+ case 2686LLU: // loop finished
3276832834 {
3276932835 list_reverse(((struct listnode **)(&stack[base + 20]/*BLKRESULTS*/)));
3277032836 // call equ from PROCRETURN
32771- stack[base + 24LLU] = 2685LLU/*throw to this address*/;
32837+ stack[base + 24LLU] = 2690LLU/*throw to this address*/;
3277232838 stack[base + 25LLU] = base;
32773- stack[base + 26LLU] = 2686LLU;
32839+ stack[base + 26LLU] = 2691LLU;
3277432840 // arguments for call to equ
3277532841 stack[base + 28LLU] = stack[base + 15]/*variant*/;
3277632842 stack[base + 29LLU] = 4LLU;
@@ -32779,14 +32845,14 @@
3277932845 label = 18446744073709551600LLU; // equ
3278032846 break;
3278132847 }
32782- case 2685LLU: // copy-back deleter (equ to PROCRETURN)
32848+ case 2690LLU: // copy-back deleter (equ to PROCRETURN)
3278332849 {
3278432850 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equ to PROCRETURN)\n");
3278532851 // copy mutable arguments back from call to equ
32786- label = 2675LLU; // continue to roll stack
32852+ label = 2680LLU; // continue to roll stack
3278732853 break;
3278832854 }
32789- case 2686LLU: // return from equ to PROCRETURN
32855+ case 2691LLU: // return from equ to PROCRETURN
3279032856 {
3279132857 // copy mutable arguments back from call to equ
3279232858 // copy back results provided by call to equ
@@ -32793,21 +32859,21 @@
3279332859 stack[base + 18] = stack[base + 27LLU];
3279432860 if(!stack[base + 18]/*isequal*/)
3279532861 {
32796- label = 2687LLU; // jump to alternative
32862+ label = 2692LLU; // jump to alternative
3279732863 break;
3279832864 }
3279932865
3280032866 // consequent
32801- label = 2688LLU; // consequent complete
32867+ label = 2693LLU; // consequent complete
3280232868 break;
3280332869 }
32804- case 2687LLU: // alternative
32870+ case 2692LLU: // alternative
3280532871 {
3280632872 fprintf(stderr, "%s", "parsing function call expected identifier but found ");
3280732873 // call reporttok from PROCRETURN
32808- stack[base + 24LLU] = 2689LLU/*throw to this address*/;
32874+ stack[base + 24LLU] = 2694LLU/*throw to this address*/;
3280932875 stack[base + 25LLU] = base;
32810- stack[base + 26LLU] = 2690LLU;
32876+ stack[base + 26LLU] = 2695LLU;
3281132877 // arguments for call to reporttok
3281232878 stack[base + 27LLU] = stack[base + 15]/*variant*/;
3281332879 stack[base + 28LLU] = stack[base + 16]/*content*/;
@@ -32816,26 +32882,26 @@
3281632882 label = 18446744073709551582LLU; // reporttok
3281732883 break;
3281832884 }
32819- case 2689LLU: // copy-back deleter (reporttok to PROCRETURN)
32885+ case 2694LLU: // copy-back deleter (reporttok to PROCRETURN)
3282032886 {
3282132887 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttok to PROCRETURN)\n");
3282232888 // copy mutable arguments back from call to reporttok
32823- label = 2675LLU; // continue to roll stack
32889+ label = 2680LLU; // continue to roll stack
3282432890 break;
3282532891 }
32826- case 2690LLU: // return from reporttok to PROCRETURN
32892+ case 2695LLU: // return from reporttok to PROCRETURN
3282732893 {
3282832894 // copy mutable arguments back from call to reporttok
3282932895 exit(-1);
32830- label = 2688LLU; // alternative complete
32896+ label = 2693LLU; // alternative complete
3283132897 break;
3283232898 }
32833- case 2688LLU: // completed if-then-else
32899+ case 2693LLU: // completed if-then-else
3283432900 {
3283532901 // call FindFn from PROCRETURN
32836- stack[base + 25LLU] = 2691LLU/*throw to this address*/;
32902+ stack[base + 25LLU] = 2696LLU/*throw to this address*/;
3283732903 stack[base + 26LLU] = base;
32838- stack[base + 27LLU] = 2692LLU;
32904+ stack[base + 27LLU] = 2697LLU;
3283932905 // arguments for call to FindFn
3284032906 stack[base + 29LLU] = stack[base + 9]/*fnid*/;
3284132907 stack[base + 30LLU] = stack[base + 0]/*fndefs*/;
@@ -32845,14 +32911,14 @@
3284532911 label = 1411LLU; // FindFn
3284632912 break;
3284732913 }
32848- case 2691LLU: // copy-back deleter (FindFn to PROCRETURN)
32914+ case 2696LLU: // copy-back deleter (FindFn to PROCRETURN)
3284932915 {
3285032916 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (FindFn to PROCRETURN)\n");
3285132917 // copy mutable arguments back from call to FindFn
32852- label = 2675LLU; // continue to roll stack
32918+ label = 2680LLU; // continue to roll stack
3285332919 break;
3285432920 }
32855- case 2692LLU: // return from FindFn to PROCRETURN
32921+ case 2697LLU: // return from FindFn to PROCRETURN
3285632922 {
3285732923 // copy mutable arguments back from call to FindFn
3285832924 // copy back results provided by call to FindFn
@@ -32859,7 +32925,7 @@
3285932925 stack[base + 24] = stack[base + 28LLU];
3286032926 if(/*fndef*/0 != ((uint64_t *)(stack[base + 24]/*calleedef*/))[0])
3286132927 {
32862- label = 2694LLU; // jump to alternative
32928+ label = 2699LLU; // jump to alternative
3286332929 break;
3286432930 }
3286532931
@@ -32874,14 +32940,14 @@
3287432940
3287532941 // case
3287632942 flippedassign(stack[base + 26]/*cerestypes*/, &stack[base + 33]);
32877- label = 2696LLU; // start to repeat
32943+ label = 2701LLU; // start to repeat
3287832944 break;
3287932945 }
32880- case 2696LLU: // repeat from here
32946+ case 2701LLU: // repeat from here
3288132947 {
3288232948 if(!stack[base + 33])
3288332949 {
32884- label = 2697LLU; // break loop
32950+ label = 2702LLU; // break loop
3288532951 break;
3288632952 }
3288732953
@@ -32893,7 +32959,7 @@
3289332959 struct listnode *list = (struct listnode *)stack[base + 20]/*BLKRESULTS*/;
3289432960 if(!list)
3289532961 {
32896- label = 2699LLU; // jump to alternative
32962+ label = 2704LLU; // jump to alternative
3289732963 break;
3289832964 }
3289932965
@@ -32905,7 +32971,7 @@
3290532971 }
3290632972 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 36]/*typeidx*/))[0])
3290732973 {
32908- label = 2703LLU; // jump to alternative
32974+ label = 2708LLU; // jump to alternative
3290932975 break;
3291032976 }
3291132977
@@ -32915,7 +32981,7 @@
3291532981 // case
3291632982 if(/*result*/0 != ((uint64_t *)(stack[base + 34]/*result*/))[0])
3291732983 {
32918- label = 2706LLU; // jump to alternative
32984+ label = 2711LLU; // jump to alternative
3291932985 break;
3292032986 }
3292132987
@@ -32926,7 +32992,7 @@
3292632992 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
3292732993 if(!newstack)
3292832994 {
32929- label = 2707LLU; // throw: begin to unroll stack
32995+ label = 2712LLU; // throw: begin to unroll stack
3293032996 break;
3293132997 }
3293232998
@@ -32933,9 +32999,9 @@
3293332999 newstack[15LLU] = 9876543210LLU; // overflow-marker
3293433000 // call equtype from PROCRETURN
3293533001 newstack[0] = (uint64_t)stack; // backup stack location
32936- newstack[1] = 2708LLU;
33002+ newstack[1] = 2713LLU;
3293733003 newstack[2] = base;
32938- newstack[3] = 2709LLU;
33004+ newstack[3] = 2714LLU;
3293933005 // arguments for call to equtype
3294033006 newstack[5LLU] = stack[base + 37]/*dsttype*/;
3294133007 newstack[6LLU] = stack[base + 39]/*srctype*/;
@@ -32945,7 +33011,7 @@
3294533011 label = 342LLU; // equtype
3294633012 break;
3294733013 }
32948- case 2708LLU: // copy-back deleter (equtype to PROCRETURN)
33014+ case 2713LLU: // copy-back deleter (equtype to PROCRETURN)
3294933015 {
3295033016 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equtype to PROCRETURN)\n");
3295133017 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -32957,10 +33023,10 @@
3295733023 }
3295833024 Free(15LLU + 1, sizeof(uint64_t), stack);
3295933025 stack = oldstack;
32960- label = 2707LLU; // continue to unroll stack
33026+ label = 2712LLU; // continue to unroll stack
3296133027 break;
3296233028 }
32963- case 2709LLU: // return from equtype to PROCRETURN
33029+ case 2714LLU: // return from equtype to PROCRETURN
3296433030 {
3296533031 uint64_t *oldstack = (uint64_t *)stack[0];
3296633032 // copy mutable arguments back from call to equtype
@@ -32975,21 +33041,21 @@
3297533041 stack = oldstack;
3297633042 if(!stack[base + 18]/*isequal*/)
3297733043 {
32978- label = 2710LLU; // jump to alternative
33044+ label = 2715LLU; // jump to alternative
3297933045 break;
3298033046 }
3298133047
3298233048 // consequent
32983- label = 2711LLU; // consequent complete
33049+ label = 2716LLU; // consequent complete
3298433050 break;
3298533051 }
32986- case 2710LLU: // alternative
33052+ case 2715LLU: // alternative
3298733053 {
3298833054 fprintf(stderr, "%s", "in function ");
3298933055 // call reportid from PROCRETURN
32990- stack[base + 41LLU] = 2712LLU/*throw to this address*/;
33056+ stack[base + 41LLU] = 2717LLU/*throw to this address*/;
3299133057 stack[base + 42LLU] = base;
32992- stack[base + 43LLU] = 2713LLU;
33058+ stack[base + 43LLU] = 2718LLU;
3299333059 // arguments for call to reportid
3299433060 stack[base + 44LLU] = stack[base + 9]/*fnid*/;
3299533061 // set stack-base & callee-address
@@ -32997,21 +33063,21 @@
3299733063 label = 18446744073709551586LLU; // reportid
3299833064 break;
3299933065 }
33000- case 2712LLU: // copy-back deleter (reportid to PROCRETURN)
33066+ case 2717LLU: // copy-back deleter (reportid to PROCRETURN)
3300133067 {
3300233068 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
3300333069 // copy mutable arguments back from call to reportid
33004- label = 2707LLU; // continue to roll stack
33070+ label = 2712LLU; // continue to roll stack
3300533071 break;
3300633072 }
33007- case 2713LLU: // return from reportid to PROCRETURN
33073+ case 2718LLU: // return from reportid to PROCRETURN
3300833074 {
3300933075 // copy mutable arguments back from call to reportid
3301033076 fprintf(stderr, "%s", " call to ");
3301133077 // call reportid from PROCRETURN
33012- stack[base + 41LLU] = 2714LLU/*throw to this address*/;
33078+ stack[base + 41LLU] = 2719LLU/*throw to this address*/;
3301333079 stack[base + 42LLU] = base;
33014- stack[base + 43LLU] = 2715LLU;
33080+ stack[base + 43LLU] = 2720LLU;
3301533081 // arguments for call to reportid
3301633082 stack[base + 44LLU] = stack[base + 29]/*ceid*/;
3301733083 // set stack-base & callee-address
@@ -33019,14 +33085,14 @@
3301933085 label = 18446744073709551586LLU; // reportid
3302033086 break;
3302133087 }
33022- case 2714LLU: // copy-back deleter (reportid to PROCRETURN)
33088+ case 2719LLU: // copy-back deleter (reportid to PROCRETURN)
3302333089 {
3302433090 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
3302533091 // copy mutable arguments back from call to reportid
33026- label = 2707LLU; // continue to roll stack
33092+ label = 2712LLU; // continue to roll stack
3302733093 break;
3302833094 }
33029- case 2715LLU: // return from reportid to PROCRETURN
33095+ case 2720LLU: // return from reportid to PROCRETURN
3303033096 {
3303133097 // copy mutable arguments back from call to reportid
3303233098 fprintf(stderr, "%s", " can't return result of type ");
@@ -33033,7 +33099,7 @@
3303333099 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3303433100 if(!newstack)
3303533101 {
33036- label = 2707LLU; // throw: begin to unroll stack
33102+ label = 2712LLU; // throw: begin to unroll stack
3303733103 break;
3303833104 }
3303933105
@@ -33040,9 +33106,9 @@
3304033106 newstack[10LLU] = 9876543210LLU; // overflow-marker
3304133107 // call reporttype from PROCRETURN
3304233108 newstack[0] = (uint64_t)stack; // backup stack location
33043- newstack[1] = 2716LLU;
33109+ newstack[1] = 2721LLU;
3304433110 newstack[2] = base;
33045- newstack[3] = 2717LLU;
33111+ newstack[3] = 2722LLU;
3304633112 // arguments for call to reporttype
3304733113 newstack[4LLU] = stack[base + 39]/*srctype*/;
3304833114 stack = newstack;
@@ -33051,7 +33117,7 @@
3305133117 label = 316LLU; // reporttype
3305233118 break;
3305333119 }
33054- case 2716LLU: // copy-back deleter (reporttype to PROCRETURN)
33120+ case 2721LLU: // copy-back deleter (reporttype to PROCRETURN)
3305533121 {
3305633122 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttype to PROCRETURN)\n");
3305733123 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -33063,10 +33129,10 @@
3306333129 }
3306433130 Free(10LLU + 1, sizeof(uint64_t), stack);
3306533131 stack = oldstack;
33066- label = 2707LLU; // continue to unroll stack
33132+ label = 2712LLU; // continue to unroll stack
3306733133 break;
3306833134 }
33069- case 2717LLU: // return from reporttype to PROCRETURN
33135+ case 2722LLU: // return from reporttype to PROCRETURN
3307033136 {
3307133137 uint64_t *oldstack = (uint64_t *)stack[0];
3307233138 // copy mutable arguments back from call to reporttype
@@ -33081,7 +33147,7 @@
3308133147 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
3308233148 if(!newstack)
3308333149 {
33084- label = 2707LLU; // throw: begin to unroll stack
33150+ label = 2712LLU; // throw: begin to unroll stack
3308533151 break;
3308633152 }
3308733153
@@ -33088,9 +33154,9 @@
3308833154 newstack[10LLU] = 9876543210LLU; // overflow-marker
3308933155 // call reporttype from PROCRETURN
3309033156 newstack[0] = (uint64_t)stack; // backup stack location
33091- newstack[1] = 2718LLU;
33157+ newstack[1] = 2723LLU;
3309233158 newstack[2] = base;
33093- newstack[3] = 2719LLU;
33159+ newstack[3] = 2724LLU;
3309433160 // arguments for call to reporttype
3309533161 newstack[4LLU] = stack[base + 37]/*dsttype*/;
3309633162 stack = newstack;
@@ -33099,7 +33165,7 @@
3309933165 label = 316LLU; // reporttype
3310033166 break;
3310133167 }
33102- case 2718LLU: // copy-back deleter (reporttype to PROCRETURN)
33168+ case 2723LLU: // copy-back deleter (reporttype to PROCRETURN)
3310333169 {
3310433170 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttype to PROCRETURN)\n");
3310533171 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -33111,10 +33177,10 @@
3311133177 }
3311233178 Free(10LLU + 1, sizeof(uint64_t), stack);
3311333179 stack = oldstack;
33114- label = 2707LLU; // continue to unroll stack
33180+ label = 2712LLU; // continue to unroll stack
3311533181 break;
3311633182 }
33117- case 2719LLU: // return from reporttype to PROCRETURN
33183+ case 2724LLU: // return from reporttype to PROCRETURN
3311833184 {
3311933185 uint64_t *oldstack = (uint64_t *)stack[0];
3312033186 // copy mutable arguments back from call to reporttype
@@ -33127,53 +33193,53 @@
3312733193 stack = oldstack;
3312833194 fprintf(stderr, "%s", "\n");
3312933195 exit(-1);
33130- label = 2711LLU; // alternative complete
33196+ label = 2716LLU; // alternative complete
3313133197 break;
3313233198 }
33133- case 2711LLU: // completed if-then-else
33199+ case 2716LLU: // completed if-then-else
3313433200 {
3313533201 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40];
3313633202 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39];
33137- label = 2705LLU; // case complete
33203+ label = 2710LLU; // case complete
3313833204 break;
3313933205 }
33140- case 2707LLU: // copy-back deleter (switch)
33206+ case 2712LLU: // copy-back deleter (switch)
3314133207 {
3314233208 ((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40];
3314333209 ((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39];
33144- label = 2704LLU; // continue to unroll stack
33210+ label = 2709LLU; // continue to unroll stack
3314533211 break;
3314633212 }
33147- case 2706LLU: // try next case
33213+ case 2711LLU: // try next case
3314833214 {
3314933215 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3315033216 exit(-1);
3315133217 }
33152- case 2705LLU: // completed switch
33218+ case 2710LLU: // completed switch
3315333219 {
3315433220 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38];
3315533221 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37];
33156- label = 2702LLU; // case complete
33222+ label = 2707LLU; // case complete
3315733223 break;
3315833224 }
33159- case 2704LLU: // copy-back deleter (switch)
33225+ case 2709LLU: // copy-back deleter (switch)
3316033226 {
3316133227 ((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38];
3316233228 ((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37];
33163- label = 2701LLU; // continue to unroll stack
33229+ label = 2706LLU; // continue to unroll stack
3316433230 break;
3316533231 }
33166- case 2703LLU: // try next case
33232+ case 2708LLU: // try next case
3316733233 {
3316833234 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3316933235 exit(-1);
3317033236 }
33171- case 2702LLU: // completed switch
33237+ case 2707LLU: // completed switch
3317233238 {
3317333239 // call cptypeidx from PROCRETURN
33174- stack[base + 38LLU] = 2720LLU/*throw to this address*/;
33240+ stack[base + 38LLU] = 2725LLU/*throw to this address*/;
3317533241 stack[base + 39LLU] = base;
33176- stack[base + 40LLU] = 2721LLU;
33242+ stack[base + 40LLU] = 2726LLU;
3317733243 // arguments for call to cptypeidx
3317833244 stack[base + 42LLU] = stack[base + 36]/*typeidx*/;
3317933245 // set stack-base & callee-address
@@ -33181,14 +33247,14 @@
3318133247 label = 382LLU; // cptypeidx
3318233248 break;
3318333249 }
33184- case 2720LLU: // copy-back deleter (cptypeidx to PROCRETURN)
33250+ case 2725LLU: // copy-back deleter (cptypeidx to PROCRETURN)
3318533251 {
3318633252 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (cptypeidx to PROCRETURN)\n");
3318733253 // copy mutable arguments back from call to cptypeidx
33188- label = 2701LLU; // continue to roll stack
33254+ label = 2706LLU; // continue to roll stack
3318933255 break;
3319033256 }
33191- case 2721LLU: // return from cptypeidx to PROCRETURN
33257+ case 2726LLU: // return from cptypeidx to PROCRETURN
3319233258 {
3319333259 // copy mutable arguments back from call to cptypeidx
3319433260 // copy back results provided by call to cptypeidx
@@ -33210,7 +33276,7 @@
3321033276 newstack[0] = (uint64_t)stack; // backup stack location
3321133277 newstack[1] = 1234567890;
3321233278 newstack[2] = base;
33213- newstack[3] = 2722LLU;
33279+ newstack[3] = 2727LLU;
3321433280 stack = newstack;
3321533281 // set stack-base & callee-address
3321633282 base = 4/*deloffset*/;
@@ -33217,16 +33283,16 @@
3321733283 label = 379LLU; // ~typeidx
3321833284 break;
3321933285 }
33220- case 2722LLU: // return from ~typeidx to PROCRETURN
33286+ case 2727LLU: // return from ~typeidx to PROCRETURN
3322133287 {
3322233288 stack = (uint64_t *)stack[0];
3322333289 // releasing toplevel container
3322433290 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4));
3322533291
33226- label = 2700LLU; // consequent complete
33292+ label = 2705LLU; // consequent complete
3322733293 break;
3322833294 }
33229- case 2701LLU: // copy-back deleter (if pop)
33295+ case 2706LLU: // copy-back deleter (if pop)
3323033296 {
3323133297
3323233298 uint64_t *newstack = (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4);
@@ -33234,7 +33300,7 @@
3323433300 newstack[0] = (uint64_t)stack; // backup stack location
3323533301 newstack[1] = 1234567890;
3323633302 newstack[2] = base;
33237- newstack[3] = 2723LLU;
33303+ newstack[3] = 2728LLU;
3323833304 stack = newstack;
3323933305 // set stack-base & callee-address
3324033306 base = 4/*deloffset*/;
@@ -33241,22 +33307,22 @@
3324133307 label = 379LLU; // ~typeidx
3324233308 break;
3324333309 }
33244- case 2723LLU: // return from ~typeidx to PROCRETURN
33310+ case 2728LLU: // return from ~typeidx to PROCRETURN
3324533311 {
3324633312 stack = (uint64_t *)stack[0];
3324733313 // releasing toplevel container
3324833314 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 36] - sizeof(uint64_t) * 4));
3324933315
33250- label = 2698LLU; // consequent complete
33316+ label = 2703LLU; // consequent complete
3325133317 break;
3325233318 }
33253- case 2699LLU: // alternative
33319+ case 2704LLU: // alternative
3325433320 {
3325533321 fprintf(stderr, "%s", "in function ");
3325633322 // call reportid from PROCRETURN
33257- stack[base + 37LLU] = 2724LLU/*throw to this address*/;
33323+ stack[base + 37LLU] = 2729LLU/*throw to this address*/;
3325833324 stack[base + 38LLU] = base;
33259- stack[base + 39LLU] = 2725LLU;
33325+ stack[base + 39LLU] = 2730LLU;
3326033326 // arguments for call to reportid
3326133327 stack[base + 40LLU] = stack[base + 9]/*fnid*/;
3326233328 // set stack-base & callee-address
@@ -33264,21 +33330,21 @@
3326433330 label = 18446744073709551586LLU; // reportid
3326533331 break;
3326633332 }
33267- case 2724LLU: // copy-back deleter (reportid to PROCRETURN)
33333+ case 2729LLU: // copy-back deleter (reportid to PROCRETURN)
3326833334 {
3326933335 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
3327033336 // copy mutable arguments back from call to reportid
33271- label = 2698LLU; // continue to roll stack
33337+ label = 2703LLU; // continue to roll stack
3327233338 break;
3327333339 }
33274- case 2725LLU: // return from reportid to PROCRETURN
33340+ case 2730LLU: // return from reportid to PROCRETURN
3327533341 {
3327633342 // copy mutable arguments back from call to reportid
3327733343 fprintf(stderr, "%s", " call to ");
3327833344 // call reportid from PROCRETURN
33279- stack[base + 37LLU] = 2726LLU/*throw to this address*/;
33345+ stack[base + 37LLU] = 2731LLU/*throw to this address*/;
3328033346 stack[base + 38LLU] = base;
33281- stack[base + 39LLU] = 2727LLU;
33347+ stack[base + 39LLU] = 2732LLU;
3328233348 // arguments for call to reportid
3328333349 stack[base + 40LLU] = stack[base + 29]/*ceid*/;
3328433350 // set stack-base & callee-address
@@ -33286,35 +33352,35 @@
3328633352 label = 18446744073709551586LLU; // reportid
3328733353 break;
3328833354 }
33289- case 2726LLU: // copy-back deleter (reportid to PROCRETURN)
33355+ case 2731LLU: // copy-back deleter (reportid to PROCRETURN)
3329033356 {
3329133357 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
3329233358 // copy mutable arguments back from call to reportid
33293- label = 2698LLU; // continue to roll stack
33359+ label = 2703LLU; // continue to roll stack
3329433360 break;
3329533361 }
33296- case 2727LLU: // return from reportid to PROCRETURN
33362+ case 2732LLU: // return from reportid to PROCRETURN
3329733363 {
3329833364 // copy mutable arguments back from call to reportid
3329933365 fprintf(stderr, "%s", " not enough destination-variables for results");
3330033366 fprintf(stderr, "%s", "\n");
3330133367 exit(-1);
33302- label = 2700LLU; // alternative complete
33368+ label = 2705LLU; // alternative complete
3330333369 break;
3330433370 }
33305- case 2700LLU: // completed if-then-else
33371+ case 2705LLU: // completed if-then-else
3330633372 {
3330733373 ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34];
33308- label = 2696LLU; // repeat
33374+ label = 2701LLU; // repeat
3330933375 break;
3331033376 }
33311- case 2698LLU: // copy-back deleter for while next
33377+ case 2703LLU: // copy-back deleter for while next
3331233378 {
3331333379 ((struct listnode *)(stack[base + 35]/*previous*/))->data = stack[base + 34];
33314- label = 2695LLU; // continue to unroll stack
33380+ label = 2700LLU; // continue to unroll stack
3331533381 break;
3331633382 }
33317- case 2697LLU: // loop finished
33383+ case 2702LLU: // loop finished
3331833384 {
3331933385 ((uint64_t **)(stack[base + 24]))[1][7] = stack[base + 32];
3332033386 ((uint64_t **)(stack[base + 24]))[1][6] = stack[base + 31];
@@ -33324,10 +33390,10 @@
3332433390 ((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
3332533391 ((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
3332633392 ((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
33327- label = 2693LLU; // case complete
33393+ label = 2698LLU; // case complete
3332833394 break;
3332933395 }
33330- case 2695LLU: // copy-back deleter (switch)
33396+ case 2700LLU: // copy-back deleter (switch)
3333133397 {
3333233398 ((uint64_t **)(stack[base + 24]))[1][7] = stack[base + 32];
3333333399 ((uint64_t **)(stack[base + 24]))[1][6] = stack[base + 31];
@@ -33337,21 +33403,21 @@
3333733403 ((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
3333833404 ((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
3333933405 ((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
33340- label = 2675LLU; // continue to unroll stack
33406+ label = 2680LLU; // continue to unroll stack
3334133407 break;
3334233408 }
33343- case 2694LLU: // try next case
33409+ case 2699LLU: // try next case
3334433410 {
3334533411 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
3334633412 exit(-1);
3334733413 }
33348- case 2693LLU: // completed switch
33414+ case 2698LLU: // completed switch
3334933415 {
3335033416 list_reverse(((struct listnode **)(&stack[base + 19]/*dsttypeidx*/)));
3335133417 // call matchsym from PROCRETURN
33352- stack[base + 25LLU] = 2728LLU/*throw to this address*/;
33418+ stack[base + 25LLU] = 2733LLU/*throw to this address*/;
3335333419 stack[base + 26LLU] = base;
33354- stack[base + 27LLU] = 2729LLU;
33420+ stack[base + 27LLU] = 2734LLU;
3335533421 // arguments for call to matchsym
3335633422 stack[base + 28LLU] = stack[base + 9]/*fnid*/;
3335733423 stack[base + 29LLU] = 40LLU;
@@ -33361,22 +33427,22 @@
3336133427 label = 212LLU; // matchsym
3336233428 break;
3336333429 }
33364- case 2728LLU: // copy-back deleter (matchsym to PROCRETURN)
33430+ case 2733LLU: // copy-back deleter (matchsym to PROCRETURN)
3336533431 {
3336633432 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
3336733433 // copy mutable arguments back from call to matchsym
3336833434 stack[base + 14]/*lookahead*/ = stack[base + 30LLU];
33369- label = 2675LLU; // continue to roll stack
33435+ label = 2680LLU; // continue to roll stack
3337033436 break;
3337133437 }
33372- case 2729LLU: // return from matchsym to PROCRETURN
33438+ case 2734LLU: // return from matchsym to PROCRETURN
3337333439 {
3337433440 // copy mutable arguments back from call to matchsym
3337533441 stack[base + 14]/*lookahead*/ = stack[base + 30LLU];
3337633442 // call ProcCall from PROCRETURN
33377- stack[base + 25LLU] = 2730LLU/*throw to this address*/;
33443+ stack[base + 25LLU] = 2735LLU/*throw to this address*/;
3337833444 stack[base + 26LLU] = base;
33379- stack[base + 27LLU] = 2731LLU;
33445+ stack[base + 27LLU] = 2736LLU;
3338033446 // arguments for call to ProcCall
3338133447 stack[base + 28LLU] = stack[base + 19]/*dsttypeidx*/;
3338233448 stack[base + 29LLU] = stack[base + 0]/*fndefs*/;
@@ -33401,7 +33467,7 @@
3340133467 label = 1566LLU; // ProcCall
3340233468 break;
3340333469 }
33404- case 2730LLU: // copy-back deleter (ProcCall to PROCRETURN)
33470+ case 2735LLU: // copy-back deleter (ProcCall to PROCRETURN)
3340533471 {
3340633472 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (ProcCall to PROCRETURN)\n");
3340733473 // copy mutable arguments back from call to ProcCall
@@ -33411,10 +33477,10 @@
3341133477 stack[base + 14]/*lookahead*/ = stack[base + 42LLU];
3341233478 stack[base + 13]/*fnmaxcount*/ = stack[base + 40LLU];
3341333479 stack[base + 19]/*dsttypeidx*/ = stack[base + 28LLU];
33414- label = 2675LLU; // continue to roll stack
33480+ label = 2680LLU; // continue to roll stack
3341533481 break;
3341633482 }
33417- case 2731LLU: // return from ProcCall to PROCRETURN
33483+ case 2736LLU: // return from ProcCall to PROCRETURN
3341833484 {
3341933485 // copy mutable arguments back from call to ProcCall
3342033486 stack[base + 17]/*label*/ = stack[base + 45LLU];
@@ -33424,9 +33490,9 @@
3342433490 stack[base + 13]/*fnmaxcount*/ = stack[base + 40LLU];
3342533491 stack[base + 19]/*dsttypeidx*/ = stack[base + 28LLU];
3342633492 // call matchsym from PROCRETURN
33427- stack[base + 25LLU] = 2732LLU/*throw to this address*/;
33493+ stack[base + 25LLU] = 2737LLU/*throw to this address*/;
3342833494 stack[base + 26LLU] = base;
33429- stack[base + 27LLU] = 2733LLU;
33495+ stack[base + 27LLU] = 2738LLU;
3343033496 // arguments for call to matchsym
3343133497 stack[base + 28LLU] = stack[base + 9]/*fnid*/;
3343233498 stack[base + 29LLU] = 41LLU;
@@ -33436,22 +33502,22 @@
3343633502 label = 212LLU; // matchsym
3343733503 break;
3343833504 }
33439- case 2732LLU: // copy-back deleter (matchsym to PROCRETURN)
33505+ case 2737LLU: // copy-back deleter (matchsym to PROCRETURN)
3344033506 {
3344133507 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
3344233508 // copy mutable arguments back from call to matchsym
3344333509 stack[base + 14]/*lookahead*/ = stack[base + 30LLU];
33444- label = 2675LLU; // continue to roll stack
33510+ label = 2680LLU; // continue to roll stack
3344533511 break;
3344633512 }
33447- case 2733LLU: // return from matchsym to PROCRETURN
33513+ case 2738LLU: // return from matchsym to PROCRETURN
3344833514 {
3344933515 // copy mutable arguments back from call to matchsym
3345033516 stack[base + 14]/*lookahead*/ = stack[base + 30LLU];
3345133517 // call skipwscmnt from PROCRETURN
33452- stack[base + 25LLU] = 2734LLU/*throw to this address*/;
33518+ stack[base + 25LLU] = 2739LLU/*throw to this address*/;
3345333519 stack[base + 26LLU] = base;
33454- stack[base + 27LLU] = 2735LLU;
33520+ stack[base + 27LLU] = 2740LLU;
3345533521 // arguments for call to skipwscmnt
3345633522 stack[base + 29LLU] = stack[base + 14]/*lookahead*/;
3345733523 // set stack-base & callee-address
@@ -33459,22 +33525,22 @@
3345933525 label = 18446744073709551580LLU; // skipwscmnt
3346033526 break;
3346133527 }
33462- case 2734LLU: // copy-back deleter (skipwscmnt to PROCRETURN)
33528+ case 2739LLU: // copy-back deleter (skipwscmnt to PROCRETURN)
3346333529 {
3346433530 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (skipwscmnt to PROCRETURN)\n");
3346533531 // copy mutable arguments back from call to skipwscmnt
33466- label = 2675LLU; // continue to roll stack
33532+ label = 2680LLU; // continue to roll stack
3346733533 break;
3346833534 }
33469- case 2735LLU: // return from skipwscmnt to PROCRETURN
33535+ case 2740LLU: // return from skipwscmnt to PROCRETURN
3347033536 {
3347133537 // copy mutable arguments back from call to skipwscmnt
3347233538 // copy back results provided by call to skipwscmnt
3347333539 stack[base + 14] = stack[base + 28LLU];
3347433540 // call equ from PROCRETURN
33475- stack[base + 25LLU] = 2736LLU/*throw to this address*/;
33541+ stack[base + 25LLU] = 2741LLU/*throw to this address*/;
3347633542 stack[base + 26LLU] = base;
33477- stack[base + 27LLU] = 2737LLU;
33543+ stack[base + 27LLU] = 2742LLU;
3347833544 // arguments for call to equ
3347933545 stack[base + 29LLU] = stack[base + 14]/*lookahead*/;
3348033546 stack[base + 30LLU] = 125LLU;
@@ -33483,14 +33549,14 @@
3348333549 label = 18446744073709551600LLU; // equ
3348433550 break;
3348533551 }
33486- case 2736LLU: // copy-back deleter (equ to PROCRETURN)
33552+ case 2741LLU: // copy-back deleter (equ to PROCRETURN)
3348733553 {
3348833554 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equ to PROCRETURN)\n");
3348933555 // copy mutable arguments back from call to equ
33490- label = 2675LLU; // continue to roll stack
33556+ label = 2680LLU; // continue to roll stack
3349133557 break;
3349233558 }
33493- case 2737LLU: // return from equ to PROCRETURN
33559+ case 2742LLU: // return from equ to PROCRETURN
3349433560 {
3349533561 // copy mutable arguments back from call to equ
3349633562 // copy back results provided by call to equ
@@ -33497,21 +33563,21 @@
3349733563 stack[base + 18] = stack[base + 28LLU];
3349833564 if(!stack[base + 18]/*isequal*/)
3349933565 {
33500- label = 2738LLU; // jump to alternative
33566+ label = 2743LLU; // jump to alternative
3350133567 break;
3350233568 }
3350333569
3350433570 // consequent
33505- label = 2739LLU; // consequent complete
33571+ label = 2744LLU; // consequent complete
3350633572 break;
3350733573 }
33508- case 2738LLU: // alternative
33574+ case 2743LLU: // alternative
3350933575 {
3351033576 fprintf(stderr, "%s", "in function ");
3351133577 // call reportid from PROCRETURN
33512- stack[base + 25LLU] = 2740LLU/*throw to this address*/;
33578+ stack[base + 25LLU] = 2745LLU/*throw to this address*/;
3351333579 stack[base + 26LLU] = base;
33514- stack[base + 27LLU] = 2741LLU;
33580+ stack[base + 27LLU] = 2746LLU;
3351533581 // arguments for call to reportid
3351633582 stack[base + 28LLU] = stack[base + 9]/*fnid*/;
3351733583 // set stack-base & callee-address
@@ -33519,21 +33585,21 @@
3351933585 label = 18446744073709551586LLU; // reportid
3352033586 break;
3352133587 }
33522- case 2740LLU: // copy-back deleter (reportid to PROCRETURN)
33588+ case 2745LLU: // copy-back deleter (reportid to PROCRETURN)
3352333589 {
3352433590 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
3352533591 // copy mutable arguments back from call to reportid
33526- label = 2675LLU; // continue to roll stack
33592+ label = 2680LLU; // continue to roll stack
3352733593 break;
3352833594 }
33529- case 2741LLU: // return from reportid to PROCRETURN
33595+ case 2746LLU: // return from reportid to PROCRETURN
3353033596 {
3353133597 // copy mutable arguments back from call to reportid
3353233598 fprintf(stderr, "%s", ": return must be last statement in function - expected '}' but found '");
3353333599 // call reportbyte from PROCRETURN
33534- stack[base + 25LLU] = 2742LLU/*throw to this address*/;
33600+ stack[base + 25LLU] = 2747LLU/*throw to this address*/;
3353533601 stack[base + 26LLU] = base;
33536- stack[base + 27LLU] = 2743LLU;
33602+ stack[base + 27LLU] = 2748LLU;
3353733603 // arguments for call to reportbyte
3353833604 stack[base + 28LLU] = stack[base + 14]/*lookahead*/;
3353933605 // set stack-base & callee-address
@@ -33541,22 +33607,22 @@
3354133607 label = 18446744073709551591LLU; // reportbyte
3354233608 break;
3354333609 }
33544- case 2742LLU: // copy-back deleter (reportbyte to PROCRETURN)
33610+ case 2747LLU: // copy-back deleter (reportbyte to PROCRETURN)
3354533611 {
3354633612 fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportbyte to PROCRETURN)\n");
3354733613 // copy mutable arguments back from call to reportbyte
33548- label = 2675LLU; // continue to roll stack
33614+ label = 2680LLU; // continue to roll stack
3354933615 break;
3355033616 }
33551- case 2743LLU: // return from reportbyte to PROCRETURN
33617+ case 2748LLU: // return from reportbyte to PROCRETURN
3355233618 {
3355333619 // copy mutable arguments back from call to reportbyte
3355433620 fprintf(stderr, "%s", "'\n");
3355533621 exit(-1);
33556- label = 2739LLU; // alternative complete
33622+ label = 2744LLU; // alternative complete
3355733623 break;
3355833624 }
33559- case 2739LLU: // completed if-then-else
33625+ case 2744LLU: // completed if-then-else
3356033626 {
3356133627
3356233628 uint64_t *newstack = (uint64_t *)(stack[base + 24] - sizeof(uint64_t) * 4);
@@ -33564,7 +33630,7 @@
3356433630 newstack[0] = (uint64_t)stack; // backup stack location
3356533631 newstack[1] = 1234567890;
3356633632 newstack[2] = base;
33567- newstack[3] = 2744LLU;
33633+ newstack[3] = 2749LLU;
3356833634 stack = newstack;
3356933635 // set stack-base & callee-address
3357033636 base = 4/*deloffset*/;
@@ -33571,7 +33637,7 @@
3357133637 label = 1336LLU; // ~fndef
3357233638 break;
3357333639 }
33574- case 2744LLU: // return from ~fndef to PROCRETURN
33640+ case 2749LLU: // return from ~fndef to PROCRETURN
3357533641 {
3357633642 stack = (uint64_t *)stack[0];
3357733643 // releasing toplevel container
@@ -33578,14 +33644,14 @@
3357833644 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 24] - sizeof(uint64_t) * 4));
3357933645
3358033646 // delete list
33581- label = 2745LLU; // start to repeat
33647+ label = 2750LLU; // start to repeat
3358233648 break;
3358333649 }
33584- case 2745LLU: // repeat from here
33650+ case 2750LLU: // repeat from here
3358533651 {
3358633652 if(!stack[base + 20])
3358733653 {
33588- label = 2746LLU; // break loop
33654+ label = 2751LLU; // break loop
3358933655 break;
3359033656 }
3359133657
@@ -33596,7 +33662,7 @@
3359633662 newstack[0] = (uint64_t)stack; // backup stack location
3359733663 newstack[1] = 1234567890;
3359833664 newstack[2] = base;
33599- newstack[3] = 2747LLU;
33665+ newstack[3] = 2752LLU;
3360033666 stack = newstack;
3360133667 // set stack-base & callee-address
3360233668 base = 4/*deloffset*/;
@@ -33603,7 +33669,7 @@
3360333669 label = 379LLU; // ~typeidx
3360433670 break;
3360533671 }
33606- case 2747LLU: // return from ~typeidx to PROCRETURN
33672+ case 2752LLU: // return from ~typeidx to PROCRETURN
3360733673 {
3360833674 stack = (uint64_t *)stack[0];
3360933675 // releasing toplevel container
@@ -33614,20 +33680,20 @@
3361433680 stack[base + 20] = (uint64_t)list->next;
3361533681 Free(1, sizeof(struct listnode), list);
3361633682 }
33617- label = 2745LLU; // repeat
33683+ label = 2750LLU; // repeat
3361833684 break;
3361933685 }
33620- case 2746LLU: // loop finished
33686+ case 2751LLU: // loop finished
3362133687 {
3362233688 // delete list
33623- label = 2748LLU; // start to repeat
33689+ label = 2753LLU; // start to repeat
3362433690 break;
3362533691 }
33626- case 2748LLU: // repeat from here
33692+ case 2753LLU: // repeat from here
3362733693 {
3362833694 if(!stack[base + 19])
3362933695 {
33630- label = 2749LLU; // break loop
33696+ label = 2754LLU; // break loop
3363133697 break;
3363233698 }
3363333699
@@ -33638,7 +33704,7 @@
3363833704 newstack[0] = (uint64_t)stack; // backup stack location
3363933705 newstack[1] = 1234567890;
3364033706 newstack[2] = base;
33641- newstack[3] = 2750LLU;
33707+ newstack[3] = 2755LLU;
3364233708 stack = newstack;
3364333709 // set stack-base & callee-address
3364433710 base = 4/*deloffset*/;
@@ -33645,7 +33711,7 @@
3364533711 label = 379LLU; // ~typeidx
3364633712 break;
3364733713 }
33648- case 2750LLU: // return from ~typeidx to PROCRETURN
33714+ case 2755LLU: // return from ~typeidx to PROCRETURN
3364933715 {
3365033716 stack = (uint64_t *)stack[0];
3365133717 // releasing toplevel container
@@ -33656,15 +33722,15 @@
3365633722 stack[base + 19] = (uint64_t)list->next;
3365733723 Free(1, sizeof(struct listnode), list);
3365833724 }
33659- label = 2748LLU; // repeat
33725+ label = 2753LLU; // repeat
3366033726 break;
3366133727 }
33662- case 2749LLU: // loop finished
33728+ case 2754LLU: // loop finished
3366333729 {
33664- label = 2655LLU; // alternative complete
33730+ label = 2660LLU; // alternative complete
3366533731 break;
3366633732 }
33667- case 2655LLU: // completed if-then-else
33733+ case 2660LLU: // completed if-then-else
3366833734 {
3366933735 // return from PROCRETURN
3367033736 label = stack[base - 1];
@@ -33671,7 +33737,7 @@
3367133737 base = stack[base - 2];
3367233738 break;
3367333739 }
33674- case 2752LLU: // function PROCCALL failed
33740+ case 2757LLU: // function PROCCALL failed
3367533741 {
3367633742 fprintf(stderr, "function PROCCALL failed\n");
3367733743 label = stack[base - 3];
@@ -33678,7 +33744,7 @@
3367833744 base = stack[base - 2];
3367933745 break;
3368033746 }
33681- case 2751LLU: // PROCCALL
33747+ case 2756LLU: // PROCCALL
3368233748 {
3368333749 //#define arg0 0
3368433750 //#define arg1 1
@@ -33696,28 +33762,28 @@
3369633762 //#define arg13 13
3369733763 //#define arg14 14
3369833764 //#define arg15 15
33699- label = 2754LLU; // skip deleter
33765+ label = 2759LLU; // skip deleter
3370033766 break;
3370133767 }
33702- case 2753LLU: // deleter
33768+ case 2758LLU: // deleter
3370333769 {
3370433770 // throw from PROCCALL
3370533771 if(!stack[base + 16])
3370633772 {
3370733773 fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable [typeidx] dsttypeidx\n");
33708- label = 2752LLU; // skip, variable already deleted/unscoped
33774+ label = 2757LLU; // skip, variable already deleted/unscoped
3370933775 break;
3371033776 }
3371133777 fprintf(stderr, "in function PROCCALL: unrolling stack, variable [typeidx] dsttypeidx\n");
3371233778 // delete list
33713- label = 2755LLU; // start to repeat
33779+ label = 2760LLU; // start to repeat
3371433780 break;
3371533781 }
33716- case 2755LLU: // repeat from here
33782+ case 2760LLU: // repeat from here
3371733783 {
3371833784 if(!stack[base + 16])
3371933785 {
33720- label = 2756LLU; // break loop
33786+ label = 2761LLU; // break loop
3372133787 break;
3372233788 }
3372333789
@@ -33728,7 +33794,7 @@
3372833794 newstack[0] = (uint64_t)stack; // backup stack location
3372933795 newstack[1] = 1234567890;
3373033796 newstack[2] = base;
33731- newstack[3] = 2757LLU;
33797+ newstack[3] = 2762LLU;
3373233798 stack = newstack;
3373333799 // set stack-base & callee-address
3373433800 base = 4/*deloffset*/;
@@ -33735,7 +33801,7 @@
3373533801 label = 379LLU; // ~typeidx
3373633802 break;
3373733803 }
33738- case 2757LLU: // return from ~typeidx to PROCCALL
33804+ case 2762LLU: // return from ~typeidx to PROCCALL
3373933805 {
3374033806 stack = (uint64_t *)stack[0];
3374133807 // releasing toplevel container
@@ -33746,39 +33812,39 @@
3374633812 stack[base + 16] = (uint64_t)list->next;
3374733813 Free(1, sizeof(struct listnode), list);
3374833814 }
33749- label = 2755LLU; // repeat
33815+ label = 2760LLU; // repeat
3375033816 break;
3375133817 }
33752- case 2756LLU: // loop finished
33818+ case 2761LLU: // loop finished
3375333819 {
33754- label = 2752LLU; // continue unrolling stack, delete next variable
33820+ label = 2757LLU; // continue unrolling stack, delete next variable
3375533821 break;
3375633822 }
33757- case 2754LLU: // skipped deleter
33823+ case 2759LLU: // skipped deleter
3375833824 {
3375933825 stack[base + 16] = 0;
33760- label = 2759LLU; // skip deleter
33826+ label = 2764LLU; // skip deleter
3376133827 break;
3376233828 }
33763- case 2758LLU: // deleter
33829+ case 2763LLU: // deleter
3376433830 {
3376533831 // throw from PROCCALL
3376633832 if(!stack[base + 17])
3376733833 {
3376833834 fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable [letdef] results\n");
33769- label = 2753LLU; // skip, variable already deleted/unscoped
33835+ label = 2758LLU; // skip, variable already deleted/unscoped
3377033836 break;
3377133837 }
3377233838 fprintf(stderr, "in function PROCCALL: unrolling stack, variable [letdef] results\n");
3377333839 // delete list
33774- label = 2760LLU; // start to repeat
33840+ label = 2765LLU; // start to repeat
3377533841 break;
3377633842 }
33777- case 2760LLU: // repeat from here
33843+ case 2765LLU: // repeat from here
3377833844 {
3377933845 if(!stack[base + 17])
3378033846 {
33781- label = 2761LLU; // break loop
33847+ label = 2766LLU; // break loop
3378233848 break;
3378333849 }
3378433850
@@ -33789,7 +33855,7 @@
3378933855 newstack[0] = (uint64_t)stack; // backup stack location
3379033856 newstack[1] = 1234567890;
3379133857 newstack[2] = base;
33792- newstack[3] = 2762LLU;
33858+ newstack[3] = 2767LLU;
3379333859 stack = newstack;
3379433860 // set stack-base & callee-address
3379533861 base = 4/*deloffset*/;
@@ -33796,7 +33862,7 @@
3379633862 label = 457LLU; // ~letdef
3379733863 break;
3379833864 }
33799- case 2762LLU: // return from ~letdef to PROCCALL
33865+ case 2767LLU: // return from ~letdef to PROCCALL
3380033866 {
3380133867 stack = (uint64_t *)stack[0];
3380233868 // releasing toplevel container
@@ -33807,40 +33873,40 @@
3380733873 stack[base + 17] = (uint64_t)list->next;
3380833874 Free(1, sizeof(struct listnode), list);
3380933875 }
33810- label = 2760LLU; // repeat
33876+ label = 2765LLU; // repeat
3381133877 break;
3381233878 }
33813- case 2761LLU: // loop finished
33879+ case 2766LLU: // loop finished
3381433880 {
33815- label = 2753LLU; // continue unrolling stack, delete next variable
33881+ label = 2758LLU; // continue unrolling stack, delete next variable
3381633882 break;
3381733883 }
33818- case 2759LLU: // skipped deleter
33884+ case 2764LLU: // skipped deleter
3381933885 {
3382033886 stack[base + 17] = 0;
33821- label = 2764LLU; // skip deleter
33887+ label = 2769LLU; // skip deleter
3382233888 break;
3382333889 }
33824- case 2763LLU: // deleter
33890+ case 2768LLU: // deleter
3382533891 {
3382633892 // throw from PROCCALL
3382733893 if(!stack[base + 18])
3382833894 {
3382933895 fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
33830- label = 2758LLU; // skip, variable already deleted/unscoped
33896+ label = 2763LLU; // skip, variable already deleted/unscoped
3383133897 break;
3383233898 }
3383333899 fprintf(stderr, "in function PROCCALL: unrolling stack, variable u64 isequal\n");
33834- label = 2758LLU; // continue unrolling stack, delete next variable
33900+ label = 2763LLU; // continue unrolling stack, delete next variable
3383533901 break;
3383633902 }
33837- case 2764LLU: // skipped deleter
33903+ case 2769LLU: // skipped deleter
3383833904 {
3383933905 stack[base + 18] = 0;
3384033906 // call equ from PROCCALL
33841- stack[base + 19LLU] = 2765LLU/*throw to this address*/;
33907+ stack[base + 19LLU] = 2770LLU/*throw to this address*/;
3384233908 stack[base + 20LLU] = base;
33843- stack[base + 21LLU] = 2766LLU;
33909+ stack[base + 21LLU] = 2771LLU;
3384433910 // arguments for call to equ
3384533911 stack[base + 23LLU] = 40LLU;
3384633912 stack[base + 24LLU] = stack[base + 14]/*content*/;
@@ -33849,14 +33915,14 @@
3384933915 label = 18446744073709551600LLU; // equ
3385033916 break;
3385133917 }
33852- case 2765LLU: // copy-back deleter (equ to PROCCALL)
33918+ case 2770LLU: // copy-back deleter (equ to PROCCALL)
3385333919 {
3385433920 fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (equ to PROCCALL)\n");
3385533921 // copy mutable arguments back from call to equ
33856- label = 2763LLU; // continue to roll stack
33922+ label = 2768LLU; // continue to roll stack
3385733923 break;
3385833924 }
33859- case 2766LLU: // return from equ to PROCCALL
33925+ case 2771LLU: // return from equ to PROCCALL
3386033926 {
3386133927 // copy mutable arguments back from call to equ
3386233928 // copy back results provided by call to equ
@@ -33863,21 +33929,21 @@
3386333929 stack[base + 18] = stack[base + 22LLU];
3386433930 if(!stack[base + 18]/*isequal*/)
3386533931 {
33866- label = 2767LLU; // jump to alternative
33932+ label = 2772LLU; // jump to alternative
3386733933 break;
3386833934 }
3386933935
3387033936 // consequent
33871- label = 2768LLU; // consequent complete
33937+ label = 2773LLU; // consequent complete
3387233938 break;
3387333939 }
33874- case 2767LLU: // alternative
33940+ case 2772LLU: // alternative
3387533941 {
3387633942 fprintf(stderr, "%s", "expected '(' but found token ");
3387733943 // call reporttok from PROCCALL
33878- stack[base + 19LLU] = 2769LLU/*throw to this address*/;
33944+ stack[base + 19LLU] = 2774LLU/*throw to this address*/;
3387933945 stack[base + 20LLU] = base;
33880- stack[base + 21LLU] = 2770LLU;
33946+ stack[base + 21LLU] = 2775LLU;
3388133947 // arguments for call to reporttok
3388233948 stack[base + 22LLU] = stack[base + 13]/*variant*/;
3388333949 stack[base + 23LLU] = stack[base + 14]/*content*/;
@@ -33886,27 +33952,27 @@
3388633952 label = 18446744073709551582LLU; // reporttok
3388733953 break;
3388833954 }
33889- case 2769LLU: // copy-back deleter (reporttok to PROCCALL)
33955+ case 2774LLU: // copy-back deleter (reporttok to PROCCALL)
3389033956 {
3389133957 fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (reporttok to PROCCALL)\n");
3389233958 // copy mutable arguments back from call to reporttok
33893- label = 2763LLU; // continue to roll stack
33959+ label = 2768LLU; // continue to roll stack
3389433960 break;
3389533961 }
33896- case 2770LLU: // return from reporttok to PROCCALL
33962+ case 2775LLU: // return from reporttok to PROCCALL
3389733963 {
3389833964 // copy mutable arguments back from call to reporttok
3389933965 fprintf(stderr, "%s", "\n");
3390033966 exit(-1);
33901- label = 2768LLU; // alternative complete
33967+ label = 2773LLU; // alternative complete
3390233968 break;
3390333969 }
33904- case 2768LLU: // completed if-then-else
33970+ case 2773LLU: // completed if-then-else
3390533971 {
3390633972 // call skipwscmnt from PROCCALL
33907- stack[base + 19LLU] = 2771LLU/*throw to this address*/;
33973+ stack[base + 19LLU] = 2776LLU/*throw to this address*/;
3390833974 stack[base + 20LLU] = base;
33909- stack[base + 21LLU] = 2772LLU;
33975+ stack[base + 21LLU] = 2777LLU;
3391033976 // arguments for call to skipwscmnt
3391133977 stack[base + 23LLU] = stack[base + 12]/*lookahead*/;
3391233978 // set stack-base & callee-address
@@ -33914,22 +33980,22 @@
3391433980 label = 18446744073709551580LLU; // skipwscmnt
3391533981 break;
3391633982 }
33917- case 2771LLU: // copy-back deleter (skipwscmnt to PROCCALL)
33983+ case 2776LLU: // copy-back deleter (skipwscmnt to PROCCALL)
3391833984 {
3391933985 fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (skipwscmnt to PROCCALL)\n");
3392033986 // copy mutable arguments back from call to skipwscmnt
33921- label = 2763LLU; // continue to roll stack
33987+ label = 2768LLU; // continue to roll stack
3392233988 break;
3392333989 }
33924- case 2772LLU: // return from skipwscmnt to PROCCALL
33990+ case 2777LLU: // return from skipwscmnt to PROCCALL
3392533991 {
3392633992 // copy mutable arguments back from call to skipwscmnt
3392733993 // copy back results provided by call to skipwscmnt
3392833994 stack[base + 12] = stack[base + 22LLU];
3392933995 // call equ from PROCCALL
33930- stack[base + 19LLU] = 2773LLU/*throw to this address*/;
33996+ stack[base + 19LLU] = 2778LLU/*throw to this address*/;
3393133997 stack[base + 20LLU] = base;
33932- stack[base + 21LLU] = 2774LLU;
33998+ stack[base + 21LLU] = 2779LLU;
3393333999 // arguments for call to equ
3393434000 stack[base + 23LLU] = stack[base + 12]/*lookahead*/;
3393534001 stack[base + 24LLU] = 41LLU;
@@ -33938,14 +34004,14 @@
3393834004 label = 18446744073709551600LLU; // equ
3393934005 break;
3394034006 }
33941- case 2773LLU: // copy-back deleter (equ to PROCCALL)
34007+ case 2778LLU: // copy-back deleter (equ to PROCCALL)
3394234008 {
3394334009 fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (equ to PROCCALL)\n");
3394434010 // copy mutable arguments back from call to equ
33945- label = 2763LLU; // continue to roll stack
34011+ label = 2768LLU; // continue to roll stack
3394634012 break;
3394734013 }
33948- case 2774LLU: // return from equ to PROCCALL
34014+ case 2779LLU: // return from equ to PROCCALL
3394934015 {
3395034016 // copy mutable arguments back from call to equ
3395134017 // copy back results provided by call to equ
@@ -33952,32 +34018,32 @@
3395234018 stack[base + 18] = stack[base + 22LLU];
3395334019 if(!stack[base + 18]/*isequal*/)
3395434020 {
33955- label = 2775LLU; // jump to alternative
34021+ label = 2780LLU; // jump to alternative
3395634022 break;
3395734023 }
3395834024
3395934025 // consequent
33960- label = 2776LLU; // consequent complete
34026+ label = 2781LLU; // consequent complete
3396134027 break;
3396234028 }
33963- case 2775LLU: // alternative
34029+ case 2780LLU: // alternative
3396434030 {
33965- label = 2777LLU; // start to repeat
34031+ label = 2782LLU; // start to repeat
3396634032 break;
3396734033 }
33968- case 2777LLU: // repeat from here
34034+ case 2782LLU: // repeat from here
3396934035 {
3397034036 if(stack[base + 12]/*lookahead*/ > 0xFF)
3397134037 {
33972- label = 2778LLU; // break loop
34038+ label = 2783LLU; // break loop
3397334039 break;
3397434040 }
3397534041
3397634042 // loop body
3397734043 // call ParseToken from PROCCALL
33978- stack[base + 19LLU] = 2779LLU/*throw to this address*/;
34044+ stack[base + 19LLU] = 2784LLU/*throw to this address*/;
3397934045 stack[base + 20LLU] = base;
33980- stack[base + 21LLU] = 2780LLU;
34046+ stack[base + 21LLU] = 2785LLU;
3398134047 // arguments for call to ParseToken
3398234048 stack[base + 24LLU] = stack[base + 12]/*lookahead*/;
3398334049 // set stack-base & callee-address
@@ -33985,15 +34051,15 @@
3398534051 label = 3LLU; // ParseToken
3398634052 break;
3398734053 }
33988- case 2779LLU: // copy-back deleter (ParseToken to PROCCALL)
34054+ case 2784LLU: // copy-back deleter (ParseToken to PROCCALL)
3398934055 {
3399034056 fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (ParseToken to PROCCALL)\n");
3399134057 // copy mutable arguments back from call to ParseToken
3399234058 stack[base + 12]/*lookahead*/ = stack[base + 24LLU];
33993- label = 2763LLU; // continue to roll stack
34059+ label = 2768LLU; // continue to roll stack
3399434060 break;
3399534061 }
33996- case 2780LLU: // return from ParseToken to PROCCALL
34062