• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1168 (tree)
Time2021-02-24 04:57:52
Authorjakobthomsen

Log Message

fix copy-back on exception in while-next

Change Summary

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1167)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1168)
@@ -2612,20 +2612,20 @@
26122612 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
26132613 if(!stack[base + 3]/*found*/)
26142614 {
2615- label = 151LLU; // jump to alternative
2615+ label = 152LLU; // jump to alternative
26162616 break;
26172617 }
26182618
26192619 // consequent
2620- label = 152LLU; // consequent complete
2620+ label = 153LLU; // consequent complete
26212621 break;
26222622 }
2623- case 151LLU: // alternative
2623+ case 152LLU: // alternative
26242624 {
26252625 // call equ from existsid
2626- stack[base + 7LLU] = 153LLU/*throw to this address*/;
2626+ stack[base + 7LLU] = 154LLU/*throw to this address*/;
26272627 stack[base + 8LLU] = base;
2628- stack[base + 9LLU] = 154LLU;
2628+ stack[base + 9LLU] = 155LLU;
26292629 // arguments for call to equ
26302630 stack[base + 11LLU] = stack[base + 5]/*current*/;
26312631 stack[base + 12LLU] = stack[base + 2]/*wanted*/;
@@ -2634,33 +2634,39 @@
26342634 label = 18446744073709551600LLU; // equ
26352635 break;
26362636 }
2637- case 153LLU: // copy-back deleter (equ to existsid)
2637+ case 154LLU: // copy-back deleter (equ to existsid)
26382638 {
26392639 fprintf(stderr, "in function existsid: unrolling stack, copy-back (equ to existsid)\n");
26402640 // copy mutable arguments back from call to equ
2641- label = 147LLU; // continue to roll stack
2641+ label = 151LLU; // continue to roll stack
26422642 break;
26432643 }
2644- case 154LLU: // return from equ to existsid
2644+ case 155LLU: // return from equ to existsid
26452645 {
26462646 // copy mutable arguments back from call to equ
26472647 // copy back results provided by call to equ
26482648 stack[base + 3] = stack[base + 10LLU];
2649- label = 152LLU; // alternative complete
2649+ label = 153LLU; // alternative complete
26502650 break;
26512651 }
2652- case 152LLU: // completed if-then-else
2652+ case 153LLU: // completed if-then-else
26532653 {
26542654 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
26552655 label = 149LLU; // repeat
26562656 break;
26572657 }
2658+ case 151LLU: // copy-back deleter for while next
2659+ {
2660+ ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
2661+ label = 147LLU; // continue to unroll stack
2662+ break;
2663+ }
26582664 case 150LLU: // loop finished
26592665 {
2660- label = 156LLU; // skip deleter
2666+ label = 157LLU; // skip deleter
26612667 break;
26622668 }
2663- case 155LLU: // deleter
2669+ case 156LLU: // deleter
26642670 {
26652671 // throw from existsid
26662672 if(!stack[base + 0])
@@ -2673,7 +2679,7 @@
26732679 label = 147LLU; // continue unrolling stack, delete next variable
26742680 break;
26752681 }
2676- case 156LLU: // skipped deleter
2682+ case 157LLU: // skipped deleter
26772683 {
26782684 stack[base + 0] = stack[base + 3]/*found*/;
26792685 // return from existsid
@@ -2681,7 +2687,7 @@
26812687 base = stack[base - 2];
26822688 break;
26832689 }
2684- case 158LLU: // function issimple failed
2690+ case 159LLU: // function issimple failed
26852691 {
26862692 fprintf(stderr, "function issimple failed\n");
26872693 label = stack[base - 3];
@@ -2688,35 +2694,35 @@
26882694 base = stack[base - 2];
26892695 break;
26902696 }
2691- case 157LLU: // issimple
2697+ case 158LLU: // issimple
26922698 {
26932699 //#define res0 0
26942700 //#define arg0 1
26952701 //#define arg1 2
26962702 //#define arg2 3
2697- label = 160LLU; // skip deleter
2703+ label = 161LLU; // skip deleter
26982704 break;
26992705 }
2700- case 159LLU: // deleter
2706+ case 160LLU: // deleter
27012707 {
27022708 // throw from issimple
27032709 if(!stack[base + 4])
27042710 {
27052711 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2706- label = 158LLU; // skip, variable already deleted/unscoped
2712+ label = 159LLU; // skip, variable already deleted/unscoped
27072713 break;
27082714 }
27092715 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2710- label = 158LLU; // continue unrolling stack, delete next variable
2716+ label = 159LLU; // continue unrolling stack, delete next variable
27112717 break;
27122718 }
2713- case 160LLU: // skipped deleter
2719+ case 161LLU: // skipped deleter
27142720 {
27152721 stack[base + 4] = 0;
27162722 // call equ from issimple
2717- stack[base + 5LLU] = 161LLU/*throw to this address*/;
2723+ stack[base + 5LLU] = 162LLU/*throw to this address*/;
27182724 stack[base + 6LLU] = base;
2719- stack[base + 7LLU] = 162LLU;
2725+ stack[base + 7LLU] = 163LLU;
27202726 // arguments for call to equ
27212727 stack[base + 9LLU] = stack[base + 1]/*variant*/;
27222728 stack[base + 10LLU] = 0LLU;
@@ -2725,14 +2731,14 @@
27252731 label = 18446744073709551600LLU; // equ
27262732 break;
27272733 }
2728- case 161LLU: // copy-back deleter (equ to issimple)
2734+ case 162LLU: // copy-back deleter (equ to issimple)
27292735 {
27302736 fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
27312737 // copy mutable arguments back from call to equ
2732- label = 159LLU; // continue to roll stack
2738+ label = 160LLU; // continue to roll stack
27332739 break;
27342740 }
2735- case 162LLU: // return from equ to issimple
2741+ case 163LLU: // return from equ to issimple
27362742 {
27372743 // copy mutable arguments back from call to equ
27382744 // copy back results provided by call to equ
@@ -2739,15 +2745,15 @@
27392745 stack[base + 4] = stack[base + 8LLU];
27402746 if(!stack[base + 4]/*isequal*/)
27412747 {
2742- label = 163LLU; // jump to alternative
2748+ label = 164LLU; // jump to alternative
27432749 break;
27442750 }
27452751
27462752 // consequent
27472753 // call equ from issimple
2748- stack[base + 5LLU] = 165LLU/*throw to this address*/;
2754+ stack[base + 5LLU] = 166LLU/*throw to this address*/;
27492755 stack[base + 6LLU] = base;
2750- stack[base + 7LLU] = 166LLU;
2756+ stack[base + 7LLU] = 167LLU;
27512757 // arguments for call to equ
27522758 stack[base + 9LLU] = stack[base + 3]/*sym*/;
27532759 stack[base + 10LLU] = stack[base + 2]/*content*/;
@@ -2756,14 +2762,14 @@
27562762 label = 18446744073709551600LLU; // equ
27572763 break;
27582764 }
2759- case 165LLU: // copy-back deleter (equ to issimple)
2765+ case 166LLU: // copy-back deleter (equ to issimple)
27602766 {
27612767 fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
27622768 // copy mutable arguments back from call to equ
2763- label = 159LLU; // continue to roll stack
2769+ label = 160LLU; // continue to roll stack
27642770 break;
27652771 }
2766- case 166LLU: // return from equ to issimple
2772+ case 167LLU: // return from equ to issimple
27672773 {
27682774 // copy mutable arguments back from call to equ
27692775 // copy back results provided by call to equ
@@ -2770,87 +2776,87 @@
27702776 stack[base + 4] = stack[base + 8LLU];
27712777 if(!stack[base + 4]/*isequal*/)
27722778 {
2773- label = 167LLU; // jump to alternative
2779+ label = 168LLU; // jump to alternative
27742780 break;
27752781 }
27762782
27772783 // consequent
2778- label = 170LLU; // skip deleter
2784+ label = 171LLU; // skip deleter
27792785 break;
27802786 }
2781- case 169LLU: // deleter
2787+ case 170LLU: // deleter
27822788 {
27832789 // throw from issimple
27842790 if(!stack[base + 0])
27852791 {
27862792 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2787- label = 159LLU; // skip, variable already deleted/unscoped
2793+ label = 160LLU; // skip, variable already deleted/unscoped
27882794 break;
27892795 }
27902796 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2791- label = 159LLU; // continue unrolling stack, delete next variable
2797+ label = 160LLU; // continue unrolling stack, delete next variable
27922798 break;
27932799 }
2794- case 170LLU: // skipped deleter
2800+ case 171LLU: // skipped deleter
27952801 {
27962802 stack[base + 0] = 1;
2797- label = 168LLU; // consequent complete
2803+ label = 169LLU; // consequent complete
27982804 break;
27992805 }
2800- case 167LLU: // alternative
2806+ case 168LLU: // alternative
28012807 {
2802- label = 172LLU; // skip deleter
2808+ label = 173LLU; // skip deleter
28032809 break;
28042810 }
2805- case 171LLU: // deleter
2811+ case 172LLU: // deleter
28062812 {
28072813 // throw from issimple
28082814 if(!stack[base + 0])
28092815 {
28102816 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2811- label = 159LLU; // skip, variable already deleted/unscoped
2817+ label = 160LLU; // skip, variable already deleted/unscoped
28122818 break;
28132819 }
28142820 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2815- label = 159LLU; // continue unrolling stack, delete next variable
2821+ label = 160LLU; // continue unrolling stack, delete next variable
28162822 break;
28172823 }
2818- case 172LLU: // skipped deleter
2824+ case 173LLU: // skipped deleter
28192825 {
28202826 stack[base + 0] = 0;
2821- label = 168LLU; // alternative complete
2827+ label = 169LLU; // alternative complete
28222828 break;
28232829 }
2824- case 168LLU: // completed if-then-else
2830+ case 169LLU: // completed if-then-else
28252831 {
2826- label = 164LLU; // consequent complete
2832+ label = 165LLU; // consequent complete
28272833 break;
28282834 }
2829- case 163LLU: // alternative
2835+ case 164LLU: // alternative
28302836 {
2831- label = 174LLU; // skip deleter
2837+ label = 175LLU; // skip deleter
28322838 break;
28332839 }
2834- case 173LLU: // deleter
2840+ case 174LLU: // deleter
28352841 {
28362842 // throw from issimple
28372843 if(!stack[base + 0])
28382844 {
28392845 fprintf(stderr, "in function issimple: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2840- label = 159LLU; // skip, variable already deleted/unscoped
2846+ label = 160LLU; // skip, variable already deleted/unscoped
28412847 break;
28422848 }
28432849 fprintf(stderr, "in function issimple: unrolling stack, variable u64 \n");
2844- label = 159LLU; // continue unrolling stack, delete next variable
2850+ label = 160LLU; // continue unrolling stack, delete next variable
28452851 break;
28462852 }
2847- case 174LLU: // skipped deleter
2853+ case 175LLU: // skipped deleter
28482854 {
28492855 stack[base + 0] = 0;
2850- label = 164LLU; // alternative complete
2856+ label = 165LLU; // alternative complete
28512857 break;
28522858 }
2853- case 164LLU: // completed if-then-else
2859+ case 165LLU: // completed if-then-else
28542860 {
28552861 // return from issimple
28562862 label = stack[base - 1];
@@ -2857,7 +2863,7 @@
28572863 base = stack[base - 2];
28582864 break;
28592865 }
2860- case 176LLU: // function isident failed
2866+ case 177LLU: // function isident failed
28612867 {
28622868 fprintf(stderr, "function isident failed\n");
28632869 label = stack[base - 3];
@@ -2864,35 +2870,35 @@
28642870 base = stack[base - 2];
28652871 break;
28662872 }
2867- case 175LLU: // isident
2873+ case 176LLU: // isident
28682874 {
28692875 //#define res0 0
28702876 //#define arg0 1
28712877 //#define arg1 2
28722878 //#define arg2 3
2873- label = 178LLU; // skip deleter
2879+ label = 179LLU; // skip deleter
28742880 break;
28752881 }
2876- case 177LLU: // deleter
2882+ case 178LLU: // deleter
28772883 {
28782884 // throw from isident
28792885 if(!stack[base + 4])
28802886 {
28812887 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2882- label = 176LLU; // skip, variable already deleted/unscoped
2888+ label = 177LLU; // skip, variable already deleted/unscoped
28832889 break;
28842890 }
28852891 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2886- label = 176LLU; // continue unrolling stack, delete next variable
2892+ label = 177LLU; // continue unrolling stack, delete next variable
28872893 break;
28882894 }
2889- case 178LLU: // skipped deleter
2895+ case 179LLU: // skipped deleter
28902896 {
28912897 stack[base + 4] = 0;
28922898 // call equ from isident
2893- stack[base + 5LLU] = 179LLU/*throw to this address*/;
2899+ stack[base + 5LLU] = 180LLU/*throw to this address*/;
28942900 stack[base + 6LLU] = base;
2895- stack[base + 7LLU] = 180LLU;
2901+ stack[base + 7LLU] = 181LLU;
28962902 // arguments for call to equ
28972903 stack[base + 9LLU] = stack[base + 1]/*variant*/;
28982904 stack[base + 10LLU] = 4LLU;
@@ -2901,14 +2907,14 @@
29012907 label = 18446744073709551600LLU; // equ
29022908 break;
29032909 }
2904- case 179LLU: // copy-back deleter (equ to isident)
2910+ case 180LLU: // copy-back deleter (equ to isident)
29052911 {
29062912 fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
29072913 // copy mutable arguments back from call to equ
2908- label = 177LLU; // continue to roll stack
2914+ label = 178LLU; // continue to roll stack
29092915 break;
29102916 }
2911- case 180LLU: // return from equ to isident
2917+ case 181LLU: // return from equ to isident
29122918 {
29132919 // copy mutable arguments back from call to equ
29142920 // copy back results provided by call to equ
@@ -2915,15 +2921,15 @@
29152921 stack[base + 4] = stack[base + 8LLU];
29162922 if(!stack[base + 4]/*isequal*/)
29172923 {
2918- label = 181LLU; // jump to alternative
2924+ label = 182LLU; // jump to alternative
29192925 break;
29202926 }
29212927
29222928 // consequent
29232929 // call equ from isident
2924- stack[base + 5LLU] = 183LLU/*throw to this address*/;
2930+ stack[base + 5LLU] = 184LLU/*throw to this address*/;
29252931 stack[base + 6LLU] = base;
2926- stack[base + 7LLU] = 184LLU;
2932+ stack[base + 7LLU] = 185LLU;
29272933 // arguments for call to equ
29282934 stack[base + 9LLU] = stack[base + 3]/*ident*/;
29292935 stack[base + 10LLU] = stack[base + 2]/*content*/;
@@ -2932,14 +2938,14 @@
29322938 label = 18446744073709551600LLU; // equ
29332939 break;
29342940 }
2935- case 183LLU: // copy-back deleter (equ to isident)
2941+ case 184LLU: // copy-back deleter (equ to isident)
29362942 {
29372943 fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
29382944 // copy mutable arguments back from call to equ
2939- label = 177LLU; // continue to roll stack
2945+ label = 178LLU; // continue to roll stack
29402946 break;
29412947 }
2942- case 184LLU: // return from equ to isident
2948+ case 185LLU: // return from equ to isident
29432949 {
29442950 // copy mutable arguments back from call to equ
29452951 // copy back results provided by call to equ
@@ -2946,87 +2952,87 @@
29462952 stack[base + 4] = stack[base + 8LLU];
29472953 if(!stack[base + 4]/*isequal*/)
29482954 {
2949- label = 185LLU; // jump to alternative
2955+ label = 186LLU; // jump to alternative
29502956 break;
29512957 }
29522958
29532959 // consequent
2954- label = 188LLU; // skip deleter
2960+ label = 189LLU; // skip deleter
29552961 break;
29562962 }
2957- case 187LLU: // deleter
2963+ case 188LLU: // deleter
29582964 {
29592965 // throw from isident
29602966 if(!stack[base + 0])
29612967 {
29622968 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2963- label = 177LLU; // skip, variable already deleted/unscoped
2969+ label = 178LLU; // skip, variable already deleted/unscoped
29642970 break;
29652971 }
29662972 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2967- label = 177LLU; // continue unrolling stack, delete next variable
2973+ label = 178LLU; // continue unrolling stack, delete next variable
29682974 break;
29692975 }
2970- case 188LLU: // skipped deleter
2976+ case 189LLU: // skipped deleter
29712977 {
29722978 stack[base + 0] = 1;
2973- label = 186LLU; // consequent complete
2979+ label = 187LLU; // consequent complete
29742980 break;
29752981 }
2976- case 185LLU: // alternative
2982+ case 186LLU: // alternative
29772983 {
2978- label = 190LLU; // skip deleter
2984+ label = 191LLU; // skip deleter
29792985 break;
29802986 }
2981- case 189LLU: // deleter
2987+ case 190LLU: // deleter
29822988 {
29832989 // throw from isident
29842990 if(!stack[base + 0])
29852991 {
29862992 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
2987- label = 177LLU; // skip, variable already deleted/unscoped
2993+ label = 178LLU; // skip, variable already deleted/unscoped
29882994 break;
29892995 }
29902996 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
2991- label = 177LLU; // continue unrolling stack, delete next variable
2997+ label = 178LLU; // continue unrolling stack, delete next variable
29922998 break;
29932999 }
2994- case 190LLU: // skipped deleter
3000+ case 191LLU: // skipped deleter
29953001 {
29963002 stack[base + 0] = 0;
2997- label = 186LLU; // alternative complete
3003+ label = 187LLU; // alternative complete
29983004 break;
29993005 }
3000- case 186LLU: // completed if-then-else
3006+ case 187LLU: // completed if-then-else
30013007 {
3002- label = 182LLU; // consequent complete
3008+ label = 183LLU; // consequent complete
30033009 break;
30043010 }
3005- case 181LLU: // alternative
3011+ case 182LLU: // alternative
30063012 {
3007- label = 192LLU; // skip deleter
3013+ label = 193LLU; // skip deleter
30083014 break;
30093015 }
3010- case 191LLU: // deleter
3016+ case 192LLU: // deleter
30113017 {
30123018 // throw from isident
30133019 if(!stack[base + 0])
30143020 {
30153021 fprintf(stderr, "in function isident: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3016- label = 177LLU; // skip, variable already deleted/unscoped
3022+ label = 178LLU; // skip, variable already deleted/unscoped
30173023 break;
30183024 }
30193025 fprintf(stderr, "in function isident: unrolling stack, variable u64 \n");
3020- label = 177LLU; // continue unrolling stack, delete next variable
3026+ label = 178LLU; // continue unrolling stack, delete next variable
30213027 break;
30223028 }
3023- case 192LLU: // skipped deleter
3029+ case 193LLU: // skipped deleter
30243030 {
30253031 stack[base + 0] = 0;
3026- label = 182LLU; // alternative complete
3032+ label = 183LLU; // alternative complete
30273033 break;
30283034 }
3029- case 182LLU: // completed if-then-else
3035+ case 183LLU: // completed if-then-else
30303036 {
30313037 // return from isident
30323038 label = stack[base - 1];
@@ -3033,7 +3039,7 @@
30333039 base = stack[base - 2];
30343040 break;
30353041 }
3036- case 194LLU: // function iseos failed
3042+ case 195LLU: // function iseos failed
30373043 {
30383044 fprintf(stderr, "function iseos failed\n");
30393045 label = stack[base - 3];
@@ -3040,14 +3046,14 @@
30403046 base = stack[base - 2];
30413047 break;
30423048 }
3043- case 193LLU: // iseos
3049+ case 194LLU: // iseos
30443050 {
30453051 //#define res0 0
30463052 //#define arg0 1
30473053 // call equ from iseos
3048- stack[base + 2LLU] = 195LLU/*throw to this address*/;
3054+ stack[base + 2LLU] = 196LLU/*throw to this address*/;
30493055 stack[base + 3LLU] = base;
3050- stack[base + 4LLU] = 196LLU;
3056+ stack[base + 4LLU] = 197LLU;
30513057 // arguments for call to equ
30523058 stack[base + 6LLU] = stack[base + 1]/*variantnr*/;
30533059 stack[base + 7LLU] = 5LLU;
@@ -3056,14 +3062,14 @@
30563062 label = 18446744073709551600LLU; // equ
30573063 break;
30583064 }
3059- case 195LLU: // copy-back deleter (equ to iseos)
3065+ case 196LLU: // copy-back deleter (equ to iseos)
30603066 {
30613067 fprintf(stderr, "in function iseos: unrolling stack, copy-back (equ to iseos)\n");
30623068 // copy mutable arguments back from call to equ
3063- label = 194LLU; // continue to roll stack
3069+ label = 195LLU; // continue to roll stack
30643070 break;
30653071 }
3066- case 196LLU: // return from equ to iseos
3072+ case 197LLU: // return from equ to iseos
30673073 {
30683074 // copy mutable arguments back from call to equ
30693075 // copy back results provided by call to equ
@@ -3073,7 +3079,7 @@
30733079 base = stack[base - 2];
30743080 break;
30753081 }
3076- case 198LLU: // function MATCHPEEK failed
3082+ case 199LLU: // function MATCHPEEK failed
30773083 {
30783084 fprintf(stderr, "function MATCHPEEK failed\n");
30793085 label = stack[base - 3];
@@ -3080,15 +3086,15 @@
30803086 base = stack[base - 2];
30813087 break;
30823088 }
3083- case 197LLU: // MATCHPEEK
3089+ case 198LLU: // MATCHPEEK
30843090 {
30853091 //#define arg0 0
30863092 //#define arg1 1
30873093 //#define arg2 2
30883094 // call skipwscmnt from MATCHPEEK
3089- stack[base + 3LLU] = 199LLU/*throw to this address*/;
3095+ stack[base + 3LLU] = 200LLU/*throw to this address*/;
30903096 stack[base + 4LLU] = base;
3091- stack[base + 5LLU] = 200LLU;
3097+ stack[base + 5LLU] = 201LLU;
30923098 // arguments for call to skipwscmnt
30933099 stack[base + 7LLU] = stack[base + 2]/*lookahead*/;
30943100 // set stack-base & callee-address
@@ -3096,22 +3102,22 @@
30963102 label = 18446744073709551580LLU; // skipwscmnt
30973103 break;
30983104 }
3099- case 199LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
3105+ case 200LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
31003106 {
31013107 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (skipwscmnt to MATCHPEEK)\n");
31023108 // copy mutable arguments back from call to skipwscmnt
3103- label = 198LLU; // continue to roll stack
3109+ label = 199LLU; // continue to roll stack
31043110 break;
31053111 }
3106- case 200LLU: // return from skipwscmnt to MATCHPEEK
3112+ case 201LLU: // return from skipwscmnt to MATCHPEEK
31073113 {
31083114 // copy mutable arguments back from call to skipwscmnt
31093115 // copy back results provided by call to skipwscmnt
31103116 stack[base + 2] = stack[base + 6LLU];
31113117 // call equ from MATCHPEEK
3112- stack[base + 4LLU] = 201LLU/*throw to this address*/;
3118+ stack[base + 4LLU] = 202LLU/*throw to this address*/;
31133119 stack[base + 5LLU] = base;
3114- stack[base + 6LLU] = 202LLU;
3120+ stack[base + 6LLU] = 203LLU;
31153121 // arguments for call to equ
31163122 stack[base + 8LLU] = stack[base + 2]/*lookahead*/;
31173123 stack[base + 9LLU] = stack[base + 1]/*sym*/;
@@ -3120,14 +3126,14 @@
31203126 label = 18446744073709551600LLU; // equ
31213127 break;
31223128 }
3123- case 201LLU: // copy-back deleter (equ to MATCHPEEK)
3129+ case 202LLU: // copy-back deleter (equ to MATCHPEEK)
31243130 {
31253131 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (equ to MATCHPEEK)\n");
31263132 // copy mutable arguments back from call to equ
3127- label = 198LLU; // continue to roll stack
3133+ label = 199LLU; // continue to roll stack
31283134 break;
31293135 }
3130- case 202LLU: // return from equ to MATCHPEEK
3136+ case 203LLU: // return from equ to MATCHPEEK
31313137 {
31323138 // copy mutable arguments back from call to equ
31333139 // copy back results provided by call to equ
@@ -3134,21 +3140,21 @@
31343140 stack[base + 3] = stack[base + 7LLU];
31353141 if(!stack[base + 3]/*isqual*/)
31363142 {
3137- label = 203LLU; // jump to alternative
3143+ label = 204LLU; // jump to alternative
31383144 break;
31393145 }
31403146
31413147 // consequent
3142- label = 204LLU; // consequent complete
3148+ label = 205LLU; // consequent complete
31433149 break;
31443150 }
3145- case 203LLU: // alternative
3151+ case 204LLU: // alternative
31463152 {
31473153 fprintf(stderr, "%s", "in function ");
31483154 // call reportid from MATCHPEEK
3149- stack[base + 4LLU] = 205LLU/*throw to this address*/;
3155+ stack[base + 4LLU] = 206LLU/*throw to this address*/;
31503156 stack[base + 5LLU] = base;
3151- stack[base + 6LLU] = 206LLU;
3157+ stack[base + 6LLU] = 207LLU;
31523158 // arguments for call to reportid
31533159 stack[base + 7LLU] = stack[base + 0]/*fnid*/;
31543160 // set stack-base & callee-address
@@ -3156,22 +3162,22 @@
31563162 label = 18446744073709551586LLU; // reportid
31573163 break;
31583164 }
3159- case 205LLU: // copy-back deleter (reportid to MATCHPEEK)
3165+ case 206LLU: // copy-back deleter (reportid to MATCHPEEK)
31603166 {
31613167 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportid to MATCHPEEK)\n");
31623168 // copy mutable arguments back from call to reportid
3163- label = 198LLU; // continue to roll stack
3169+ label = 199LLU; // continue to roll stack
31643170 break;
31653171 }
3166- case 206LLU: // return from reportid to MATCHPEEK
3172+ case 207LLU: // return from reportid to MATCHPEEK
31673173 {
31683174 // copy mutable arguments back from call to reportid
31693175 fprintf(stderr, "%s", ": ");
31703176 fprintf(stderr, "%s", "expected '");
31713177 // call reportbyte from MATCHPEEK
3172- stack[base + 4LLU] = 207LLU/*throw to this address*/;
3178+ stack[base + 4LLU] = 208LLU/*throw to this address*/;
31733179 stack[base + 5LLU] = base;
3174- stack[base + 6LLU] = 208LLU;
3180+ stack[base + 6LLU] = 209LLU;
31753181 // arguments for call to reportbyte
31763182 stack[base + 7LLU] = stack[base + 1]/*sym*/;
31773183 // set stack-base & callee-address
@@ -3179,21 +3185,21 @@
31793185 label = 18446744073709551591LLU; // reportbyte
31803186 break;
31813187 }
3182- case 207LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3188+ case 208LLU: // copy-back deleter (reportbyte to MATCHPEEK)
31833189 {
31843190 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
31853191 // copy mutable arguments back from call to reportbyte
3186- label = 198LLU; // continue to roll stack
3192+ label = 199LLU; // continue to roll stack
31873193 break;
31883194 }
3189- case 208LLU: // return from reportbyte to MATCHPEEK
3195+ case 209LLU: // return from reportbyte to MATCHPEEK
31903196 {
31913197 // copy mutable arguments back from call to reportbyte
31923198 fprintf(stderr, "%s", "' but found token ");
31933199 // call reportbyte from MATCHPEEK
3194- stack[base + 4LLU] = 209LLU/*throw to this address*/;
3200+ stack[base + 4LLU] = 210LLU/*throw to this address*/;
31953201 stack[base + 5LLU] = base;
3196- stack[base + 6LLU] = 210LLU;
3202+ stack[base + 6LLU] = 211LLU;
31973203 // arguments for call to reportbyte
31983204 stack[base + 7LLU] = stack[base + 2]/*lookahead*/;
31993205 // set stack-base & callee-address
@@ -3201,22 +3207,22 @@
32013207 label = 18446744073709551591LLU; // reportbyte
32023208 break;
32033209 }
3204- case 209LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3210+ case 210LLU: // copy-back deleter (reportbyte to MATCHPEEK)
32053211 {
32063212 fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
32073213 // copy mutable arguments back from call to reportbyte
3208- label = 198LLU; // continue to roll stack
3214+ label = 199LLU; // continue to roll stack
32093215 break;
32103216 }
3211- case 210LLU: // return from reportbyte to MATCHPEEK
3217+ case 211LLU: // return from reportbyte to MATCHPEEK
32123218 {
32133219 // copy mutable arguments back from call to reportbyte
32143220 fprintf(stderr, "%s", "\n");
32153221 exit(-1);
3216- label = 204LLU; // alternative complete
3222+ label = 205LLU; // alternative complete
32173223 break;
32183224 }
3219- case 204LLU: // completed if-then-else
3225+ case 205LLU: // completed if-then-else
32203226 {
32213227 // return from MATCHPEEK
32223228 label = stack[base - 1];
@@ -3223,7 +3229,7 @@
32233229 base = stack[base - 2];
32243230 break;
32253231 }
3226- case 212LLU: // function matchsym failed
3232+ case 213LLU: // function matchsym failed
32273233 {
32283234 fprintf(stderr, "function matchsym failed\n");
32293235 label = stack[base - 3];
@@ -3230,53 +3236,53 @@
32303236 base = stack[base - 2];
32313237 break;
32323238 }
3233- case 211LLU: // matchsym
3239+ case 212LLU: // matchsym
32343240 {
32353241 //#define arg0 0
32363242 //#define arg1 1
32373243 //#define arg2 2
3238- label = 214LLU; // skip deleter
3244+ label = 215LLU; // skip deleter
32393245 break;
32403246 }
3241- case 213LLU: // deleter
3247+ case 214LLU: // deleter
32423248 {
32433249 // throw from matchsym
32443250 if(!stack[base + 3])
32453251 {
32463252 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3247- label = 212LLU; // skip, variable already deleted/unscoped
3253+ label = 213LLU; // skip, variable already deleted/unscoped
32483254 break;
32493255 }
32503256 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3251- label = 212LLU; // continue unrolling stack, delete next variable
3257+ label = 213LLU; // continue unrolling stack, delete next variable
32523258 break;
32533259 }
3254- case 214LLU: // skipped deleter
3260+ case 215LLU: // skipped deleter
32553261 {
32563262 stack[base + 3] = 0;
3257- label = 216LLU; // skip deleter
3263+ label = 217LLU; // skip deleter
32583264 break;
32593265 }
3260- case 215LLU: // deleter
3266+ case 216LLU: // deleter
32613267 {
32623268 // throw from matchsym
32633269 if(!stack[base + 4])
32643270 {
32653271 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3266- label = 213LLU; // skip, variable already deleted/unscoped
3272+ label = 214LLU; // skip, variable already deleted/unscoped
32673273 break;
32683274 }
32693275 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3270- label = 213LLU; // continue unrolling stack, delete next variable
3276+ label = 214LLU; // continue unrolling stack, delete next variable
32713277 break;
32723278 }
3273- case 216LLU: // skipped deleter
3279+ case 217LLU: // skipped deleter
32743280 {
32753281 stack[base + 4] = 0;
32763282 // call ParseToken from matchsym
3277- stack[base + 5LLU] = 217LLU/*throw to this address*/;
3283+ stack[base + 5LLU] = 218LLU/*throw to this address*/;
32783284 stack[base + 6LLU] = base;
3279- stack[base + 7LLU] = 218LLU;
3285+ stack[base + 7LLU] = 219LLU;
32803286 // arguments for call to ParseToken
32813287 stack[base + 10LLU] = stack[base + 2]/*lookahead*/;
32823288 // set stack-base & callee-address
@@ -3284,15 +3290,15 @@
32843290 label = 3LLU; // ParseToken
32853291 break;
32863292 }
3287- case 217LLU: // copy-back deleter (ParseToken to matchsym)
3293+ case 218LLU: // copy-back deleter (ParseToken to matchsym)
32883294 {
32893295 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (ParseToken to matchsym)\n");
32903296 // copy mutable arguments back from call to ParseToken
32913297 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
3292- label = 215LLU; // continue to roll stack
3298+ label = 216LLU; // continue to roll stack
32933299 break;
32943300 }
3295- case 218LLU: // return from ParseToken to matchsym
3301+ case 219LLU: // return from ParseToken to matchsym
32963302 {
32973303 // copy mutable arguments back from call to ParseToken
32983304 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
@@ -3299,29 +3305,29 @@
32993305 // copy back results provided by call to ParseToken
33003306 stack[base + 3] = stack[base + 8LLU];
33013307 stack[base + 4] = stack[base + 9LLU];
3302- label = 220LLU; // skip deleter
3308+ label = 221LLU; // skip deleter
33033309 break;
33043310 }
3305- case 219LLU: // deleter
3311+ case 220LLU: // deleter
33063312 {
33073313 // throw from matchsym
33083314 if(!stack[base + 5])
33093315 {
33103316 fprintf(stderr, "in function matchsym: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3311- label = 215LLU; // skip, variable already deleted/unscoped
3317+ label = 216LLU; // skip, variable already deleted/unscoped
33123318 break;
33133319 }
33143320 fprintf(stderr, "in function matchsym: unrolling stack, variable u64 \n");
3315- label = 215LLU; // continue unrolling stack, delete next variable
3321+ label = 216LLU; // continue unrolling stack, delete next variable
33163322 break;
33173323 }
3318- case 220LLU: // skipped deleter
3324+ case 221LLU: // skipped deleter
33193325 {
33203326 stack[base + 5] = 0;
33213327 // call equ from matchsym
3322- stack[base + 6LLU] = 221LLU/*throw to this address*/;
3328+ stack[base + 6LLU] = 222LLU/*throw to this address*/;
33233329 stack[base + 7LLU] = base;
3324- stack[base + 8LLU] = 222LLU;
3330+ stack[base + 8LLU] = 223LLU;
33253331 // arguments for call to equ
33263332 stack[base + 10LLU] = stack[base + 3]/*variant*/;
33273333 stack[base + 11LLU] = 0LLU;
@@ -3330,14 +3336,14 @@
33303336 label = 18446744073709551600LLU; // equ
33313337 break;
33323338 }
3333- case 221LLU: // copy-back deleter (equ to matchsym)
3339+ case 222LLU: // copy-back deleter (equ to matchsym)
33343340 {
33353341 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
33363342 // copy mutable arguments back from call to equ
3337- label = 219LLU; // continue to roll stack
3343+ label = 220LLU; // continue to roll stack
33383344 break;
33393345 }
3340- case 222LLU: // return from equ to matchsym
3346+ case 223LLU: // return from equ to matchsym
33413347 {
33423348 // copy mutable arguments back from call to equ
33433349 // copy back results provided by call to equ
@@ -3344,15 +3350,15 @@
33443350 stack[base + 5] = stack[base + 9LLU];
33453351 if(!stack[base + 5]/*isqual*/)
33463352 {
3347- label = 223LLU; // jump to alternative
3353+ label = 224LLU; // jump to alternative
33483354 break;
33493355 }
33503356
33513357 // consequent
33523358 // call equ from matchsym
3353- stack[base + 6LLU] = 225LLU/*throw to this address*/;
3359+ stack[base + 6LLU] = 226LLU/*throw to this address*/;
33543360 stack[base + 7LLU] = base;
3355- stack[base + 8LLU] = 226LLU;
3361+ stack[base + 8LLU] = 227LLU;
33563362 // arguments for call to equ
33573363 stack[base + 10LLU] = stack[base + 1]/*sym*/;
33583364 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -3361,14 +3367,14 @@
33613367 label = 18446744073709551600LLU; // equ
33623368 break;
33633369 }
3364- case 225LLU: // copy-back deleter (equ to matchsym)
3370+ case 226LLU: // copy-back deleter (equ to matchsym)
33653371 {
33663372 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
33673373 // copy mutable arguments back from call to equ
3368- label = 219LLU; // continue to roll stack
3374+ label = 220LLU; // continue to roll stack
33693375 break;
33703376 }
3371- case 226LLU: // return from equ to matchsym
3377+ case 227LLU: // return from equ to matchsym
33723378 {
33733379 // copy mutable arguments back from call to equ
33743380 // copy back results provided by call to equ
@@ -3375,21 +3381,21 @@
33753381 stack[base + 5] = stack[base + 9LLU];
33763382 if(!stack[base + 5]/*isqual*/)
33773383 {
3378- label = 227LLU; // jump to alternative
3384+ label = 228LLU; // jump to alternative
33793385 break;
33803386 }
33813387
33823388 // consequent
3383- label = 228LLU; // consequent complete
3389+ label = 229LLU; // consequent complete
33843390 break;
33853391 }
3386- case 227LLU: // alternative
3392+ case 228LLU: // alternative
33873393 {
33883394 fprintf(stderr, "%s", "in function ");
33893395 // call reportid from matchsym
3390- stack[base + 6LLU] = 229LLU/*throw to this address*/;
3396+ stack[base + 6LLU] = 230LLU/*throw to this address*/;
33913397 stack[base + 7LLU] = base;
3392- stack[base + 8LLU] = 230LLU;
3398+ stack[base + 8LLU] = 231LLU;
33933399 // arguments for call to reportid
33943400 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
33953401 // set stack-base & callee-address
@@ -3397,22 +3403,22 @@
33973403 label = 18446744073709551586LLU; // reportid
33983404 break;
33993405 }
3400- case 229LLU: // copy-back deleter (reportid to matchsym)
3406+ case 230LLU: // copy-back deleter (reportid to matchsym)
34013407 {
34023408 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
34033409 // copy mutable arguments back from call to reportid
3404- label = 219LLU; // continue to roll stack
3410+ label = 220LLU; // continue to roll stack
34053411 break;
34063412 }
3407- case 230LLU: // return from reportid to matchsym
3413+ case 231LLU: // return from reportid to matchsym
34083414 {
34093415 // copy mutable arguments back from call to reportid
34103416 fprintf(stderr, "%s", ": ");
34113417 fprintf(stderr, "%s", "expected '");
34123418 // call reportbyte from matchsym
3413- stack[base + 6LLU] = 231LLU/*throw to this address*/;
3419+ stack[base + 6LLU] = 232LLU/*throw to this address*/;
34143420 stack[base + 7LLU] = base;
3415- stack[base + 8LLU] = 232LLU;
3421+ stack[base + 8LLU] = 233LLU;
34163422 // arguments for call to reportbyte
34173423 stack[base + 9LLU] = stack[base + 1]/*sym*/;
34183424 // set stack-base & callee-address
@@ -3420,21 +3426,21 @@
34203426 label = 18446744073709551591LLU; // reportbyte
34213427 break;
34223428 }
3423- case 231LLU: // copy-back deleter (reportbyte to matchsym)
3429+ case 232LLU: // copy-back deleter (reportbyte to matchsym)
34243430 {
34253431 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
34263432 // copy mutable arguments back from call to reportbyte
3427- label = 219LLU; // continue to roll stack
3433+ label = 220LLU; // continue to roll stack
34283434 break;
34293435 }
3430- case 232LLU: // return from reportbyte to matchsym
3436+ case 233LLU: // return from reportbyte to matchsym
34313437 {
34323438 // copy mutable arguments back from call to reportbyte
34333439 fprintf(stderr, "%s", "' but found token ");
34343440 // call reporttok from matchsym
3435- stack[base + 6LLU] = 233LLU/*throw to this address*/;
3441+ stack[base + 6LLU] = 234LLU/*throw to this address*/;
34363442 stack[base + 7LLU] = base;
3437- stack[base + 8LLU] = 234LLU;
3443+ stack[base + 8LLU] = 235LLU;
34383444 // arguments for call to reporttok
34393445 stack[base + 9LLU] = stack[base + 3]/*variant*/;
34403446 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3443,33 +3449,33 @@
34433449 label = 18446744073709551582LLU; // reporttok
34443450 break;
34453451 }
3446- case 233LLU: // copy-back deleter (reporttok to matchsym)
3452+ case 234LLU: // copy-back deleter (reporttok to matchsym)
34473453 {
34483454 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
34493455 // copy mutable arguments back from call to reporttok
3450- label = 219LLU; // continue to roll stack
3456+ label = 220LLU; // continue to roll stack
34513457 break;
34523458 }
3453- case 234LLU: // return from reporttok to matchsym
3459+ case 235LLU: // return from reporttok to matchsym
34543460 {
34553461 // copy mutable arguments back from call to reporttok
34563462 fprintf(stderr, "%s", "\n");
34573463 exit(-1);
3458- label = 228LLU; // alternative complete
3464+ label = 229LLU; // alternative complete
34593465 break;
34603466 }
3461- case 228LLU: // completed if-then-else
3467+ case 229LLU: // completed if-then-else
34623468 {
3463- label = 224LLU; // consequent complete
3469+ label = 225LLU; // consequent complete
34643470 break;
34653471 }
3466- case 223LLU: // alternative
3472+ case 224LLU: // alternative
34673473 {
34683474 fprintf(stderr, "%s", "in function ");
34693475 // call reportid from matchsym
3470- stack[base + 6LLU] = 235LLU/*throw to this address*/;
3476+ stack[base + 6LLU] = 236LLU/*throw to this address*/;
34713477 stack[base + 7LLU] = base;
3472- stack[base + 8LLU] = 236LLU;
3478+ stack[base + 8LLU] = 237LLU;
34733479 // arguments for call to reportid
34743480 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
34753481 // set stack-base & callee-address
@@ -3477,22 +3483,22 @@
34773483 label = 18446744073709551586LLU; // reportid
34783484 break;
34793485 }
3480- case 235LLU: // copy-back deleter (reportid to matchsym)
3486+ case 236LLU: // copy-back deleter (reportid to matchsym)
34813487 {
34823488 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
34833489 // copy mutable arguments back from call to reportid
3484- label = 219LLU; // continue to roll stack
3490+ label = 220LLU; // continue to roll stack
34853491 break;
34863492 }
3487- case 236LLU: // return from reportid to matchsym
3493+ case 237LLU: // return from reportid to matchsym
34883494 {
34893495 // copy mutable arguments back from call to reportid
34903496 fprintf(stderr, "%s", ": ");
34913497 fprintf(stderr, "%s", "expected '");
34923498 // call reportbyte from matchsym
3493- stack[base + 6LLU] = 237LLU/*throw to this address*/;
3499+ stack[base + 6LLU] = 238LLU/*throw to this address*/;
34943500 stack[base + 7LLU] = base;
3495- stack[base + 8LLU] = 238LLU;
3501+ stack[base + 8LLU] = 239LLU;
34963502 // arguments for call to reportbyte
34973503 stack[base + 9LLU] = stack[base + 1]/*sym*/;
34983504 // set stack-base & callee-address
@@ -3500,21 +3506,21 @@
35003506 label = 18446744073709551591LLU; // reportbyte
35013507 break;
35023508 }
3503- case 237LLU: // copy-back deleter (reportbyte to matchsym)
3509+ case 238LLU: // copy-back deleter (reportbyte to matchsym)
35043510 {
35053511 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
35063512 // copy mutable arguments back from call to reportbyte
3507- label = 219LLU; // continue to roll stack
3513+ label = 220LLU; // continue to roll stack
35083514 break;
35093515 }
3510- case 238LLU: // return from reportbyte to matchsym
3516+ case 239LLU: // return from reportbyte to matchsym
35113517 {
35123518 // copy mutable arguments back from call to reportbyte
35133519 fprintf(stderr, "%s", "' but found token ");
35143520 // call reporttok from matchsym
3515- stack[base + 6LLU] = 239LLU/*throw to this address*/;
3521+ stack[base + 6LLU] = 240LLU/*throw to this address*/;
35163522 stack[base + 7LLU] = base;
3517- stack[base + 8LLU] = 240LLU;
3523+ stack[base + 8LLU] = 241LLU;
35183524 // arguments for call to reporttok
35193525 stack[base + 9LLU] = stack[base + 3]/*variant*/;
35203526 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3523,22 +3529,22 @@
35233529 label = 18446744073709551582LLU; // reporttok
35243530 break;
35253531 }
3526- case 239LLU: // copy-back deleter (reporttok to matchsym)
3532+ case 240LLU: // copy-back deleter (reporttok to matchsym)
35273533 {
35283534 fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
35293535 // copy mutable arguments back from call to reporttok
3530- label = 219LLU; // continue to roll stack
3536+ label = 220LLU; // continue to roll stack
35313537 break;
35323538 }
3533- case 240LLU: // return from reporttok to matchsym
3539+ case 241LLU: // return from reporttok to matchsym
35343540 {
35353541 // copy mutable arguments back from call to reporttok
35363542 fprintf(stderr, "%s", "\n");
35373543 exit(-1);
3538- label = 224LLU; // alternative complete
3544+ label = 225LLU; // alternative complete
35393545 break;
35403546 }
3541- case 224LLU: // completed if-then-else
3547+ case 225LLU: // completed if-then-else
35423548 {
35433549 // return from matchsym
35443550 label = stack[base - 1];
@@ -3545,7 +3551,7 @@
35453551 base = stack[base - 2];
35463552 break;
35473553 }
3548- case 242LLU: // function matchid failed
3554+ case 243LLU: // function matchid failed
35493555 {
35503556 fprintf(stderr, "function matchid failed\n");
35513557 label = stack[base - 3];
@@ -3552,53 +3558,53 @@
35523558 base = stack[base - 2];
35533559 break;
35543560 }
3555- case 241LLU: // matchid
3561+ case 242LLU: // matchid
35563562 {
35573563 //#define arg0 0
35583564 //#define arg1 1
35593565 //#define arg2 2
3560- label = 244LLU; // skip deleter
3566+ label = 245LLU; // skip deleter
35613567 break;
35623568 }
3563- case 243LLU: // deleter
3569+ case 244LLU: // deleter
35643570 {
35653571 // throw from matchid
35663572 if(!stack[base + 3])
35673573 {
35683574 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3569- label = 242LLU; // skip, variable already deleted/unscoped
3575+ label = 243LLU; // skip, variable already deleted/unscoped
35703576 break;
35713577 }
35723578 fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3573- label = 242LLU; // continue unrolling stack, delete next variable
3579+ label = 243LLU; // continue unrolling stack, delete next variable
35743580 break;
35753581 }
3576- case 244LLU: // skipped deleter
3582+ case 245LLU: // skipped deleter
35773583 {
35783584 stack[base + 3] = 0;
3579- label = 246LLU; // skip deleter
3585+ label = 247LLU; // skip deleter
35803586 break;
35813587 }
3582- case 245LLU: // deleter
3588+ case 246LLU: // deleter
35833589 {
35843590 // throw from matchid
35853591 if(!stack[base + 4])
35863592 {
35873593 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3588- label = 243LLU; // skip, variable already deleted/unscoped
3594+ label = 244LLU; // skip, variable already deleted/unscoped
35893595 break;
35903596 }
35913597 fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3592- label = 243LLU; // continue unrolling stack, delete next variable
3598+ label = 244LLU; // continue unrolling stack, delete next variable
35933599 break;
35943600 }
3595- case 246LLU: // skipped deleter
3601+ case 247LLU: // skipped deleter
35963602 {
35973603 stack[base + 4] = 0;
35983604 // call ParseToken from matchid
3599- stack[base + 5LLU] = 247LLU/*throw to this address*/;
3605+ stack[base + 5LLU] = 248LLU/*throw to this address*/;
36003606 stack[base + 6LLU] = base;
3601- stack[base + 7LLU] = 248LLU;
3607+ stack[base + 7LLU] = 249LLU;
36023608 // arguments for call to ParseToken
36033609 stack[base + 10LLU] = stack[base + 2]/*lookahead*/;
36043610 // set stack-base & callee-address
@@ -3606,15 +3612,15 @@
36063612 label = 3LLU; // ParseToken
36073613 break;
36083614 }
3609- case 247LLU: // copy-back deleter (ParseToken to matchid)
3615+ case 248LLU: // copy-back deleter (ParseToken to matchid)
36103616 {
36113617 fprintf(stderr, "in function matchid: unrolling stack, copy-back (ParseToken to matchid)\n");
36123618 // copy mutable arguments back from call to ParseToken
36133619 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
3614- label = 245LLU; // continue to roll stack
3620+ label = 246LLU; // continue to roll stack
36153621 break;
36163622 }
3617- case 248LLU: // return from ParseToken to matchid
3623+ case 249LLU: // return from ParseToken to matchid
36183624 {
36193625 // copy mutable arguments back from call to ParseToken
36203626 stack[base + 2]/*lookahead*/ = stack[base + 10LLU];
@@ -3621,29 +3627,29 @@
36213627 // copy back results provided by call to ParseToken
36223628 stack[base + 3] = stack[base + 8LLU];
36233629 stack[base + 4] = stack[base + 9LLU];
3624- label = 250LLU; // skip deleter
3630+ label = 251LLU; // skip deleter
36253631 break;
36263632 }
3627- case 249LLU: // deleter
3633+ case 250LLU: // deleter
36283634 {
36293635 // throw from matchid
36303636 if(!stack[base + 5])
36313637 {
36323638 fprintf(stderr, "in function matchid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3633- label = 245LLU; // skip, variable already deleted/unscoped
3639+ label = 246LLU; // skip, variable already deleted/unscoped
36343640 break;
36353641 }
36363642 fprintf(stderr, "in function matchid: unrolling stack, variable u64 \n");
3637- label = 245LLU; // continue unrolling stack, delete next variable
3643+ label = 246LLU; // continue unrolling stack, delete next variable
36383644 break;
36393645 }
3640- case 250LLU: // skipped deleter
3646+ case 251LLU: // skipped deleter
36413647 {
36423648 stack[base + 5] = 0;
36433649 // call equ from matchid
3644- stack[base + 6LLU] = 251LLU/*throw to this address*/;
3650+ stack[base + 6LLU] = 252LLU/*throw to this address*/;
36453651 stack[base + 7LLU] = base;
3646- stack[base + 8LLU] = 252LLU;
3652+ stack[base + 8LLU] = 253LLU;
36473653 // arguments for call to equ
36483654 stack[base + 10LLU] = stack[base + 3]/*variant*/;
36493655 stack[base + 11LLU] = 4LLU;
@@ -3652,14 +3658,14 @@
36523658 label = 18446744073709551600LLU; // equ
36533659 break;
36543660 }
3655- case 251LLU: // copy-back deleter (equ to matchid)
3661+ case 252LLU: // copy-back deleter (equ to matchid)
36563662 {
36573663 fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
36583664 // copy mutable arguments back from call to equ
3659- label = 249LLU; // continue to roll stack
3665+ label = 250LLU; // continue to roll stack
36603666 break;
36613667 }
3662- case 252LLU: // return from equ to matchid
3668+ case 253LLU: // return from equ to matchid
36633669 {
36643670 // copy mutable arguments back from call to equ
36653671 // copy back results provided by call to equ
@@ -3666,15 +3672,15 @@
36663672 stack[base + 5] = stack[base + 9LLU];
36673673 if(!stack[base + 5]/*isqual*/)
36683674 {
3669- label = 253LLU; // jump to alternative
3675+ label = 254LLU; // jump to alternative
36703676 break;
36713677 }
36723678
36733679 // consequent
36743680 // call equ from matchid
3675- stack[base + 6LLU] = 255LLU/*throw to this address*/;
3681+ stack[base + 6LLU] = 256LLU/*throw to this address*/;
36763682 stack[base + 7LLU] = base;
3677- stack[base + 8LLU] = 256LLU;
3683+ stack[base + 8LLU] = 257LLU;
36783684 // arguments for call to equ
36793685 stack[base + 10LLU] = stack[base + 1]/*id*/;
36803686 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -3683,14 +3689,14 @@
36833689 label = 18446744073709551600LLU; // equ
36843690 break;
36853691 }
3686- case 255LLU: // copy-back deleter (equ to matchid)
3692+ case 256LLU: // copy-back deleter (equ to matchid)
36873693 {
36883694 fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
36893695 // copy mutable arguments back from call to equ
3690- label = 249LLU; // continue to roll stack
3696+ label = 250LLU; // continue to roll stack
36913697 break;
36923698 }
3693- case 256LLU: // return from equ to matchid
3699+ case 257LLU: // return from equ to matchid
36943700 {
36953701 // copy mutable arguments back from call to equ
36963702 // copy back results provided by call to equ
@@ -3697,21 +3703,21 @@
36973703 stack[base + 5] = stack[base + 9LLU];
36983704 if(!stack[base + 5]/*isqual*/)
36993705 {
3700- label = 257LLU; // jump to alternative
3706+ label = 258LLU; // jump to alternative
37013707 break;
37023708 }
37033709
37043710 // consequent
3705- label = 258LLU; // consequent complete
3711+ label = 259LLU; // consequent complete
37063712 break;
37073713 }
3708- case 257LLU: // alternative
3714+ case 258LLU: // alternative
37093715 {
37103716 fprintf(stderr, "%s", "in function ");
37113717 // call reportid from matchid
3712- stack[base + 6LLU] = 259LLU/*throw to this address*/;
3718+ stack[base + 6LLU] = 260LLU/*throw to this address*/;
37133719 stack[base + 7LLU] = base;
3714- stack[base + 8LLU] = 260LLU;
3720+ stack[base + 8LLU] = 261LLU;
37153721 // arguments for call to reportid
37163722 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
37173723 // set stack-base & callee-address
@@ -3719,22 +3725,22 @@
37193725 label = 18446744073709551586LLU; // reportid
37203726 break;
37213727 }
3722- case 259LLU: // copy-back deleter (reportid to matchid)
3728+ case 260LLU: // copy-back deleter (reportid to matchid)
37233729 {
37243730 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
37253731 // copy mutable arguments back from call to reportid
3726- label = 249LLU; // continue to roll stack
3732+ label = 250LLU; // continue to roll stack
37273733 break;
37283734 }
3729- case 260LLU: // return from reportid to matchid
3735+ case 261LLU: // return from reportid to matchid
37303736 {
37313737 // copy mutable arguments back from call to reportid
37323738 fprintf(stderr, "%s", ": ");
37333739 fprintf(stderr, "%s", "expected ");
37343740 // call reportid from matchid
3735- stack[base + 6LLU] = 261LLU/*throw to this address*/;
3741+ stack[base + 6LLU] = 262LLU/*throw to this address*/;
37363742 stack[base + 7LLU] = base;
3737- stack[base + 8LLU] = 262LLU;
3743+ stack[base + 8LLU] = 263LLU;
37383744 // arguments for call to reportid
37393745 stack[base + 9LLU] = stack[base + 1]/*id*/;
37403746 // set stack-base & callee-address
@@ -3742,21 +3748,21 @@
37423748 label = 18446744073709551586LLU; // reportid
37433749 break;
37443750 }
3745- case 261LLU: // copy-back deleter (reportid to matchid)
3751+ case 262LLU: // copy-back deleter (reportid to matchid)
37463752 {
37473753 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
37483754 // copy mutable arguments back from call to reportid
3749- label = 249LLU; // continue to roll stack
3755+ label = 250LLU; // continue to roll stack
37503756 break;
37513757 }
3752- case 262LLU: // return from reportid to matchid
3758+ case 263LLU: // return from reportid to matchid
37533759 {
37543760 // copy mutable arguments back from call to reportid
37553761 fprintf(stderr, "%s", " but found token ");
37563762 // call reporttok from matchid
3757- stack[base + 6LLU] = 263LLU/*throw to this address*/;
3763+ stack[base + 6LLU] = 264LLU/*throw to this address*/;
37583764 stack[base + 7LLU] = base;
3759- stack[base + 8LLU] = 264LLU;
3765+ stack[base + 8LLU] = 265LLU;
37603766 // arguments for call to reporttok
37613767 stack[base + 9LLU] = stack[base + 3]/*variant*/;
37623768 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3765,33 +3771,33 @@
37653771 label = 18446744073709551582LLU; // reporttok
37663772 break;
37673773 }
3768- case 263LLU: // copy-back deleter (reporttok to matchid)
3774+ case 264LLU: // copy-back deleter (reporttok to matchid)
37693775 {
37703776 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
37713777 // copy mutable arguments back from call to reporttok
3772- label = 249LLU; // continue to roll stack
3778+ label = 250LLU; // continue to roll stack
37733779 break;
37743780 }
3775- case 264LLU: // return from reporttok to matchid
3781+ case 265LLU: // return from reporttok to matchid
37763782 {
37773783 // copy mutable arguments back from call to reporttok
37783784 fprintf(stderr, "%s", "\n");
37793785 exit(-1);
3780- label = 258LLU; // alternative complete
3786+ label = 259LLU; // alternative complete
37813787 break;
37823788 }
3783- case 258LLU: // completed if-then-else
3789+ case 259LLU: // completed if-then-else
37843790 {
3785- label = 254LLU; // consequent complete
3791+ label = 255LLU; // consequent complete
37863792 break;
37873793 }
3788- case 253LLU: // alternative
3794+ case 254LLU: // alternative
37893795 {
37903796 fprintf(stderr, "%s", "in function ");
37913797 // call reportid from matchid
3792- stack[base + 6LLU] = 265LLU/*throw to this address*/;
3798+ stack[base + 6LLU] = 266LLU/*throw to this address*/;
37933799 stack[base + 7LLU] = base;
3794- stack[base + 8LLU] = 266LLU;
3800+ stack[base + 8LLU] = 267LLU;
37953801 // arguments for call to reportid
37963802 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
37973803 // set stack-base & callee-address
@@ -3799,22 +3805,22 @@
37993805 label = 18446744073709551586LLU; // reportid
38003806 break;
38013807 }
3802- case 265LLU: // copy-back deleter (reportid to matchid)
3808+ case 266LLU: // copy-back deleter (reportid to matchid)
38033809 {
38043810 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
38053811 // copy mutable arguments back from call to reportid
3806- label = 249LLU; // continue to roll stack
3812+ label = 250LLU; // continue to roll stack
38073813 break;
38083814 }
3809- case 266LLU: // return from reportid to matchid
3815+ case 267LLU: // return from reportid to matchid
38103816 {
38113817 // copy mutable arguments back from call to reportid
38123818 fprintf(stderr, "%s", ": ");
38133819 fprintf(stderr, "%s", "expected ");
38143820 // call reportid from matchid
3815- stack[base + 6LLU] = 267LLU/*throw to this address*/;
3821+ stack[base + 6LLU] = 268LLU/*throw to this address*/;
38163822 stack[base + 7LLU] = base;
3817- stack[base + 8LLU] = 268LLU;
3823+ stack[base + 8LLU] = 269LLU;
38183824 // arguments for call to reportid
38193825 stack[base + 9LLU] = stack[base + 1]/*id*/;
38203826 // set stack-base & callee-address
@@ -3822,21 +3828,21 @@
38223828 label = 18446744073709551586LLU; // reportid
38233829 break;
38243830 }
3825- case 267LLU: // copy-back deleter (reportid to matchid)
3831+ case 268LLU: // copy-back deleter (reportid to matchid)
38263832 {
38273833 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
38283834 // copy mutable arguments back from call to reportid
3829- label = 249LLU; // continue to roll stack
3835+ label = 250LLU; // continue to roll stack
38303836 break;
38313837 }
3832- case 268LLU: // return from reportid to matchid
3838+ case 269LLU: // return from reportid to matchid
38333839 {
38343840 // copy mutable arguments back from call to reportid
38353841 fprintf(stderr, "%s", " but found token ");
38363842 // call reporttok from matchid
3837- stack[base + 6LLU] = 269LLU/*throw to this address*/;
3843+ stack[base + 6LLU] = 270LLU/*throw to this address*/;
38383844 stack[base + 7LLU] = base;
3839- stack[base + 8LLU] = 270LLU;
3845+ stack[base + 8LLU] = 271LLU;
38403846 // arguments for call to reporttok
38413847 stack[base + 9LLU] = stack[base + 3]/*variant*/;
38423848 stack[base + 10LLU] = stack[base + 4]/*content*/;
@@ -3845,22 +3851,22 @@
38453851 label = 18446744073709551582LLU; // reporttok
38463852 break;
38473853 }
3848- case 269LLU: // copy-back deleter (reporttok to matchid)
3854+ case 270LLU: // copy-back deleter (reporttok to matchid)
38493855 {
38503856 fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
38513857 // copy mutable arguments back from call to reporttok
3852- label = 249LLU; // continue to roll stack
3858+ label = 250LLU; // continue to roll stack
38533859 break;
38543860 }
3855- case 270LLU: // return from reporttok to matchid
3861+ case 271LLU: // return from reporttok to matchid
38563862 {
38573863 // copy mutable arguments back from call to reporttok
38583864 fprintf(stderr, "%s", "\n");
38593865 exit(-1);
3860- label = 254LLU; // alternative complete
3866+ label = 255LLU; // alternative complete
38613867 break;
38623868 }
3863- case 254LLU: // completed if-then-else
3869+ case 255LLU: // completed if-then-else
38643870 {
38653871 // return from matchid
38663872 label = stack[base - 1];
@@ -3867,7 +3873,7 @@
38673873 base = stack[base - 2];
38683874 break;
38693875 }
3870- case 272LLU: // function isncs failed
3876+ case 273LLU: // function isncs failed
38713877 {
38723878 fprintf(stderr, "function isncs failed\n");
38733879 label = stack[base - 3];
@@ -3874,33 +3880,33 @@
38743880 base = stack[base - 2];
38753881 break;
38763882 }
3877- case 271LLU: // isncs
3883+ case 272LLU: // isncs
38783884 {
38793885 //#define res0 0
38803886 //#define arg0 1
3881- label = 274LLU; // skip deleter
3887+ label = 275LLU; // skip deleter
38823888 break;
38833889 }
3884- case 273LLU: // deleter
3890+ case 274LLU: // deleter
38853891 {
38863892 // throw from isncs
38873893 if(!stack[base + 2])
38883894 {
38893895 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3890- label = 272LLU; // skip, variable already deleted/unscoped
3896+ label = 273LLU; // skip, variable already deleted/unscoped
38913897 break;
38923898 }
38933899 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
3894- label = 272LLU; // continue unrolling stack, delete next variable
3900+ label = 273LLU; // continue unrolling stack, delete next variable
38953901 break;
38963902 }
3897- case 274LLU: // skipped deleter
3903+ case 275LLU: // skipped deleter
38983904 {
38993905 stack[base + 2] = 0;
39003906 // call equ from isncs
3901- stack[base + 3LLU] = 275LLU/*throw to this address*/;
3907+ stack[base + 3LLU] = 276LLU/*throw to this address*/;
39023908 stack[base + 4LLU] = base;
3903- stack[base + 5LLU] = 276LLU;
3909+ stack[base + 5LLU] = 277LLU;
39043910 // arguments for call to equ
39053911 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
39063912 stack[base + 8LLU] = 1LLU;
@@ -3909,14 +3915,14 @@
39093915 label = 18446744073709551600LLU; // equ
39103916 break;
39113917 }
3912- case 275LLU: // copy-back deleter (equ to isncs)
3918+ case 276LLU: // copy-back deleter (equ to isncs)
39133919 {
39143920 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
39153921 // copy mutable arguments back from call to equ
3916- label = 273LLU; // continue to roll stack
3922+ label = 274LLU; // continue to roll stack
39173923 break;
39183924 }
3919- case 276LLU: // return from equ to isncs
3925+ case 277LLU: // return from equ to isncs
39203926 {
39213927 // copy mutable arguments back from call to equ
39223928 // copy back results provided by call to equ
@@ -3923,39 +3929,39 @@
39233929 stack[base + 2] = stack[base + 6LLU];
39243930 if(!stack[base + 2]/*isequal*/)
39253931 {
3926- label = 277LLU; // jump to alternative
3932+ label = 278LLU; // jump to alternative
39273933 break;
39283934 }
39293935
39303936 // consequent
3931- label = 280LLU; // skip deleter
3937+ label = 281LLU; // skip deleter
39323938 break;
39333939 }
3934- case 279LLU: // deleter
3940+ case 280LLU: // deleter
39353941 {
39363942 // throw from isncs
39373943 if(!stack[base + 0])
39383944 {
39393945 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3940- label = 273LLU; // skip, variable already deleted/unscoped
3946+ label = 274LLU; // skip, variable already deleted/unscoped
39413947 break;
39423948 }
39433949 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
3944- label = 273LLU; // continue unrolling stack, delete next variable
3950+ label = 274LLU; // continue unrolling stack, delete next variable
39453951 break;
39463952 }
3947- case 280LLU: // skipped deleter
3953+ case 281LLU: // skipped deleter
39483954 {
39493955 stack[base + 0] = 1;
3950- label = 278LLU; // consequent complete
3956+ label = 279LLU; // consequent complete
39513957 break;
39523958 }
3953- case 277LLU: // alternative
3959+ case 278LLU: // alternative
39543960 {
39553961 // call equ from isncs
3956- stack[base + 3LLU] = 281LLU/*throw to this address*/;
3962+ stack[base + 3LLU] = 282LLU/*throw to this address*/;
39573963 stack[base + 4LLU] = base;
3958- stack[base + 5LLU] = 282LLU;
3964+ stack[base + 5LLU] = 283LLU;
39593965 // arguments for call to equ
39603966 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
39613967 stack[base + 8LLU] = 2LLU;
@@ -3964,14 +3970,14 @@
39643970 label = 18446744073709551600LLU; // equ
39653971 break;
39663972 }
3967- case 281LLU: // copy-back deleter (equ to isncs)
3973+ case 282LLU: // copy-back deleter (equ to isncs)
39683974 {
39693975 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
39703976 // copy mutable arguments back from call to equ
3971- label = 273LLU; // continue to roll stack
3977+ label = 274LLU; // continue to roll stack
39723978 break;
39733979 }
3974- case 282LLU: // return from equ to isncs
3980+ case 283LLU: // return from equ to isncs
39753981 {
39763982 // copy mutable arguments back from call to equ
39773983 // copy back results provided by call to equ
@@ -3978,39 +3984,39 @@
39783984 stack[base + 2] = stack[base + 6LLU];
39793985 if(!stack[base + 2]/*isequal*/)
39803986 {
3981- label = 283LLU; // jump to alternative
3987+ label = 284LLU; // jump to alternative
39823988 break;
39833989 }
39843990
39853991 // consequent
3986- label = 286LLU; // skip deleter
3992+ label = 287LLU; // skip deleter
39873993 break;
39883994 }
3989- case 285LLU: // deleter
3995+ case 286LLU: // deleter
39903996 {
39913997 // throw from isncs
39923998 if(!stack[base + 0])
39933999 {
39944000 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
3995- label = 273LLU; // skip, variable already deleted/unscoped
4001+ label = 274LLU; // skip, variable already deleted/unscoped
39964002 break;
39974003 }
39984004 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
3999- label = 273LLU; // continue unrolling stack, delete next variable
4005+ label = 274LLU; // continue unrolling stack, delete next variable
40004006 break;
40014007 }
4002- case 286LLU: // skipped deleter
4008+ case 287LLU: // skipped deleter
40034009 {
40044010 stack[base + 0] = 1;
4005- label = 284LLU; // consequent complete
4011+ label = 285LLU; // consequent complete
40064012 break;
40074013 }
4008- case 283LLU: // alternative
4014+ case 284LLU: // alternative
40094015 {
40104016 // call equ from isncs
4011- stack[base + 3LLU] = 287LLU/*throw to this address*/;
4017+ stack[base + 3LLU] = 288LLU/*throw to this address*/;
40124018 stack[base + 4LLU] = base;
4013- stack[base + 5LLU] = 288LLU;
4019+ stack[base + 5LLU] = 289LLU;
40144020 // arguments for call to equ
40154021 stack[base + 7LLU] = stack[base + 1]/*tokvar*/;
40164022 stack[base + 8LLU] = 3LLU;
@@ -4019,14 +4025,14 @@
40194025 label = 18446744073709551600LLU; // equ
40204026 break;
40214027 }
4022- case 287LLU: // copy-back deleter (equ to isncs)
4028+ case 288LLU: // copy-back deleter (equ to isncs)
40234029 {
40244030 fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
40254031 // copy mutable arguments back from call to equ
4026- label = 273LLU; // continue to roll stack
4032+ label = 274LLU; // continue to roll stack
40274033 break;
40284034 }
4029- case 288LLU: // return from equ to isncs
4035+ case 289LLU: // return from equ to isncs
40304036 {
40314037 // copy mutable arguments back from call to equ
40324038 // copy back results provided by call to equ
@@ -4033,68 +4039,68 @@
40334039 stack[base + 2] = stack[base + 6LLU];
40344040 if(!stack[base + 2]/*isequal*/)
40354041 {
4036- label = 289LLU; // jump to alternative
4042+ label = 290LLU; // jump to alternative
40374043 break;
40384044 }
40394045
40404046 // consequent
4041- label = 292LLU; // skip deleter
4047+ label = 293LLU; // skip deleter
40424048 break;
40434049 }
4044- case 291LLU: // deleter
4050+ case 292LLU: // deleter
40454051 {
40464052 // throw from isncs
40474053 if(!stack[base + 0])
40484054 {
40494055 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4050- label = 273LLU; // skip, variable already deleted/unscoped
4056+ label = 274LLU; // skip, variable already deleted/unscoped
40514057 break;
40524058 }
40534059 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
4054- label = 273LLU; // continue unrolling stack, delete next variable
4060+ label = 274LLU; // continue unrolling stack, delete next variable
40554061 break;
40564062 }
4057- case 292LLU: // skipped deleter
4063+ case 293LLU: // skipped deleter
40584064 {
40594065 stack[base + 0] = 1;
4060- label = 290LLU; // consequent complete
4066+ label = 291LLU; // consequent complete
40614067 break;
40624068 }
4063- case 289LLU: // alternative
4069+ case 290LLU: // alternative
40644070 {
4065- label = 294LLU; // skip deleter
4071+ label = 295LLU; // skip deleter
40664072 break;
40674073 }
4068- case 293LLU: // deleter
4074+ case 294LLU: // deleter
40694075 {
40704076 // throw from isncs
40714077 if(!stack[base + 0])
40724078 {
40734079 fprintf(stderr, "in function isncs: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4074- label = 273LLU; // skip, variable already deleted/unscoped
4080+ label = 274LLU; // skip, variable already deleted/unscoped
40754081 break;
40764082 }
40774083 fprintf(stderr, "in function isncs: unrolling stack, variable u64 \n");
4078- label = 273LLU; // continue unrolling stack, delete next variable
4084+ label = 274LLU; // continue unrolling stack, delete next variable
40794085 break;
40804086 }
4081- case 294LLU: // skipped deleter
4087+ case 295LLU: // skipped deleter
40824088 {
40834089 stack[base + 0] = 0;
4084- label = 290LLU; // alternative complete
4090+ label = 291LLU; // alternative complete
40854091 break;
40864092 }
4087- case 290LLU: // completed if-then-else
4093+ case 291LLU: // completed if-then-else
40884094 {
4089- label = 284LLU; // alternative complete
4095+ label = 285LLU; // alternative complete
40904096 break;
40914097 }
4092- case 284LLU: // completed if-then-else
4098+ case 285LLU: // completed if-then-else
40934099 {
4094- label = 278LLU; // alternative complete
4100+ label = 279LLU; // alternative complete
40954101 break;
40964102 }
4097- case 278LLU: // completed if-then-else
4103+ case 279LLU: // completed if-then-else
40984104 {
40994105 // return from isncs
41004106 label = stack[base - 1];
@@ -4101,7 +4107,7 @@
41014107 base = stack[base - 2];
41024108 break;
41034109 }
4104- case 295LLU: // ~type
4110+ case 296LLU: // ~type
41054111 {
41064112 if(stack[base + 0]/*variant-nr*/ >= 2)
41074113 {
@@ -4108,10 +4114,10 @@
41084114 fprintf(stderr, "in ~type: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
41094115 exit(-1);
41104116 }
4111- label = 295LLU + 1LLU + stack[base + 0]/*variant-nr*/;
4117+ label = 296LLU + 1LLU + stack[base + 0]/*variant-nr*/;
41124118 break;
41134119 }
4114- case 295LLU + 1LLU + 0LLU: // ~type.typename
4120+ case 296LLU + 1LLU + 0LLU: // ~type.typename
41154121 {
41164122 // release element name
41174123 // release variant container
@@ -4120,7 +4126,7 @@
41204126 base = stack[base - 2];
41214127 break;
41224128 }
4123- case 295LLU + 1LLU + 1LLU: // ~type.typelist
4129+ case 296LLU + 1LLU + 1LLU: // ~type.typelist
41244130 {
41254131 // release element subtype
41264132 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -4130,14 +4136,14 @@
41304136 newstack[0] = (uint64_t)stack; // backup stack location
41314137 newstack[1] = 1234567890;
41324138 newstack[2] = base;
4133- newstack[3] = 298LLU;
4139+ newstack[3] = 299LLU;
41344140 stack = newstack;
41354141 // set stack-base & callee-address
41364142 base = 4/*deloffset*/;
4137- label = 295LLU; // ~type
4143+ label = 296LLU; // ~type
41384144 break;
41394145 }
4140- case 298LLU: // return from ~type to type
4146+ case 299LLU: // return from ~type to type
41414147 {
41424148 stack = (uint64_t *)stack[0];
41434149 // releasing toplevel container
@@ -4149,7 +4155,7 @@
41494155 base = stack[base - 2];
41504156 break;
41514157 }
4152- case 300LLU: // function mktypename failed
4158+ case 301LLU: // function mktypename failed
41534159 {
41544160 fprintf(stderr, "function mktypename failed\n");
41554161 label = stack[base - 3];
@@ -4156,20 +4162,20 @@
41564162 base = stack[base - 2];
41574163 break;
41584164 }
4159- case 299LLU: // mktypename
4165+ case 300LLU: // mktypename
41604166 {
41614167 //#define res0 0
41624168 //#define arg0 1
4163- label = 302LLU; // skip deleter
4169+ label = 303LLU; // skip deleter
41644170 break;
41654171 }
4166- case 301LLU: // deleter
4172+ case 302LLU: // deleter
41674173 {
41684174 // throw from mktypename
41694175 if(!stack[base + 0])
41704176 {
41714177 fprintf(stderr, "in function mktypename: unrolling stack, skipping already deleted/unscoped variable type \n");
4172- label = 300LLU; // skip, variable already deleted/unscoped
4178+ label = 301LLU; // skip, variable already deleted/unscoped
41734179 break;
41744180 }
41754181 fprintf(stderr, "in function mktypename: unrolling stack, variable type \n");
@@ -4179,28 +4185,28 @@
41794185 newstack[0] = (uint64_t)stack; // backup stack location
41804186 newstack[1] = 1234567890;
41814187 newstack[2] = base;
4182- newstack[3] = 303LLU;
4188+ newstack[3] = 304LLU;
41834189 stack = newstack;
41844190 // set stack-base & callee-address
41854191 base = 4/*deloffset*/;
4186- label = 295LLU; // ~type
4192+ label = 296LLU; // ~type
41874193 break;
41884194 }
4189- case 303LLU: // return from ~type to mktypename
4195+ case 304LLU: // return from ~type to mktypename
41904196 {
41914197 stack = (uint64_t *)stack[0];
41924198 // releasing toplevel container
41934199 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
41944200
4195- label = 300LLU; // continue unrolling stack, delete next variable
4201+ label = 301LLU; // continue unrolling stack, delete next variable
41964202 break;
41974203 }
4198- case 302LLU: // skipped deleter
4204+ case 303LLU: // skipped deleter
41994205 {
42004206 // construct type.typename
42014207 if(!(stack[base + 0] = construct(1)))
42024208 {
4203- label = 300LLU; // throw: begin to unroll stack
4209+ label = 301LLU; // throw: begin to unroll stack
42044210 break;
42054211 }
42064212
@@ -4212,7 +4218,7 @@
42124218 base = stack[base - 2];
42134219 break;
42144220 }
4215- case 305LLU: // function printtype failed
4221+ case 306LLU: // function printtype failed
42164222 {
42174223 fprintf(stderr, "function printtype failed\n");
42184224 label = stack[base - 3];
@@ -4219,12 +4225,12 @@
42194225 base = stack[base - 2];
42204226 break;
42214227 }
4222- case 304LLU: // printtype
4228+ case 305LLU: // printtype
42234229 {
42244230 //#define arg0 0
42254231 if(/*typename*/0 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
42264232 {
4227- label = 307LLU; // jump to alternative
4233+ label = 308LLU; // jump to alternative
42284234 break;
42294235 }
42304236
@@ -4232,9 +4238,9 @@
42324238
42334239 // case
42344240 // call printid from printtype
4235- stack[base + 2LLU] = 309LLU/*throw to this address*/;
4241+ stack[base + 2LLU] = 310LLU/*throw to this address*/;
42364242 stack[base + 3LLU] = base;
4237- stack[base + 4LLU] = 310LLU;
4243+ stack[base + 4LLU] = 311LLU;
42384244 // arguments for call to printid
42394245 stack[base + 5LLU] = stack[base + 1]/*name*/;
42404246 // set stack-base & callee-address
@@ -4242,31 +4248,31 @@
42424248 label = 18446744073709551587LLU; // printid
42434249 break;
42444250 }
4245- case 309LLU: // copy-back deleter (printid to printtype)
4251+ case 310LLU: // copy-back deleter (printid to printtype)
42464252 {
42474253 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
42484254 // copy mutable arguments back from call to printid
4249- label = 308LLU; // continue to roll stack
4255+ label = 309LLU; // continue to roll stack
42504256 break;
42514257 }
4252- case 310LLU: // return from printid to printtype
4258+ case 311LLU: // return from printid to printtype
42534259 {
42544260 // copy mutable arguments back from call to printid
42554261 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4256- label = 306LLU; // case complete
4262+ label = 307LLU; // case complete
42574263 break;
42584264 }
4259- case 308LLU: // copy-back deleter (switch)
4265+ case 309LLU: // copy-back deleter (switch)
42604266 {
42614267 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4262- label = 305LLU; // continue to unroll stack
4268+ label = 306LLU; // continue to unroll stack
42634269 break;
42644270 }
4265- case 307LLU: // try next case
4271+ case 308LLU: // try next case
42664272 {
42674273 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
42684274 {
4269- label = 311LLU; // jump to alternative
4275+ label = 312LLU; // jump to alternative
42704276 break;
42714277 }
42724278
@@ -4277,7 +4283,7 @@
42774283 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
42784284 if(!newstack)
42794285 {
4280- label = 312LLU; // throw: begin to unroll stack
4286+ label = 313LLU; // throw: begin to unroll stack
42814287 break;
42824288 }
42834289
@@ -4284,18 +4290,18 @@
42844290 newstack[10LLU] = 9876543210LLU; // overflow-marker
42854291 // call printtype from printtype
42864292 newstack[0] = (uint64_t)stack; // backup stack location
4287- newstack[1] = 313LLU;
4293+ newstack[1] = 314LLU;
42884294 newstack[2] = base;
4289- newstack[3] = 314LLU;
4295+ newstack[3] = 315LLU;
42904296 // arguments for call to printtype
42914297 newstack[4LLU] = stack[base + 1]/*subtype*/;
42924298 stack = newstack;
42934299 // set stack-base & callee-address
42944300 base = 4/*deloffset*/;
4295- label = 304LLU; // printtype
4301+ label = 305LLU; // printtype
42964302 break;
42974303 }
4298- case 313LLU: // copy-back deleter (printtype to printtype)
4304+ case 314LLU: // copy-back deleter (printtype to printtype)
42994305 {
43004306 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
43014307 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4307,10 +4313,10 @@
43074313 }
43084314 Free(10LLU + 1, sizeof(uint64_t), stack);
43094315 stack = oldstack;
4310- label = 312LLU; // continue to unroll stack
4316+ label = 313LLU; // continue to unroll stack
43114317 break;
43124318 }
4313- case 314LLU: // return from printtype to printtype
4319+ case 315LLU: // return from printtype to printtype
43144320 {
43154321 uint64_t *oldstack = (uint64_t *)stack[0];
43164322 // copy mutable arguments back from call to printtype
@@ -4323,21 +4329,21 @@
43234329 stack = oldstack;
43244330 printf("%s", "]");
43254331 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4326- label = 306LLU; // case complete
4332+ label = 307LLU; // case complete
43274333 break;
43284334 }
4329- case 312LLU: // copy-back deleter (switch)
4335+ case 313LLU: // copy-back deleter (switch)
43304336 {
43314337 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4332- label = 305LLU; // continue to unroll stack
4338+ label = 306LLU; // continue to unroll stack
43334339 break;
43344340 }
4335- case 311LLU: // try next case
4341+ case 312LLU: // try next case
43364342 {
43374343 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
43384344 exit(-1);
43394345 }
4340- case 306LLU: // completed switch
4346+ case 307LLU: // completed switch
43414347 {
43424348 // return from printtype
43434349 label = stack[base - 1];
@@ -4344,7 +4350,7 @@
43444350 base = stack[base - 2];
43454351 break;
43464352 }
4347- case 316LLU: // function reporttype failed
4353+ case 317LLU: // function reporttype failed
43484354 {
43494355 fprintf(stderr, "function reporttype failed\n");
43504356 label = stack[base - 3];
@@ -4351,12 +4357,12 @@
43514357 base = stack[base - 2];
43524358 break;
43534359 }
4354- case 315LLU: // reporttype
4360+ case 316LLU: // reporttype
43554361 {
43564362 //#define arg0 0
43574363 if(/*typename*/0 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
43584364 {
4359- label = 318LLU; // jump to alternative
4365+ label = 319LLU; // jump to alternative
43604366 break;
43614367 }
43624368
@@ -4364,9 +4370,9 @@
43644370
43654371 // case
43664372 // call reportid from reporttype
4367- stack[base + 2LLU] = 320LLU/*throw to this address*/;
4373+ stack[base + 2LLU] = 321LLU/*throw to this address*/;
43684374 stack[base + 3LLU] = base;
4369- stack[base + 4LLU] = 321LLU;
4375+ stack[base + 4LLU] = 322LLU;
43704376 // arguments for call to reportid
43714377 stack[base + 5LLU] = stack[base + 1]/*name*/;
43724378 // set stack-base & callee-address
@@ -4374,31 +4380,31 @@
43744380 label = 18446744073709551586LLU; // reportid
43754381 break;
43764382 }
4377- case 320LLU: // copy-back deleter (reportid to reporttype)
4383+ case 321LLU: // copy-back deleter (reportid to reporttype)
43784384 {
43794385 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
43804386 // copy mutable arguments back from call to reportid
4381- label = 319LLU; // continue to roll stack
4387+ label = 320LLU; // continue to roll stack
43824388 break;
43834389 }
4384- case 321LLU: // return from reportid to reporttype
4390+ case 322LLU: // return from reportid to reporttype
43854391 {
43864392 // copy mutable arguments back from call to reportid
43874393 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4388- label = 317LLU; // case complete
4394+ label = 318LLU; // case complete
43894395 break;
43904396 }
4391- case 319LLU: // copy-back deleter (switch)
4397+ case 320LLU: // copy-back deleter (switch)
43924398 {
43934399 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4394- label = 316LLU; // continue to unroll stack
4400+ label = 317LLU; // continue to unroll stack
43954401 break;
43964402 }
4397- case 318LLU: // try next case
4403+ case 319LLU: // try next case
43984404 {
43994405 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
44004406 {
4401- label = 322LLU; // jump to alternative
4407+ label = 323LLU; // jump to alternative
44024408 break;
44034409 }
44044410
@@ -4409,7 +4415,7 @@
44094415 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
44104416 if(!newstack)
44114417 {
4412- label = 323LLU; // throw: begin to unroll stack
4418+ label = 324LLU; // throw: begin to unroll stack
44134419 break;
44144420 }
44154421
@@ -4416,18 +4422,18 @@
44164422 newstack[10LLU] = 9876543210LLU; // overflow-marker
44174423 // call reporttype from reporttype
44184424 newstack[0] = (uint64_t)stack; // backup stack location
4419- newstack[1] = 324LLU;
4425+ newstack[1] = 325LLU;
44204426 newstack[2] = base;
4421- newstack[3] = 325LLU;
4427+ newstack[3] = 326LLU;
44224428 // arguments for call to reporttype
44234429 newstack[4LLU] = stack[base + 1]/*subtype*/;
44244430 stack = newstack;
44254431 // set stack-base & callee-address
44264432 base = 4/*deloffset*/;
4427- label = 315LLU; // reporttype
4433+ label = 316LLU; // reporttype
44284434 break;
44294435 }
4430- case 324LLU: // copy-back deleter (reporttype to reporttype)
4436+ case 325LLU: // copy-back deleter (reporttype to reporttype)
44314437 {
44324438 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
44334439 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4439,10 +4445,10 @@
44394445 }
44404446 Free(10LLU + 1, sizeof(uint64_t), stack);
44414447 stack = oldstack;
4442- label = 323LLU; // continue to unroll stack
4448+ label = 324LLU; // continue to unroll stack
44434449 break;
44444450 }
4445- case 325LLU: // return from reporttype to reporttype
4451+ case 326LLU: // return from reporttype to reporttype
44464452 {
44474453 uint64_t *oldstack = (uint64_t *)stack[0];
44484454 // copy mutable arguments back from call to reporttype
@@ -4455,21 +4461,21 @@
44554461 stack = oldstack;
44564462 fprintf(stderr, "%s", "]");
44574463 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4458- label = 317LLU; // case complete
4464+ label = 318LLU; // case complete
44594465 break;
44604466 }
4461- case 323LLU: // copy-back deleter (switch)
4467+ case 324LLU: // copy-back deleter (switch)
44624468 {
44634469 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4464- label = 316LLU; // continue to unroll stack
4470+ label = 317LLU; // continue to unroll stack
44654471 break;
44664472 }
4467- case 322LLU: // try next case
4473+ case 323LLU: // try next case
44684474 {
44694475 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
44704476 exit(-1);
44714477 }
4472- case 317LLU: // completed switch
4478+ case 318LLU: // completed switch
44734479 {
44744480 // return from reporttype
44754481 label = stack[base - 1];
@@ -4476,7 +4482,7 @@
44764482 base = stack[base - 2];
44774483 break;
44784484 }
4479- case 327LLU: // function copytype failed
4485+ case 328LLU: // function copytype failed
44804486 {
44814487 fprintf(stderr, "function copytype failed\n");
44824488 label = stack[base - 3];
@@ -4483,13 +4489,13 @@
44834489 base = stack[base - 2];
44844490 break;
44854491 }
4486- case 326LLU: // copytype
4492+ case 327LLU: // copytype
44874493 {
44884494 //#define res0 0
44894495 //#define arg0 1
44904496 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
44914497 {
4492- label = 329LLU; // jump to alternative
4498+ label = 330LLU; // jump to alternative
44934499 break;
44944500 }
44954501
@@ -4496,16 +4502,16 @@
44964502 /*name*/stack[base + 2] = ((uint64_t **)(stack[base + 1]/*type*/))[1][0]/*name*/;
44974503
44984504 // case
4499- label = 332LLU; // skip deleter
4505+ label = 333LLU; // skip deleter
45004506 break;
45014507 }
4502- case 331LLU: // deleter
4508+ case 332LLU: // deleter
45034509 {
45044510 // throw from copytype
45054511 if(!stack[base + 0])
45064512 {
45074513 fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4508- label = 330LLU; // skip, variable already deleted/unscoped
4514+ label = 331LLU; // skip, variable already deleted/unscoped
45094515 break;
45104516 }
45114517 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4515,28 +4521,28 @@
45154521 newstack[0] = (uint64_t)stack; // backup stack location
45164522 newstack[1] = 1234567890;
45174523 newstack[2] = base;
4518- newstack[3] = 333LLU;
4524+ newstack[3] = 334LLU;
45194525 stack = newstack;
45204526 // set stack-base & callee-address
45214527 base = 4/*deloffset*/;
4522- label = 295LLU; // ~type
4528+ label = 296LLU; // ~type
45234529 break;
45244530 }
4525- case 333LLU: // return from ~type to copytype
4531+ case 334LLU: // return from ~type to copytype
45264532 {
45274533 stack = (uint64_t *)stack[0];
45284534 // releasing toplevel container
45294535 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
45304536
4531- label = 330LLU; // continue unrolling stack, delete next variable
4537+ label = 331LLU; // continue unrolling stack, delete next variable
45324538 break;
45334539 }
4534- case 332LLU: // skipped deleter
4540+ case 333LLU: // skipped deleter
45354541 {
45364542 // construct type.typename
45374543 if(!(stack[base + 0] = construct(1)))
45384544 {
4539- label = 330LLU; // throw: begin to unroll stack
4545+ label = 331LLU; // throw: begin to unroll stack
45404546 break;
45414547 }
45424548
@@ -4544,20 +4550,20 @@
45444550 ((uint64_t *)stack[base + 0])[0] = 0;
45454551 (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 2]/*name*/;
45464552 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4547- label = 328LLU; // case complete
4553+ label = 329LLU; // case complete
45484554 break;
45494555 }
4550- case 330LLU: // copy-back deleter (switch)
4556+ case 331LLU: // copy-back deleter (switch)
45514557 {
45524558 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4553- label = 327LLU; // continue to unroll stack
4559+ label = 328LLU; // continue to unroll stack
45544560 break;
45554561 }
4556- case 329LLU: // try next case
4562+ case 330LLU: // try next case
45574563 {
45584564 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
45594565 {
4560- label = 334LLU; // jump to alternative
4566+ label = 335LLU; // jump to alternative
45614567 break;
45624568 }
45634569
@@ -4567,7 +4573,7 @@
45674573 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
45684574 if(!newstack)
45694575 {
4570- label = 335LLU; // throw: begin to unroll stack
4576+ label = 336LLU; // throw: begin to unroll stack
45714577 break;
45724578 }
45734579
@@ -4574,18 +4580,18 @@
45744580 newstack[15LLU] = 9876543210LLU; // overflow-marker
45754581 // call copytype from copytype
45764582 newstack[0] = (uint64_t)stack; // backup stack location
4577- newstack[1] = 336LLU;
4583+ newstack[1] = 337LLU;
45784584 newstack[2] = base;
4579- newstack[3] = 337LLU;
4585+ newstack[3] = 338LLU;
45804586 // arguments for call to copytype
45814587 newstack[5LLU] = stack[base + 2]/*original*/;
45824588 stack = newstack;
45834589 // set stack-base & callee-address
45844590 base = 4/*deloffset*/;
4585- label = 326LLU; // copytype
4591+ label = 327LLU; // copytype
45864592 break;
45874593 }
4588- case 336LLU: // copy-back deleter (copytype to copytype)
4594+ case 337LLU: // copy-back deleter (copytype to copytype)
45894595 {
45904596 fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
45914597 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4597,10 +4603,10 @@
45974603 }
45984604 Free(15LLU + 1, sizeof(uint64_t), stack);
45994605 stack = oldstack;
4600- label = 335LLU; // continue to unroll stack
4606+ label = 336LLU; // continue to unroll stack
46014607 break;
46024608 }
4603- case 337LLU: // return from copytype to copytype
4609+ case 338LLU: // return from copytype to copytype
46044610 {
46054611 uint64_t *oldstack = (uint64_t *)stack[0];
46064612 // copy mutable arguments back from call to copytype
@@ -4613,16 +4619,16 @@
46134619 }
46144620 Free(15LLU + 1, sizeof(uint64_t), stack);
46154621 stack = oldstack;
4616- label = 339LLU; // skip deleter
4622+ label = 340LLU; // skip deleter
46174623 break;
46184624 }
4619- case 338LLU: // deleter
4625+ case 339LLU: // deleter
46204626 {
46214627 // throw from copytype
46224628 if(!stack[base + 0])
46234629 {
46244630 fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4625- label = 335LLU; // skip, variable already deleted/unscoped
4631+ label = 336LLU; // skip, variable already deleted/unscoped
46264632 break;
46274633 }
46284634 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4632,28 +4638,28 @@
46324638 newstack[0] = (uint64_t)stack; // backup stack location
46334639 newstack[1] = 1234567890;
46344640 newstack[2] = base;
4635- newstack[3] = 340LLU;
4641+ newstack[3] = 341LLU;
46364642 stack = newstack;
46374643 // set stack-base & callee-address
46384644 base = 4/*deloffset*/;
4639- label = 295LLU; // ~type
4645+ label = 296LLU; // ~type
46404646 break;
46414647 }
4642- case 340LLU: // return from ~type to copytype
4648+ case 341LLU: // return from ~type to copytype
46434649 {
46444650 stack = (uint64_t *)stack[0];
46454651 // releasing toplevel container
46464652 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
46474653
4648- label = 335LLU; // continue unrolling stack, delete next variable
4654+ label = 336LLU; // continue unrolling stack, delete next variable
46494655 break;
46504656 }
4651- case 339LLU: // skipped deleter
4657+ case 340LLU: // skipped deleter
46524658 {
46534659 // construct type.typelist
46544660 if(!(stack[base + 0] = construct(1)))
46554661 {
4656- label = 335LLU; // throw: begin to unroll stack
4662+ label = 336LLU; // throw: begin to unroll stack
46574663 break;
46584664 }
46594665
@@ -4661,21 +4667,21 @@
46614667 ((uint64_t *)stack[base + 0])[0] = 1;
46624668 INIT(&(((uint64_t **)(stack[base + 0]))[1][0]), &stack[base + 3]/*copy*/);
46634669 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4664- label = 328LLU; // case complete
4670+ label = 329LLU; // case complete
46654671 break;
46664672 }
4667- case 335LLU: // copy-back deleter (switch)
4673+ case 336LLU: // copy-back deleter (switch)
46684674 {
46694675 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4670- label = 327LLU; // continue to unroll stack
4676+ label = 328LLU; // continue to unroll stack
46714677 break;
46724678 }
4673- case 334LLU: // try next case
4679+ case 335LLU: // try next case
46744680 {
46754681 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
46764682 exit(-1);
46774683 }
4678- case 328LLU: // completed switch
4684+ case 329LLU: // completed switch
46794685 {
46804686 // return from copytype
46814687 label = stack[base - 1];
@@ -4682,7 +4688,7 @@
46824688 base = stack[base - 2];
46834689 break;
46844690 }
4685- case 342LLU: // function equtype failed
4691+ case 343LLU: // function equtype failed
46864692 {
46874693 fprintf(stderr, "function equtype failed\n");
46884694 label = stack[base - 3];
@@ -4689,7 +4695,7 @@
46894695 base = stack[base - 2];
46904696 break;
46914697 }
4692- case 341LLU: // equtype
4698+ case 342LLU: // equtype
46934699 {
46944700 //#define res0 0
46954701 //#define arg0 1
@@ -4696,7 +4702,7 @@
46964702 //#define arg1 2
46974703 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
46984704 {
4699- label = 344LLU; // jump to alternative
4705+ label = 345LLU; // jump to alternative
47004706 break;
47014707 }
47024708
@@ -4704,7 +4710,7 @@
47044710
47054711 if(/*typename*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
47064712 {
4707- label = 344LLU; // jump to alternative
4713+ label = 345LLU; // jump to alternative
47084714 break;
47094715 }
47104716
@@ -4712,9 +4718,9 @@
47124718
47134719 // case
47144720 // call equ from equtype
4715- stack[base + 5LLU] = 346LLU/*throw to this address*/;
4721+ stack[base + 5LLU] = 347LLU/*throw to this address*/;
47164722 stack[base + 6LLU] = base;
4717- stack[base + 7LLU] = 347LLU;
4723+ stack[base + 7LLU] = 348LLU;
47184724 // arguments for call to equ
47194725 stack[base + 9LLU] = stack[base + 3]/*xname*/;
47204726 stack[base + 10LLU] = stack[base + 4]/*yname*/;
@@ -4723,14 +4729,14 @@
47234729 label = 18446744073709551600LLU; // equ
47244730 break;
47254731 }
4726- case 346LLU: // copy-back deleter (equ to equtype)
4732+ case 347LLU: // copy-back deleter (equ to equtype)
47274733 {
47284734 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
47294735 // copy mutable arguments back from call to equ
4730- label = 345LLU; // continue to roll stack
4736+ label = 346LLU; // continue to roll stack
47314737 break;
47324738 }
4733- case 347LLU: // return from equ to equtype
4739+ case 348LLU: // return from equ to equtype
47344740 {
47354741 // copy mutable arguments back from call to equ
47364742 // copy back results provided by call to equ
@@ -4737,21 +4743,21 @@
47374743 stack[base + 0] = stack[base + 8LLU];
47384744 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47394745 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4740- label = 343LLU; // case complete
4746+ label = 344LLU; // case complete
47414747 break;
47424748 }
4743- case 345LLU: // copy-back deleter (switch)
4749+ case 346LLU: // copy-back deleter (switch)
47444750 {
47454751 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47464752 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4747- label = 342LLU; // continue to unroll stack
4753+ label = 343LLU; // continue to unroll stack
47484754 break;
47494755 }
4750- case 344LLU: // try next case
4756+ case 345LLU: // try next case
47514757 {
47524758 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
47534759 {
4754- label = 348LLU; // jump to alternative
4760+ label = 349LLU; // jump to alternative
47554761 break;
47564762 }
47574763
@@ -4759,7 +4765,7 @@
47594765
47604766 if(/*typelist*/1 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
47614767 {
4762- label = 348LLU; // jump to alternative
4768+ label = 349LLU; // jump to alternative
47634769 break;
47644770 }
47654771
@@ -4769,7 +4775,7 @@
47694775 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
47704776 if(!newstack)
47714777 {
4772- label = 349LLU; // throw: begin to unroll stack
4778+ label = 350LLU; // throw: begin to unroll stack
47734779 break;
47744780 }
47754781
@@ -4776,9 +4782,9 @@
47764782 newstack[15LLU] = 9876543210LLU; // overflow-marker
47774783 // call equtype from equtype
47784784 newstack[0] = (uint64_t)stack; // backup stack location
4779- newstack[1] = 350LLU;
4785+ newstack[1] = 351LLU;
47804786 newstack[2] = base;
4781- newstack[3] = 351LLU;
4787+ newstack[3] = 352LLU;
47824788 // arguments for call to equtype
47834789 newstack[5LLU] = stack[base + 3]/*xsubtype*/;
47844790 newstack[6LLU] = stack[base + 4]/*ysubtype*/;
@@ -4785,10 +4791,10 @@
47854791 stack = newstack;
47864792 // set stack-base & callee-address
47874793 base = 4/*deloffset*/;
4788- label = 341LLU; // equtype
4794+ label = 342LLU; // equtype
47894795 break;
47904796 }
4791- case 350LLU: // copy-back deleter (equtype to equtype)
4797+ case 351LLU: // copy-back deleter (equtype to equtype)
47924798 {
47934799 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
47944800 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4800,10 +4806,10 @@
48004806 }
48014807 Free(15LLU + 1, sizeof(uint64_t), stack);
48024808 stack = oldstack;
4803- label = 349LLU; // continue to unroll stack
4809+ label = 350LLU; // continue to unroll stack
48044810 break;
48054811 }
4806- case 351LLU: // return from equtype to equtype
4812+ case 352LLU: // return from equtype to equtype
48074813 {
48084814 uint64_t *oldstack = (uint64_t *)stack[0];
48094815 // copy mutable arguments back from call to equtype
@@ -4818,42 +4824,42 @@
48184824 stack = oldstack;
48194825 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
48204826 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4821- label = 343LLU; // case complete
4827+ label = 344LLU; // case complete
48224828 break;
48234829 }
4824- case 349LLU: // copy-back deleter (switch)
4830+ case 350LLU: // copy-back deleter (switch)
48254831 {
48264832 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
48274833 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4828- label = 342LLU; // continue to unroll stack
4834+ label = 343LLU; // continue to unroll stack
48294835 break;
48304836 }
4831- case 348LLU: // try next case
4837+ case 349LLU: // try next case
48324838 {
48334839 // default
4834- label = 353LLU; // skip deleter
4840+ label = 354LLU; // skip deleter
48354841 break;
48364842 }
4837- case 352LLU: // deleter
4843+ case 353LLU: // deleter
48384844 {
48394845 // throw from equtype
48404846 if(!stack[base + 0])
48414847 {
48424848 fprintf(stderr, "in function equtype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4843- label = 342LLU; // skip, variable already deleted/unscoped
4849+ label = 343LLU; // skip, variable already deleted/unscoped
48444850 break;
48454851 }
48464852 fprintf(stderr, "in function equtype: unrolling stack, variable u64 \n");
4847- label = 342LLU; // continue unrolling stack, delete next variable
4853+ label = 343LLU; // continue unrolling stack, delete next variable
48484854 break;
48494855 }
4850- case 353LLU: // skipped deleter
4856+ case 354LLU: // skipped deleter
48514857 {
48524858 stack[base + 0] = 0;
4853- label = 343LLU; // default complete
4859+ label = 344LLU; // default complete
48544860 break;
48554861 }
4856- case 343LLU: // completed switch
4862+ case 344LLU: // completed switch
48574863 {
48584864 // return from equtype
48594865 label = stack[base - 1];
@@ -4860,7 +4866,7 @@
48604866 base = stack[base - 2];
48614867 break;
48624868 }
4863- case 354LLU: // ~typeid
4869+ case 355LLU: // ~typeid
48644870 {
48654871 if(stack[base + 0]/*variant-nr*/ >= 1)
48664872 {
@@ -4867,10 +4873,10 @@
48674873 fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
48684874 exit(-1);
48694875 }
4870- label = 354LLU + 1LLU + stack[base + 0]/*variant-nr*/;
4876+ label = 355LLU + 1LLU + stack[base + 0]/*variant-nr*/;
48714877 break;
48724878 }
4873- case 354LLU + 1LLU + 0LLU: // ~typeid.typeid
4879+ case 355LLU + 1LLU + 0LLU: // ~typeid.typeid
48744880 {
48754881 // release element type
48764882 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -4880,14 +4886,14 @@
48804886 newstack[0] = (uint64_t)stack; // backup stack location
48814887 newstack[1] = 1234567890;
48824888 newstack[2] = base;
4883- newstack[3] = 356LLU;
4889+ newstack[3] = 357LLU;
48844890 stack = newstack;
48854891 // set stack-base & callee-address
48864892 base = 4/*deloffset*/;
4887- label = 295LLU; // ~type
4893+ label = 296LLU; // ~type
48884894 break;
48894895 }
4890- case 356LLU: // return from ~type to typeid
4896+ case 357LLU: // return from ~type to typeid
48914897 {
48924898 stack = (uint64_t *)stack[0];
48934899 // releasing toplevel container
@@ -4900,7 +4906,7 @@
49004906 base = stack[base - 2];
49014907 break;
49024908 }
4903- case 358LLU: // function copytypeid failed
4909+ case 359LLU: // function copytypeid failed
49044910 {
49054911 fprintf(stderr, "function copytypeid failed\n");
49064912 label = stack[base - 3];
@@ -4907,13 +4913,13 @@
49074913 base = stack[base - 2];
49084914 break;
49094915 }
4910- case 357LLU: // copytypeid
4916+ case 358LLU: // copytypeid
49114917 {
49124918 //#define res0 0
49134919 //#define arg0 1
49144920 if(/*typeid*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
49154921 {
4916- label = 360LLU; // jump to alternative
4922+ label = 361LLU; // jump to alternative
49174923 break;
49184924 }
49194925
@@ -4924,7 +4930,7 @@
49244930 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
49254931 if(!newstack)
49264932 {
4927- label = 361LLU; // throw: begin to unroll stack
4933+ label = 362LLU; // throw: begin to unroll stack
49284934 break;
49294935 }
49304936
@@ -4931,18 +4937,18 @@
49314937 newstack[15LLU] = 9876543210LLU; // overflow-marker
49324938 // call copytype from copytypeid
49334939 newstack[0] = (uint64_t)stack; // backup stack location
4934- newstack[1] = 362LLU;
4940+ newstack[1] = 363LLU;
49354941 newstack[2] = base;
4936- newstack[3] = 363LLU;
4942+ newstack[3] = 364LLU;
49374943 // arguments for call to copytype
49384944 newstack[5LLU] = stack[base + 2]/*origtype*/;
49394945 stack = newstack;
49404946 // set stack-base & callee-address
49414947 base = 4/*deloffset*/;
4942- label = 326LLU; // copytype
4948+ label = 327LLU; // copytype
49434949 break;
49444950 }
4945- case 362LLU: // copy-back deleter (copytype to copytypeid)
4951+ case 363LLU: // copy-back deleter (copytype to copytypeid)
49464952 {
49474953 fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
49484954 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4954,10 +4960,10 @@
49544960 }
49554961 Free(15LLU + 1, sizeof(uint64_t), stack);
49564962 stack = oldstack;
4957- label = 361LLU; // continue to unroll stack
4963+ label = 362LLU; // continue to unroll stack
49584964 break;
49594965 }
4960- case 363LLU: // return from copytype to copytypeid
4966+ case 364LLU: // return from copytype to copytypeid
49614967 {
49624968 uint64_t *oldstack = (uint64_t *)stack[0];
49634969 // copy mutable arguments back from call to copytype
@@ -4970,35 +4976,35 @@
49704976 }
49714977 Free(15LLU + 1, sizeof(uint64_t), stack);
49724978 stack = oldstack;
4973- label = 365LLU; // skip deleter
4979+ label = 366LLU; // skip deleter
49744980 break;
49754981 }
4976- case 364LLU: // deleter
4982+ case 365LLU: // deleter
49774983 {
49784984 // throw from copytypeid
49794985 if(!stack[base + 5])
49804986 {
49814987 fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4982- label = 361LLU; // skip, variable already deleted/unscoped
4988+ label = 362LLU; // skip, variable already deleted/unscoped
49834989 break;
49844990 }
49854991 fprintf(stderr, "in function copytypeid: unrolling stack, variable u64 \n");
4986- label = 361LLU; // continue unrolling stack, delete next variable
4992+ label = 362LLU; // continue unrolling stack, delete next variable
49874993 break;
49884994 }
4989- case 365LLU: // skipped deleter
4995+ case 366LLU: // skipped deleter
49904996 {
49914997 stack[base + 5] = stack[base + 3]/*origid*/;
4992- label = 367LLU; // skip deleter
4998+ label = 368LLU; // skip deleter
49934999 break;
49945000 }
4995- case 366LLU: // deleter
5001+ case 367LLU: // deleter
49965002 {
49975003 // throw from copytypeid
49985004 if(!stack[base + 0])
49995005 {
50005006 fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable typeid \n");
5001- label = 364LLU; // skip, variable already deleted/unscoped
5007+ label = 365LLU; // skip, variable already deleted/unscoped
50025008 break;
50035009 }
50045010 fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");
@@ -5008,28 +5014,28 @@
50085014 newstack[0] = (uint64_t)stack; // backup stack location
50095015 newstack[1] = 1234567890;
50105016 newstack[2] = base;
5011- newstack[3] = 368LLU;
5017+ newstack[3] = 369LLU;
50125018 stack = newstack;
50135019 // set stack-base & callee-address
50145020 base = 4/*deloffset*/;
5015- label = 354LLU; // ~typeid
5021+ label = 355LLU; // ~typeid
50165022 break;
50175023 }
5018- case 368LLU: // return from ~typeid to copytypeid
5024+ case 369LLU: // return from ~typeid to copytypeid
50195025 {
50205026 stack = (uint64_t *)stack[0];
50215027 // releasing toplevel container
50225028 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
50235029
5024- label = 364LLU; // continue unrolling stack, delete next variable
5030+ label = 365LLU; // continue unrolling stack, delete next variable
50255031 break;
50265032 }
5027- case 367LLU: // skipped deleter
5033+ case 368LLU: // skipped deleter
50285034 {
50295035 // construct typeid.typeid
50305036 if(!(stack[base + 0] = construct(2)))
50315037 {
5032- label = 364LLU; // throw: begin to unroll stack
5038+ label = 365LLU; // throw: begin to unroll stack
50335039 break;
50345040 }
50355041
@@ -5039,22 +5045,22 @@
50395045 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copyid*/;
50405046 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
50415047 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5042- label = 359LLU; // case complete
5048+ label = 360LLU; // case complete
50435049 break;
50445050 }
5045- case 361LLU: // copy-back deleter (switch)
5051+ case 362LLU: // copy-back deleter (switch)
50465052 {
50475053 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
50485054 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5049- label = 358LLU; // continue to unroll stack
5055+ label = 359LLU; // continue to unroll stack
50505056 break;
50515057 }
5052- case 360LLU: // try next case
5058+ case 361LLU: // try next case
50535059 {
50545060 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
50555061 exit(-1);
50565062 }
5057- case 359LLU: // completed switch
5063+ case 360LLU: // completed switch
50585064 {
50595065 // return from copytypeid
50605066 label = stack[base - 1];
@@ -5061,7 +5067,7 @@
50615067 base = stack[base - 2];
50625068 break;
50635069 }
5064- case 370LLU: // function reportti failed
5070+ case 371LLU: // function reportti failed
50655071 {
50665072 fprintf(stderr, "function reportti failed\n");
50675073 label = stack[base - 3];
@@ -5068,12 +5074,12 @@
50685074 base = stack[base - 2];
50695075 break;
50705076 }
5071- case 369LLU: // reportti
5077+ case 370LLU: // reportti
50725078 {
50735079 //#define arg0 0
50745080 if(/*typeid*/0 != ((uint64_t *)(stack[base + 0]/*typeid*/))[0])
50755081 {
5076- label = 372LLU; // jump to alternative
5082+ label = 373LLU; // jump to alternative
50775083 break;
50785084 }
50795085
@@ -5084,7 +5090,7 @@
50845090 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
50855091 if(!newstack)
50865092 {
5087- label = 373LLU; // throw: begin to unroll stack
5093+ label = 374LLU; // throw: begin to unroll stack
50885094 break;
50895095 }
50905096
@@ -5091,18 +5097,18 @@
50915097 newstack[10LLU] = 9876543210LLU; // overflow-marker
50925098 // call reporttype from reportti
50935099 newstack[0] = (uint64_t)stack; // backup stack location
5094- newstack[1] = 374LLU;
5100+ newstack[1] = 375LLU;
50955101 newstack[2] = base;
5096- newstack[3] = 375LLU;
5102+ newstack[3] = 376LLU;
50975103 // arguments for call to reporttype
50985104 newstack[4LLU] = stack[base + 1]/*type*/;
50995105 stack = newstack;
51005106 // set stack-base & callee-address
51015107 base = 4/*deloffset*/;
5102- label = 315LLU; // reporttype
5108+ label = 316LLU; // reporttype
51035109 break;
51045110 }
5105- case 374LLU: // copy-back deleter (reporttype to reportti)
5111+ case 375LLU: // copy-back deleter (reporttype to reportti)
51065112 {
51075113 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
51085114 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5114,10 +5120,10 @@
51145120 }
51155121 Free(10LLU + 1, sizeof(uint64_t), stack);
51165122 stack = oldstack;
5117- label = 373LLU; // continue to unroll stack
5123+ label = 374LLU; // continue to unroll stack
51185124 break;
51195125 }
5120- case 375LLU: // return from reporttype to reportti
5126+ case 376LLU: // return from reporttype to reportti
51215127 {
51225128 uint64_t *oldstack = (uint64_t *)stack[0];
51235129 // copy mutable arguments back from call to reporttype
@@ -5130,9 +5136,9 @@
51305136 stack = oldstack;
51315137 fprintf(stderr, "%s", " ");
51325138 // call reportid from reportti
5133- stack[base + 3LLU] = 376LLU/*throw to this address*/;
5139+ stack[base + 3LLU] = 377LLU/*throw to this address*/;
51345140 stack[base + 4LLU] = base;
5135- stack[base + 5LLU] = 377LLU;
5141+ stack[base + 5LLU] = 378LLU;
51365142 // arguments for call to reportid
51375143 stack[base + 6LLU] = stack[base + 2]/*id*/;
51385144 // set stack-base & callee-address
@@ -5140,34 +5146,34 @@
51405146 label = 18446744073709551586LLU; // reportid
51415147 break;
51425148 }
5143- case 376LLU: // copy-back deleter (reportid to reportti)
5149+ case 377LLU: // copy-back deleter (reportid to reportti)
51445150 {
51455151 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
51465152 // copy mutable arguments back from call to reportid
5147- label = 373LLU; // continue to roll stack
5153+ label = 374LLU; // continue to roll stack
51485154 break;
51495155 }
5150- case 377LLU: // return from reportid to reportti
5156+ case 378LLU: // return from reportid to reportti
51515157 {
51525158 // copy mutable arguments back from call to reportid
51535159 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
51545160 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5155- label = 371LLU; // case complete
5161+ label = 372LLU; // case complete
51565162 break;
51575163 }
5158- case 373LLU: // copy-back deleter (switch)
5164+ case 374LLU: // copy-back deleter (switch)
51595165 {
51605166 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
51615167 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5162- label = 370LLU; // continue to unroll stack
5168+ label = 371LLU; // continue to unroll stack
51635169 break;
51645170 }
5165- case 372LLU: // try next case
5171+ case 373LLU: // try next case
51665172 {
51675173 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
51685174 exit(-1);
51695175 }
5170- case 371LLU: // completed switch
5176+ case 372LLU: // completed switch
51715177 {
51725178 // return from reportti
51735179 label = stack[base - 1];
@@ -5174,7 +5180,7 @@
51745180 base = stack[base - 2];
51755181 break;
51765182 }
5177- case 378LLU: // ~typeidx
5183+ case 379LLU: // ~typeidx
51785184 {
51795185 if(stack[base + 0]/*variant-nr*/ >= 1)
51805186 {
@@ -5181,10 +5187,10 @@
51815187 fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
51825188 exit(-1);
51835189 }
5184- label = 378LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5190+ label = 379LLU + 1LLU + stack[base + 0]/*variant-nr*/;
51855191 break;
51865192 }
5187- case 378LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5193+ case 379LLU + 1LLU + 0LLU: // ~typeidx.typeidx
51885194 {
51895195 // release element type
51905196 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5194,14 +5200,14 @@
51945200 newstack[0] = (uint64_t)stack; // backup stack location
51955201 newstack[1] = 1234567890;
51965202 newstack[2] = base;
5197- newstack[3] = 380LLU;
5203+ newstack[3] = 381LLU;
51985204 stack = newstack;
51995205 // set stack-base & callee-address
52005206 base = 4/*deloffset*/;
5201- label = 295LLU; // ~type
5207+ label = 296LLU; // ~type
52025208 break;
52035209 }
5204- case 380LLU: // return from ~type to typeidx
5210+ case 381LLU: // return from ~type to typeidx
52055211 {
52065212 stack = (uint64_t *)stack[0];
52075213 // releasing toplevel container
@@ -5214,7 +5220,7 @@
52145220 base = stack[base - 2];
52155221 break;
52165222 }
5217- case 382LLU: // function cptypeidx failed
5223+ case 383LLU: // function cptypeidx failed
52185224 {
52195225 fprintf(stderr, "function cptypeidx failed\n");
52205226 label = stack[base - 3];
@@ -5221,13 +5227,13 @@
52215227 base = stack[base - 2];
52225228 break;
52235229 }
5224- case 381LLU: // cptypeidx
5230+ case 382LLU: // cptypeidx
52255231 {
52265232 //#define res0 0
52275233 //#define arg0 1
52285234 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 1]/*orig*/))[0])
52295235 {
5230- label = 384LLU; // jump to alternative
5236+ label = 385LLU; // jump to alternative
52315237 break;
52325238 }
52335239
@@ -5238,7 +5244,7 @@
52385244 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
52395245 if(!newstack)
52405246 {
5241- label = 385LLU; // throw: begin to unroll stack
5247+ label = 386LLU; // throw: begin to unroll stack
52425248 break;
52435249 }
52445250
@@ -5245,18 +5251,18 @@
52455251 newstack[15LLU] = 9876543210LLU; // overflow-marker
52465252 // call copytype from cptypeidx
52475253 newstack[0] = (uint64_t)stack; // backup stack location
5248- newstack[1] = 386LLU;
5254+ newstack[1] = 387LLU;
52495255 newstack[2] = base;
5250- newstack[3] = 387LLU;
5256+ newstack[3] = 388LLU;
52515257 // arguments for call to copytype
52525258 newstack[5LLU] = stack[base + 2]/*otype*/;
52535259 stack = newstack;
52545260 // set stack-base & callee-address
52555261 base = 4/*deloffset*/;
5256- label = 326LLU; // copytype
5262+ label = 327LLU; // copytype
52575263 break;
52585264 }
5259- case 386LLU: // copy-back deleter (copytype to cptypeidx)
5265+ case 387LLU: // copy-back deleter (copytype to cptypeidx)
52605266 {
52615267 fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
52625268 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5268,10 +5274,10 @@
52685274 }
52695275 Free(15LLU + 1, sizeof(uint64_t), stack);
52705276 stack = oldstack;
5271- label = 385LLU; // continue to unroll stack
5277+ label = 386LLU; // continue to unroll stack
52725278 break;
52735279 }
5274- case 387LLU: // return from copytype to cptypeidx
5280+ case 388LLU: // return from copytype to cptypeidx
52755281 {
52765282 uint64_t *oldstack = (uint64_t *)stack[0];
52775283 // copy mutable arguments back from call to copytype
@@ -5284,35 +5290,35 @@
52845290 }
52855291 Free(15LLU + 1, sizeof(uint64_t), stack);
52865292 stack = oldstack;
5287- label = 389LLU; // skip deleter
5293+ label = 390LLU; // skip deleter
52885294 break;
52895295 }
5290- case 388LLU: // deleter
5296+ case 389LLU: // deleter
52915297 {
52925298 // throw from cptypeidx
52935299 if(!stack[base + 5])
52945300 {
52955301 fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5296- label = 385LLU; // skip, variable already deleted/unscoped
5302+ label = 386LLU; // skip, variable already deleted/unscoped
52975303 break;
52985304 }
52995305 fprintf(stderr, "in function cptypeidx: unrolling stack, variable u64 \n");
5300- label = 385LLU; // continue unrolling stack, delete next variable
5306+ label = 386LLU; // continue unrolling stack, delete next variable
53015307 break;
53025308 }
5303- case 389LLU: // skipped deleter
5309+ case 390LLU: // skipped deleter
53045310 {
53055311 stack[base + 5] = stack[base + 3]/*oidx*/;
5306- label = 391LLU; // skip deleter
5312+ label = 392LLU; // skip deleter
53075313 break;
53085314 }
5309- case 390LLU: // deleter
5315+ case 391LLU: // deleter
53105316 {
53115317 // throw from cptypeidx
53125318 if(!stack[base + 0])
53135319 {
53145320 fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable typeidx \n");
5315- label = 388LLU; // skip, variable already deleted/unscoped
5321+ label = 389LLU; // skip, variable already deleted/unscoped
53165322 break;
53175323 }
53185324 fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");
@@ -5322,28 +5328,28 @@
53225328 newstack[0] = (uint64_t)stack; // backup stack location
53235329 newstack[1] = 1234567890;
53245330 newstack[2] = base;
5325- newstack[3] = 392LLU;
5331+ newstack[3] = 393LLU;
53265332 stack = newstack;
53275333 // set stack-base & callee-address
53285334 base = 4/*deloffset*/;
5329- label = 378LLU; // ~typeidx
5335+ label = 379LLU; // ~typeidx
53305336 break;
53315337 }
5332- case 392LLU: // return from ~typeidx to cptypeidx
5338+ case 393LLU: // return from ~typeidx to cptypeidx
53335339 {
53345340 stack = (uint64_t *)stack[0];
53355341 // releasing toplevel container
53365342 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
53375343
5338- label = 388LLU; // continue unrolling stack, delete next variable
5344+ label = 389LLU; // continue unrolling stack, delete next variable
53395345 break;
53405346 }
5341- case 391LLU: // skipped deleter
5347+ case 392LLU: // skipped deleter
53425348 {
53435349 // construct typeidx.typeidx
53445350 if(!(stack[base + 0] = construct(2)))
53455351 {
5346- label = 388LLU; // throw: begin to unroll stack
5352+ label = 389LLU; // throw: begin to unroll stack
53475353 break;
53485354 }
53495355
@@ -5353,22 +5359,22 @@
53535359 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*cidx*/;
53545360 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
53555361 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5356- label = 383LLU; // case complete
5362+ label = 384LLU; // case complete
53575363 break;
53585364 }
5359- case 385LLU: // copy-back deleter (switch)
5365+ case 386LLU: // copy-back deleter (switch)
53605366 {
53615367 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
53625368 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5363- label = 382LLU; // continue to unroll stack
5369+ label = 383LLU; // continue to unroll stack
53645370 break;
53655371 }
5366- case 384LLU: // try next case
5372+ case 385LLU: // try next case
53675373 {
53685374 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
53695375 exit(-1);
53705376 }
5371- case 383LLU: // completed switch
5377+ case 384LLU: // completed switch
53725378 {
53735379 // return from cptypeidx
53745380 label = stack[base - 1];
@@ -5375,7 +5381,7 @@
53755381 base = stack[base - 2];
53765382 break;
53775383 }
5378- case 393LLU: // ~result
5384+ case 394LLU: // ~result
53795385 {
53805386 if(stack[base + 0]/*variant-nr*/ >= 1)
53815387 {
@@ -5382,10 +5388,10 @@
53825388 fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
53835389 exit(-1);
53845390 }
5385- label = 393LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5391+ label = 394LLU + 1LLU + stack[base + 0]/*variant-nr*/;
53865392 break;
53875393 }
5388- case 393LLU + 1LLU + 0LLU: // ~result.result
5394+ case 394LLU + 1LLU + 0LLU: // ~result.result
53895395 {
53905396 // release element type
53915397 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5395,14 +5401,14 @@
53955401 newstack[0] = (uint64_t)stack; // backup stack location
53965402 newstack[1] = 1234567890;
53975403 newstack[2] = base;
5398- newstack[3] = 395LLU;
5404+ newstack[3] = 396LLU;
53995405 stack = newstack;
54005406 // set stack-base & callee-address
54015407 base = 4/*deloffset*/;
5402- label = 295LLU; // ~type
5408+ label = 296LLU; // ~type
54035409 break;
54045410 }
5405- case 395LLU: // return from ~type to result
5411+ case 396LLU: // return from ~type to result
54065412 {
54075413 stack = (uint64_t *)stack[0];
54085414 // releasing toplevel container
@@ -5415,7 +5421,7 @@
54155421 base = stack[base - 2];
54165422 break;
54175423 }
5418- case 397LLU: // function copyresult failed
5424+ case 398LLU: // function copyresult failed
54195425 {
54205426 fprintf(stderr, "function copyresult failed\n");
54215427 label = stack[base - 3];
@@ -5422,13 +5428,13 @@
54225428 base = stack[base - 2];
54235429 break;
54245430 }
5425- case 396LLU: // copyresult
5431+ case 397LLU: // copyresult
54265432 {
54275433 //#define res0 0
54285434 //#define arg0 1
54295435 if(/*result*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
54305436 {
5431- label = 399LLU; // jump to alternative
5437+ label = 400LLU; // jump to alternative
54325438 break;
54335439 }
54345440
@@ -5439,7 +5445,7 @@
54395445 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
54405446 if(!newstack)
54415447 {
5442- label = 400LLU; // throw: begin to unroll stack
5448+ label = 401LLU; // throw: begin to unroll stack
54435449 break;
54445450 }
54455451
@@ -5446,18 +5452,18 @@
54465452 newstack[15LLU] = 9876543210LLU; // overflow-marker
54475453 // call copytype from copyresult
54485454 newstack[0] = (uint64_t)stack; // backup stack location
5449- newstack[1] = 401LLU;
5455+ newstack[1] = 402LLU;
54505456 newstack[2] = base;
5451- newstack[3] = 402LLU;
5457+ newstack[3] = 403LLU;
54525458 // arguments for call to copytype
54535459 newstack[5LLU] = stack[base + 2]/*origtype*/;
54545460 stack = newstack;
54555461 // set stack-base & callee-address
54565462 base = 4/*deloffset*/;
5457- label = 326LLU; // copytype
5463+ label = 327LLU; // copytype
54585464 break;
54595465 }
5460- case 401LLU: // copy-back deleter (copytype to copyresult)
5466+ case 402LLU: // copy-back deleter (copytype to copyresult)
54615467 {
54625468 fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
54635469 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5469,10 +5475,10 @@
54695475 }
54705476 Free(15LLU + 1, sizeof(uint64_t), stack);
54715477 stack = oldstack;
5472- label = 400LLU; // continue to unroll stack
5478+ label = 401LLU; // continue to unroll stack
54735479 break;
54745480 }
5475- case 402LLU: // return from copytype to copyresult
5481+ case 403LLU: // return from copytype to copyresult
54765482 {
54775483 uint64_t *oldstack = (uint64_t *)stack[0];
54785484 // copy mutable arguments back from call to copytype
@@ -5485,16 +5491,16 @@
54855491 }
54865492 Free(15LLU + 1, sizeof(uint64_t), stack);
54875493 stack = oldstack;
5488- label = 404LLU; // skip deleter
5494+ label = 405LLU; // skip deleter
54895495 break;
54905496 }
5491- case 403LLU: // deleter
5497+ case 404LLU: // deleter
54925498 {
54935499 // throw from copyresult
54945500 if(!stack[base + 0])
54955501 {
54965502 fprintf(stderr, "in function copyresult: unrolling stack, skipping already deleted/unscoped variable result \n");
5497- label = 400LLU; // skip, variable already deleted/unscoped
5503+ label = 401LLU; // skip, variable already deleted/unscoped
54985504 break;
54995505 }
55005506 fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");
@@ -5504,28 +5510,28 @@
55045510 newstack[0] = (uint64_t)stack; // backup stack location
55055511 newstack[1] = 1234567890;
55065512 newstack[2] = base;
5507- newstack[3] = 405LLU;
5513+ newstack[3] = 406LLU;
55085514 stack = newstack;
55095515 // set stack-base & callee-address
55105516 base = 4/*deloffset*/;
5511- label = 393LLU; // ~result
5517+ label = 394LLU; // ~result
55125518 break;
55135519 }
5514- case 405LLU: // return from ~result to copyresult
5520+ case 406LLU: // return from ~result to copyresult
55155521 {
55165522 stack = (uint64_t *)stack[0];
55175523 // releasing toplevel container
55185524 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
55195525
5520- label = 400LLU; // continue unrolling stack, delete next variable
5526+ label = 401LLU; // continue unrolling stack, delete next variable
55215527 break;
55225528 }
5523- case 404LLU: // skipped deleter
5529+ case 405LLU: // skipped deleter
55245530 {
55255531 // construct result.result
55265532 if(!(stack[base + 0] = construct(2)))
55275533 {
5528- label = 400LLU; // throw: begin to unroll stack
5534+ label = 401LLU; // throw: begin to unroll stack
55295535 break;
55305536 }
55315537
@@ -5535,22 +5541,22 @@
55355541 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 3]/*RESERVED*/;
55365542 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
55375543 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5538- label = 398LLU; // case complete
5544+ label = 399LLU; // case complete
55395545 break;
55405546 }
5541- case 400LLU: // copy-back deleter (switch)
5547+ case 401LLU: // copy-back deleter (switch)
55425548 {
55435549 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
55445550 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5545- label = 397LLU; // continue to unroll stack
5551+ label = 398LLU; // continue to unroll stack
55465552 break;
55475553 }
5548- case 399LLU: // try next case
5554+ case 400LLU: // try next case
55495555 {
55505556 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
55515557 exit(-1);
55525558 }
5553- case 398LLU: // completed switch
5559+ case 399LLU: // completed switch
55545560 {
55555561 // return from copyresult
55565562 label = stack[base - 1];
@@ -5557,7 +5563,7 @@
55575563 base = stack[base - 2];
55585564 break;
55595565 }
5560- case 407LLU: // function represult failed
5566+ case 408LLU: // function represult failed
55615567 {
55625568 fprintf(stderr, "function represult failed\n");
55635569 label = stack[base - 3];
@@ -5564,12 +5570,12 @@
55645570 base = stack[base - 2];
55655571 break;
55665572 }
5567- case 406LLU: // represult
5573+ case 407LLU: // represult
55685574 {
55695575 //#define arg0 0
55705576 if(/*result*/0 != ((uint64_t *)(stack[base + 0]/*result*/))[0])
55715577 {
5572- label = 409LLU; // jump to alternative
5578+ label = 410LLU; // jump to alternative
55735579 break;
55745580 }
55755581
@@ -5580,7 +5586,7 @@
55805586 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
55815587 if(!newstack)
55825588 {
5583- label = 410LLU; // throw: begin to unroll stack
5589+ label = 411LLU; // throw: begin to unroll stack
55845590 break;
55855591 }
55865592
@@ -5587,18 +5593,18 @@
55875593 newstack[10LLU] = 9876543210LLU; // overflow-marker
55885594 // call reporttype from represult
55895595 newstack[0] = (uint64_t)stack; // backup stack location
5590- newstack[1] = 411LLU;
5596+ newstack[1] = 412LLU;
55915597 newstack[2] = base;
5592- newstack[3] = 412LLU;
5598+ newstack[3] = 413LLU;
55935599 // arguments for call to reporttype
55945600 newstack[4LLU] = stack[base + 1]/*type*/;
55955601 stack = newstack;
55965602 // set stack-base & callee-address
55975603 base = 4/*deloffset*/;
5598- label = 315LLU; // reporttype
5604+ label = 316LLU; // reporttype
55995605 break;
56005606 }
5601- case 411LLU: // copy-back deleter (reporttype to represult)
5607+ case 412LLU: // copy-back deleter (reporttype to represult)
56025608 {
56035609 fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
56045610 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5610,10 +5616,10 @@
56105616 }
56115617 Free(10LLU + 1, sizeof(uint64_t), stack);
56125618 stack = oldstack;
5613- label = 410LLU; // continue to unroll stack
5619+ label = 411LLU; // continue to unroll stack
56145620 break;
56155621 }
5616- case 412LLU: // return from reporttype to represult
5622+ case 413LLU: // return from reporttype to represult
56175623 {
56185624 uint64_t *oldstack = (uint64_t *)stack[0];
56195625 // copy mutable arguments back from call to reporttype
@@ -5626,22 +5632,22 @@
56265632 stack = oldstack;
56275633 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
56285634 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5629- label = 408LLU; // case complete
5635+ label = 409LLU; // case complete
56305636 break;
56315637 }
5632- case 410LLU: // copy-back deleter (switch)
5638+ case 411LLU: // copy-back deleter (switch)
56335639 {
56345640 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
56355641 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5636- label = 407LLU; // continue to unroll stack
5642+ label = 408LLU; // continue to unroll stack
56375643 break;
56385644 }
5639- case 409LLU: // try next case
5645+ case 410LLU: // try next case
56405646 {
56415647 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
56425648 exit(-1);
56435649 }
5644- case 408LLU: // completed switch
5650+ case 409LLU: // completed switch
56455651 {
56465652 // return from represult
56475653 label = stack[base - 1];
@@ -5648,7 +5654,7 @@
56485654 base = stack[base - 2];
56495655 break;
56505656 }
5651- case 413LLU: // ~param
5657+ case 414LLU: // ~param
56525658 {
56535659 if(stack[base + 0]/*variant-nr*/ >= 1)
56545660 {
@@ -5655,10 +5661,10 @@
56555661 fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
56565662 exit(-1);
56575663 }
5658- label = 413LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5664+ label = 414LLU + 1LLU + stack[base + 0]/*variant-nr*/;
56595665 break;
56605666 }
5661- case 413LLU + 1LLU + 0LLU: // ~param.param
5667+ case 414LLU + 1LLU + 0LLU: // ~param.param
56625668 {
56635669 // release element typeid
56645670 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5668,14 +5674,14 @@
56685674 newstack[0] = (uint64_t)stack; // backup stack location
56695675 newstack[1] = 1234567890;
56705676 newstack[2] = base;
5671- newstack[3] = 415LLU;
5677+ newstack[3] = 416LLU;
56725678 stack = newstack;
56735679 // set stack-base & callee-address
56745680 base = 4/*deloffset*/;
5675- label = 354LLU; // ~typeid
5681+ label = 355LLU; // ~typeid
56765682 break;
56775683 }
5678- case 415LLU: // return from ~typeid to param
5684+ case 416LLU: // return from ~typeid to param
56795685 {
56805686 stack = (uint64_t *)stack[0];
56815687 // releasing toplevel container
@@ -5688,7 +5694,7 @@
56885694 base = stack[base - 2];
56895695 break;
56905696 }
5691- case 417LLU: // function copyparam failed
5697+ case 418LLU: // function copyparam failed
56925698 {
56935699 fprintf(stderr, "function copyparam failed\n");
56945700 label = stack[base - 3];
@@ -5695,13 +5701,13 @@
56955701 base = stack[base - 2];
56965702 break;
56975703 }
5698- case 416LLU: // copyparam
5704+ case 417LLU: // copyparam
56995705 {
57005706 //#define res0 0
57015707 //#define arg0 1
57025708 if(/*param*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
57035709 {
5704- label = 419LLU; // jump to alternative
5710+ label = 420LLU; // jump to alternative
57055711 break;
57065712 }
57075713
@@ -5710,57 +5716,57 @@
57105716
57115717 // case
57125718 // call copytypeid from copyparam
5713- stack[base + 5LLU] = 421LLU/*throw to this address*/;
5719+ stack[base + 5LLU] = 422LLU/*throw to this address*/;
57145720 stack[base + 6LLU] = base;
5715- stack[base + 7LLU] = 422LLU;
5721+ stack[base + 7LLU] = 423LLU;
57165722 // arguments for call to copytypeid
57175723 stack[base + 9LLU] = stack[base + 2]/*origtypeid*/;
57185724 // set stack-base & callee-address
57195725 base += 8LLU;
5720- label = 357LLU; // copytypeid
5726+ label = 358LLU; // copytypeid
57215727 break;
57225728 }
5723- case 421LLU: // copy-back deleter (copytypeid to copyparam)
5729+ case 422LLU: // copy-back deleter (copytypeid to copyparam)
57245730 {
57255731 fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
57265732 // copy mutable arguments back from call to copytypeid
5727- label = 420LLU; // continue to roll stack
5733+ label = 421LLU; // continue to roll stack
57285734 break;
57295735 }
5730- case 422LLU: // return from copytypeid to copyparam
5736+ case 423LLU: // return from copytypeid to copyparam
57315737 {
57325738 // copy mutable arguments back from call to copytypeid
57335739 // copy back results provided by call to copytypeid
57345740 stack[base + 4] = stack[base + 8LLU];
5735- label = 424LLU; // skip deleter
5741+ label = 425LLU; // skip deleter
57365742 break;
57375743 }
5738- case 423LLU: // deleter
5744+ case 424LLU: // deleter
57395745 {
57405746 // throw from copyparam
57415747 if(!stack[base + 5])
57425748 {
57435749 fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5744- label = 420LLU; // skip, variable already deleted/unscoped
5750+ label = 421LLU; // skip, variable already deleted/unscoped
57455751 break;
57465752 }
57475753 fprintf(stderr, "in function copyparam: unrolling stack, variable u64 \n");
5748- label = 420LLU; // continue unrolling stack, delete next variable
5754+ label = 421LLU; // continue unrolling stack, delete next variable
57495755 break;
57505756 }
5751- case 424LLU: // skipped deleter
5757+ case 425LLU: // skipped deleter
57525758 {
57535759 stack[base + 5] = stack[base + 3]/*origmut*/;
5754- label = 426LLU; // skip deleter
5760+ label = 427LLU; // skip deleter
57555761 break;
57565762 }
5757- case 425LLU: // deleter
5763+ case 426LLU: // deleter
57585764 {
57595765 // throw from copyparam
57605766 if(!stack[base + 0])
57615767 {
57625768 fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable param \n");
5763- label = 423LLU; // skip, variable already deleted/unscoped
5769+ label = 424LLU; // skip, variable already deleted/unscoped
57645770 break;
57655771 }
57665772 fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");
@@ -5770,28 +5776,28 @@
57705776 newstack[0] = (uint64_t)stack; // backup stack location
57715777 newstack[1] = 1234567890;
57725778 newstack[2] = base;
5773- newstack[3] = 427LLU;
5779+ newstack[3] = 428LLU;
57745780 stack = newstack;
57755781 // set stack-base & callee-address
57765782 base = 4/*deloffset*/;
5777- label = 413LLU; // ~param
5783+ label = 414LLU; // ~param
57785784 break;
57795785 }
5780- case 427LLU: // return from ~param to copyparam
5786+ case 428LLU: // return from ~param to copyparam
57815787 {
57825788 stack = (uint64_t *)stack[0];
57835789 // releasing toplevel container
57845790 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
57855791
5786- label = 423LLU; // continue unrolling stack, delete next variable
5792+ label = 424LLU; // continue unrolling stack, delete next variable
57875793 break;
57885794 }
5789- case 426LLU: // skipped deleter
5795+ case 427LLU: // skipped deleter
57905796 {
57915797 // construct param.param
57925798 if(!(stack[base + 0] = construct(2)))
57935799 {
5794- label = 423LLU; // throw: begin to unroll stack
5800+ label = 424LLU; // throw: begin to unroll stack
57955801 break;
57965802 }
57975803
@@ -5801,22 +5807,22 @@
58015807 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copymut*/;
58025808 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
58035809 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5804- label = 418LLU; // case complete
5810+ label = 419LLU; // case complete
58055811 break;
58065812 }
5807- case 420LLU: // copy-back deleter (switch)
5813+ case 421LLU: // copy-back deleter (switch)
58085814 {
58095815 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
58105816 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5811- label = 417LLU; // continue to unroll stack
5817+ label = 418LLU; // continue to unroll stack
58125818 break;
58135819 }
5814- case 419LLU: // try next case
5820+ case 420LLU: // try next case
58155821 {
58165822 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
58175823 exit(-1);
58185824 }
5819- case 418LLU: // completed switch
5825+ case 419LLU: // completed switch
58205826 {
58215827 // return from copyparam
58225828 label = stack[base - 1];
@@ -5823,7 +5829,7 @@
58235829 base = stack[base - 2];
58245830 break;
58255831 }
5826- case 429LLU: // function repparam failed
5832+ case 430LLU: // function repparam failed
58275833 {
58285834 fprintf(stderr, "function repparam failed\n");
58295835 label = stack[base - 3];
@@ -5830,12 +5836,12 @@
58305836 base = stack[base - 2];
58315837 break;
58325838 }
5833- case 428LLU: // repparam
5839+ case 429LLU: // repparam
58345840 {
58355841 //#define arg0 0
58365842 if(/*param*/0 != ((uint64_t *)(stack[base + 0]/*param*/))[0])
58375843 {
5838- label = 431LLU; // jump to alternative
5844+ label = 432LLU; // jump to alternative
58395845 break;
58405846 }
58415847
@@ -5845,61 +5851,61 @@
58455851 // case
58465852 if(!stack[base + 2]/*mutable*/)
58475853 {
5848- label = 433LLU; // jump to alternative
5854+ label = 434LLU; // jump to alternative
58495855 break;
58505856 }
58515857
58525858 // consequent
58535859 fprintf(stderr, "%s", "mut ");
5854- label = 434LLU; // consequent complete
5860+ label = 435LLU; // consequent complete
58555861 break;
58565862 }
5857- case 433LLU: // alternative
5863+ case 434LLU: // alternative
58585864 {
5859- label = 434LLU; // alternative complete
5865+ label = 435LLU; // alternative complete
58605866 break;
58615867 }
5862- case 434LLU: // completed if-then-else
5868+ case 435LLU: // completed if-then-else
58635869 {
58645870 // call reportti from repparam
5865- stack[base + 3LLU] = 435LLU/*throw to this address*/;
5871+ stack[base + 3LLU] = 436LLU/*throw to this address*/;
58665872 stack[base + 4LLU] = base;
5867- stack[base + 5LLU] = 436LLU;
5873+ stack[base + 5LLU] = 437LLU;
58685874 // arguments for call to reportti
58695875 stack[base + 6LLU] = stack[base + 1]/*typeid*/;
58705876 // set stack-base & callee-address
58715877 base += 6LLU;
5872- label = 369LLU; // reportti
5878+ label = 370LLU; // reportti
58735879 break;
58745880 }
5875- case 435LLU: // copy-back deleter (reportti to repparam)
5881+ case 436LLU: // copy-back deleter (reportti to repparam)
58765882 {
58775883 fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
58785884 // copy mutable arguments back from call to reportti
5879- label = 432LLU; // continue to roll stack
5885+ label = 433LLU; // continue to roll stack
58805886 break;
58815887 }
5882- case 436LLU: // return from reportti to repparam
5888+ case 437LLU: // return from reportti to repparam
58835889 {
58845890 // copy mutable arguments back from call to reportti
58855891 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
58865892 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5887- label = 430LLU; // case complete
5893+ label = 431LLU; // case complete
58885894 break;
58895895 }
5890- case 432LLU: // copy-back deleter (switch)
5896+ case 433LLU: // copy-back deleter (switch)
58915897 {
58925898 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
58935899 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5894- label = 429LLU; // continue to unroll stack
5900+ label = 430LLU; // continue to unroll stack
58955901 break;
58965902 }
5897- case 431LLU: // try next case
5903+ case 432LLU: // try next case
58985904 {
58995905 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
59005906 exit(-1);
59015907 }
5902- case 430LLU: // completed switch
5908+ case 431LLU: // completed switch
59035909 {
59045910 // return from repparam
59055911 label = stack[base - 1];
@@ -5906,7 +5912,7 @@
59065912 base = stack[base - 2];
59075913 break;
59085914 }
5909- case 438LLU: // function lookparam failed
5915+ case 439LLU: // function lookparam failed
59105916 {
59115917 fprintf(stderr, "function lookparam failed\n");
59125918 label = stack[base - 3];
@@ -5913,39 +5919,39 @@
59135919 base = stack[base - 2];
59145920 break;
59155921 }
5916- case 437LLU: // lookparam
5922+ case 438LLU: // lookparam
59175923 {
59185924 //#define res0 0
59195925 //#define arg0 1
59205926 //#define arg1 2
5921- label = 440LLU; // skip deleter
5927+ label = 441LLU; // skip deleter
59225928 break;
59235929 }
5924- case 439LLU: // deleter
5930+ case 440LLU: // deleter
59255931 {
59265932 // throw from lookparam
59275933 if(!stack[base + 3])
59285934 {
59295935 fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5930- label = 438LLU; // skip, variable already deleted/unscoped
5936+ label = 439LLU; // skip, variable already deleted/unscoped
59315937 break;
59325938 }
59335939 fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
5934- label = 438LLU; // continue unrolling stack, delete next variable
5940+ label = 439LLU; // continue unrolling stack, delete next variable
59355941 break;
59365942 }
5937- case 440LLU: // skipped deleter
5943+ case 441LLU: // skipped deleter
59385944 {
59395945 stack[base + 3] = 0;
59405946 flippedassign(stack[base + 1]/*params*/, &stack[base + 4]);
5941- label = 441LLU; // start to repeat
5947+ label = 442LLU; // start to repeat
59425948 break;
59435949 }
5944- case 441LLU: // repeat from here
5950+ case 442LLU: // repeat from here
59455951 {
59465952 if(!stack[base + 4])
59475953 {
5948- label = 442LLU; // break loop
5954+ label = 443LLU; // break loop
59495955 break;
59505956 }
59515957
@@ -5955,19 +5961,19 @@
59555961 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
59565962 if(!stack[base + 3]/*found*/)
59575963 {
5958- label = 443LLU; // jump to alternative
5964+ label = 445LLU; // jump to alternative
59595965 break;
59605966 }
59615967
59625968 // consequent
5963- label = 444LLU; // consequent complete
5969+ label = 446LLU; // consequent complete
59645970 break;
59655971 }
5966- case 443LLU: // alternative
5972+ case 445LLU: // alternative
59675973 {
59685974 if(/*param*/0 != ((uint64_t *)(stack[base + 5]/*param*/))[0])
59695975 {
5970- label = 446LLU; // jump to alternative
5976+ label = 448LLU; // jump to alternative
59715977 break;
59725978 }
59735979
@@ -5977,7 +5983,7 @@
59775983 // case
59785984 if(/*typeid*/0 != ((uint64_t *)(stack[base + 7]/*typeid*/))[0])
59795985 {
5980- label = 449LLU; // jump to alternative
5986+ label = 451LLU; // jump to alternative
59815987 break;
59825988 }
59835989
@@ -5986,9 +5992,9 @@
59865992
59875993 // case
59885994 // call equ from lookparam
5989- stack[base + 11LLU] = 451LLU/*throw to this address*/;
5995+ stack[base + 11LLU] = 453LLU/*throw to this address*/;
59905996 stack[base + 12LLU] = base;
5991- stack[base + 13LLU] = 452LLU;
5997+ stack[base + 13LLU] = 454LLU;
59925998 // arguments for call to equ
59935999 stack[base + 15LLU] = stack[base + 10]/*id*/;
59946000 stack[base + 16LLU] = stack[base + 2]/*wanted*/;
@@ -5997,14 +6003,14 @@
59976003 label = 18446744073709551600LLU; // equ
59986004 break;
59996005 }
6000- case 451LLU: // copy-back deleter (equ to lookparam)
6006+ case 453LLU: // copy-back deleter (equ to lookparam)
60016007 {
60026008 fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
60036009 // copy mutable arguments back from call to equ
6004- label = 450LLU; // continue to roll stack
6010+ label = 452LLU; // continue to roll stack
60056011 break;
60066012 }
6007- case 452LLU: // return from equ to lookparam
6013+ case 454LLU: // return from equ to lookparam
60086014 {
60096015 // copy mutable arguments back from call to equ
60106016 // copy back results provided by call to equ
@@ -6011,70 +6017,76 @@
60116017 stack[base + 3] = stack[base + 14LLU];
60126018 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
60136019 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6014- label = 448LLU; // case complete
6020+ label = 450LLU; // case complete
60156021 break;
60166022 }
6017- case 450LLU: // copy-back deleter (switch)
6023+ case 452LLU: // copy-back deleter (switch)
60186024 {
60196025 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
60206026 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6021- label = 447LLU; // continue to unroll stack
6027+ label = 449LLU; // continue to unroll stack
60226028 break;
60236029 }
6024- case 449LLU: // try next case
6030+ case 451LLU: // try next case
60256031 {
60266032 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
60276033 exit(-1);
60286034 }
6029- case 448LLU: // completed switch
6035+ case 450LLU: // completed switch
60306036 {
60316037 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
60326038 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6033- label = 445LLU; // case complete
6039+ label = 447LLU; // case complete
60346040 break;
60356041 }
6036- case 447LLU: // copy-back deleter (switch)
6042+ case 449LLU: // copy-back deleter (switch)
60376043 {
60386044 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
60396045 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6040- label = 439LLU; // continue to unroll stack
6046+ label = 444LLU; // continue to unroll stack
60416047 break;
60426048 }
6043- case 446LLU: // try next case
6049+ case 448LLU: // try next case
60446050 {
60456051 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
60466052 exit(-1);
60476053 }
6048- case 445LLU: // completed switch
6054+ case 447LLU: // completed switch
60496055 {
6050- label = 444LLU; // alternative complete
6056+ label = 446LLU; // alternative complete
60516057 break;
60526058 }
6053- case 444LLU: // completed if-then-else
6059+ case 446LLU: // completed if-then-else
60546060 {
60556061 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
6056- label = 441LLU; // repeat
6062+ label = 442LLU; // repeat
60576063 break;
60586064 }
6059- case 442LLU: // loop finished
6065+ case 444LLU: // copy-back deleter for while next
60606066 {
6061- label = 454LLU; // skip deleter
6067+ ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
6068+ label = 440LLU; // continue to unroll stack
60626069 break;
60636070 }
6064- case 453LLU: // deleter
6071+ case 443LLU: // loop finished
60656072 {
6073+ label = 456LLU; // skip deleter
6074+ break;
6075+ }
6076+ case 455LLU: // deleter
6077+ {
60666078 // throw from lookparam
60676079 if(!stack[base + 0])
60686080 {
60696081 fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6070- label = 439LLU; // skip, variable already deleted/unscoped
6082+ label = 440LLU; // skip, variable already deleted/unscoped
60716083 break;
60726084 }
60736085 fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
6074- label = 439LLU; // continue unrolling stack, delete next variable
6086+ label = 440LLU; // continue unrolling stack, delete next variable
60756087 break;
60766088 }
6077- case 454LLU: // skipped deleter
6089+ case 456LLU: // skipped deleter
60786090 {
60796091 stack[base + 0] = stack[base + 3]/*found*/;
60806092 // return from lookparam
@@ -6082,7 +6094,7 @@
60826094 base = stack[base - 2];
60836095 break;
60846096 }
6085- case 455LLU: // ~letdef
6097+ case 457LLU: // ~letdef
60866098 {
60876099 if(stack[base + 0]/*variant-nr*/ >= 1)
60886100 {
@@ -6089,10 +6101,10 @@
60896101 fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
60906102 exit(-1);
60916103 }
6092- label = 455LLU + 1LLU + stack[base + 0]/*variant-nr*/;
6104+ label = 457LLU + 1LLU + stack[base + 0]/*variant-nr*/;
60936105 break;
60946106 }
6095- case 455LLU + 1LLU + 0LLU: // ~letdef.letdef
6107+ case 457LLU + 1LLU + 0LLU: // ~letdef.letdef
60966108 {
60976109 // release element type
60986110 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -6102,14 +6114,14 @@
61026114 newstack[0] = (uint64_t)stack; // backup stack location
61036115 newstack[1] = 1234567890;
61046116 newstack[2] = base;
6105- newstack[3] = 457LLU;
6117+ newstack[3] = 459LLU;
61066118 stack = newstack;
61076119 // set stack-base & callee-address
61086120 base = 4/*deloffset*/;
6109- label = 295LLU; // ~type
6121+ label = 296LLU; // ~type
61106122 break;
61116123 }
6112- case 457LLU: // return from ~type to letdef
6124+ case 459LLU: // return from ~type to letdef
61136125 {
61146126 stack = (uint64_t *)stack[0];
61156127 // releasing toplevel container
@@ -6125,7 +6137,7 @@
61256137 base = stack[base - 2];
61266138 break;
61276139 }
6128- case 459LLU: // function mkletdummy failed
6140+ case 461LLU: // function mkletdummy failed
61296141 {
61306142 fprintf(stderr, "function mkletdummy failed\n");
61316143 label = stack[base - 3];
@@ -6132,38 +6144,38 @@
61326144 base = stack[base - 2];
61336145 break;
61346146 }
6135- case 458LLU: // mkletdummy
6147+ case 460LLU: // mkletdummy
61366148 {
61376149 //#define res0 0
6138- label = 461LLU; // skip deleter
6150+ label = 463LLU; // skip deleter
61396151 break;
61406152 }
6141- case 460LLU: // deleter
6153+ case 462LLU: // deleter
61426154 {
61436155 // throw from mkletdummy
61446156 if(!stack[base + 1])
61456157 {
61466158 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6147- label = 459LLU; // skip, variable already deleted/unscoped
6159+ label = 461LLU; // skip, variable already deleted/unscoped
61486160 break;
61496161 }
61506162 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6151- label = 459LLU; // continue unrolling stack, delete next variable
6163+ label = 461LLU; // continue unrolling stack, delete next variable
61526164 break;
61536165 }
6154- case 461LLU: // skipped deleter
6166+ case 463LLU: // skipped deleter
61556167 {
61566168 stack[base + 1] = 78026663350239232;
6157- label = 463LLU; // skip deleter
6169+ label = 465LLU; // skip deleter
61586170 break;
61596171 }
6160- case 462LLU: // deleter
6172+ case 464LLU: // deleter
61616173 {
61626174 // throw from mkletdummy
61636175 if(!stack[base + 2])
61646176 {
61656177 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable type \n");
6166- label = 460LLU; // skip, variable already deleted/unscoped
6178+ label = 462LLU; // skip, variable already deleted/unscoped
61676179 break;
61686180 }
61696181 fprintf(stderr, "in function mkletdummy: unrolling stack, variable type \n");
@@ -6173,28 +6185,28 @@
61736185 newstack[0] = (uint64_t)stack; // backup stack location
61746186 newstack[1] = 1234567890;
61756187 newstack[2] = base;
6176- newstack[3] = 464LLU;
6188+ newstack[3] = 466LLU;
61776189 stack = newstack;
61786190 // set stack-base & callee-address
61796191 base = 4/*deloffset*/;
6180- label = 295LLU; // ~type
6192+ label = 296LLU; // ~type
61816193 break;
61826194 }
6183- case 464LLU: // return from ~type to mkletdummy
6195+ case 466LLU: // return from ~type to mkletdummy
61846196 {
61856197 stack = (uint64_t *)stack[0];
61866198 // releasing toplevel container
61876199 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 2] - sizeof(uint64_t) * 4));
61886200
6189- label = 460LLU; // continue unrolling stack, delete next variable
6201+ label = 462LLU; // continue unrolling stack, delete next variable
61906202 break;
61916203 }
6192- case 463LLU: // skipped deleter
6204+ case 465LLU: // skipped deleter
61936205 {
61946206 // construct type.typename
61956207 if(!(stack[base + 2] = construct(1)))
61966208 {
6197- label = 460LLU; // throw: begin to unroll stack
6209+ label = 462LLU; // throw: begin to unroll stack
61986210 break;
61996211 }
62006212
@@ -6201,73 +6213,73 @@
62016213 // consequent
62026214 ((uint64_t *)stack[base + 2])[0] = 0;
62036215 (((uint64_t **)(stack[base + 2]))[1][0]) = stack[base + 1]/*newid*/;
6204- label = 466LLU; // skip deleter
6216+ label = 468LLU; // skip deleter
62056217 break;
62066218 }
6207- case 465LLU: // deleter
6219+ case 467LLU: // deleter
62086220 {
62096221 // throw from mkletdummy
62106222 if(!stack[base + 3])
62116223 {
62126224 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6213- label = 462LLU; // skip, variable already deleted/unscoped
6225+ label = 464LLU; // skip, variable already deleted/unscoped
62146226 break;
62156227 }
62166228 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6217- label = 462LLU; // continue unrolling stack, delete next variable
6229+ label = 464LLU; // continue unrolling stack, delete next variable
62186230 break;
62196231 }
6220- case 466LLU: // skipped deleter
6232+ case 468LLU: // skipped deleter
62216233 {
62226234 stack[base + 3] = 0;
6223- label = 468LLU; // skip deleter
6235+ label = 470LLU; // skip deleter
62246236 break;
62256237 }
6226- case 467LLU: // deleter
6238+ case 469LLU: // deleter
62276239 {
62286240 // throw from mkletdummy
62296241 if(!stack[base + 4])
62306242 {
62316243 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6232- label = 465LLU; // skip, variable already deleted/unscoped
6244+ label = 467LLU; // skip, variable already deleted/unscoped
62336245 break;
62346246 }
62356247 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6236- label = 465LLU; // continue unrolling stack, delete next variable
6248+ label = 467LLU; // continue unrolling stack, delete next variable
62376249 break;
62386250 }
6239- case 468LLU: // skipped deleter
6251+ case 470LLU: // skipped deleter
62406252 {
62416253 stack[base + 4] = 0;
6242- label = 470LLU; // skip deleter
6254+ label = 472LLU; // skip deleter
62436255 break;
62446256 }
6245- case 469LLU: // deleter
6257+ case 471LLU: // deleter
62466258 {
62476259 // throw from mkletdummy
62486260 if(!stack[base + 5])
62496261 {
62506262 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6251- label = 467LLU; // skip, variable already deleted/unscoped
6263+ label = 469LLU; // skip, variable already deleted/unscoped
62526264 break;
62536265 }
62546266 fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6255- label = 467LLU; // continue unrolling stack, delete next variable
6267+ label = 469LLU; // continue unrolling stack, delete next variable
62566268 break;
62576269 }
6258- case 470LLU: // skipped deleter
6270+ case 472LLU: // skipped deleter
62596271 {
62606272 stack[base + 5] = 0;
6261- label = 472LLU; // skip deleter
6273+ label = 474LLU; // skip deleter
62626274 break;
62636275 }
6264- case 471LLU: // deleter
6276+ case 473LLU: // deleter
62656277 {
62666278 // throw from mkletdummy
62676279 if(!stack[base + 0])
62686280 {
62696281 fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6270- label = 469LLU; // skip, variable already deleted/unscoped
6282+ label = 471LLU; // skip, variable already deleted/unscoped
62716283 break;
62726284 }
62736285 fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");
@@ -6277,28 +6289,28 @@
62776289 newstack[0] = (uint64_t)stack; // backup stack location
62786290 newstack[1] = 1234567890;
62796291 newstack[2] = base;
6280- newstack[3] = 473LLU;
6292+ newstack[3] = 475LLU;
62816293 stack = newstack;
62826294 // set stack-base & callee-address
62836295 base = 4/*deloffset*/;
6284- label = 455LLU; // ~letdef
6296+ label = 457LLU; // ~letdef
62856297 break;
62866298 }
6287- case 473LLU: // return from ~letdef to mkletdummy
6299+ case 475LLU: // return from ~letdef to mkletdummy
62886300 {
62896301 stack = (uint64_t *)stack[0];
62906302 // releasing toplevel container
62916303 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
62926304
6293- label = 469LLU; // continue unrolling stack, delete next variable
6305+ label = 471LLU; // continue unrolling stack, delete next variable
62946306 break;
62956307 }
6296- case 472LLU: // skipped deleter
6308+ case 474LLU: // skipped deleter
62976309 {
62986310 // construct letdef.letdef
62996311 if(!(stack[base + 0] = construct(5)))
63006312 {
6301- label = 469LLU; // throw: begin to unroll stack
6313+ label = 471LLU; // throw: begin to unroll stack
63026314 break;
63036315 }
63046316
@@ -6314,7 +6326,7 @@
63146326 base = stack[base - 2];
63156327 break;
63166328 }
6317- case 475LLU: // function reportlet failed
6329+ case 477LLU: // function reportlet failed
63186330 {
63196331 fprintf(stderr, "function reportlet failed\n");
63206332 label = stack[base - 3];
@@ -6321,12 +6333,12 @@
63216333 base = stack[base - 2];
63226334 break;
63236335 }
6324- case 474LLU: // reportlet
6336+ case 476LLU: // reportlet
63256337 {
63266338 //#define arg0 0
63276339 if(/*letdef*/0 != ((uint64_t *)(stack[base + 0]/*letdef*/))[0])
63286340 {
6329- label = 477LLU; // jump to alternative
6341+ label = 479LLU; // jump to alternative
63306342 break;
63316343 }
63326344
@@ -6339,26 +6351,26 @@
63396351 // case
63406352 if(!stack[base + 4]/*mutable*/)
63416353 {
6342- label = 479LLU; // jump to alternative
6354+ label = 481LLU; // jump to alternative
63436355 break;
63446356 }
63456357
63466358 // consequent
63476359 fprintf(stderr, "%s", "mut ");
6348- label = 480LLU; // consequent complete
6360+ label = 482LLU; // consequent complete
63496361 break;
63506362 }
6351- case 479LLU: // alternative
6363+ case 481LLU: // alternative
63526364 {
6353- label = 480LLU; // alternative complete
6365+ label = 482LLU; // alternative complete
63546366 break;
63556367 }
6356- case 480LLU: // completed if-then-else
6368+ case 482LLU: // completed if-then-else
63576369 {
63586370 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
63596371 if(!newstack)
63606372 {
6361- label = 478LLU; // throw: begin to unroll stack
6373+ label = 480LLU; // throw: begin to unroll stack
63626374 break;
63636375 }
63646376
@@ -6365,18 +6377,18 @@
63656377 newstack[10LLU] = 9876543210LLU; // overflow-marker
63666378 // call reporttype from reportlet
63676379 newstack[0] = (uint64_t)stack; // backup stack location
6368- newstack[1] = 481LLU;
6380+ newstack[1] = 483LLU;
63696381 newstack[2] = base;
6370- newstack[3] = 482LLU;
6382+ newstack[3] = 484LLU;
63716383 // arguments for call to reporttype
63726384 newstack[4LLU] = stack[base + 1]/*type*/;
63736385 stack = newstack;
63746386 // set stack-base & callee-address
63756387 base = 4/*deloffset*/;
6376- label = 315LLU; // reporttype
6388+ label = 316LLU; // reporttype
63776389 break;
63786390 }
6379- case 481LLU: // copy-back deleter (reporttype to reportlet)
6391+ case 483LLU: // copy-back deleter (reporttype to reportlet)
63806392 {
63816393 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
63826394 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6388,10 +6400,10 @@
63886400 }
63896401 Free(10LLU + 1, sizeof(uint64_t), stack);
63906402 stack = oldstack;
6391- label = 478LLU; // continue to unroll stack
6403+ label = 480LLU; // continue to unroll stack
63926404 break;
63936405 }
6394- case 482LLU: // return from reporttype to reportlet
6406+ case 484LLU: // return from reporttype to reportlet
63956407 {
63966408 uint64_t *oldstack = (uint64_t *)stack[0];
63976409 // copy mutable arguments back from call to reporttype
@@ -6404,9 +6416,9 @@
64046416 stack = oldstack;
64056417 fprintf(stderr, "%s", " ");
64066418 // call reportid from reportlet
6407- stack[base + 6LLU] = 483LLU/*throw to this address*/;
6419+ stack[base + 6LLU] = 485LLU/*throw to this address*/;
64086420 stack[base + 7LLU] = base;
6409- stack[base + 8LLU] = 484LLU;
6421+ stack[base + 8LLU] = 486LLU;
64106422 // arguments for call to reportid
64116423 stack[base + 9LLU] = stack[base + 2]/*id*/;
64126424 // set stack-base & callee-address
@@ -6414,21 +6426,21 @@
64146426 label = 18446744073709551586LLU; // reportid
64156427 break;
64166428 }
6417- case 483LLU: // copy-back deleter (reportid to reportlet)
6429+ case 485LLU: // copy-back deleter (reportid to reportlet)
64186430 {
64196431 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
64206432 // copy mutable arguments back from call to reportid
6421- label = 478LLU; // continue to roll stack
6433+ label = 480LLU; // continue to roll stack
64226434 break;
64236435 }
6424- case 484LLU: // return from reportid to reportlet
6436+ case 486LLU: // return from reportid to reportlet
64256437 {
64266438 // copy mutable arguments back from call to reportid
64276439 fprintf(stderr, "%s", " ");
64286440 // call reportnr from reportlet
6429- stack[base + 6LLU] = 485LLU/*throw to this address*/;
6441+ stack[base + 6LLU] = 487LLU/*throw to this address*/;
64306442 stack[base + 7LLU] = base;
6431- stack[base + 8LLU] = 486LLU;
6443+ stack[base + 8LLU] = 488LLU;
64326444 // arguments for call to reportnr
64336445 stack[base + 9LLU] = stack[base + 3]/*index*/;
64346446 // set stack-base & callee-address
@@ -6436,14 +6448,14 @@
64366448 label = 18446744073709551589LLU; // reportnr
64376449 break;
64386450 }
6439- case 485LLU: // copy-back deleter (reportnr to reportlet)
6451+ case 487LLU: // copy-back deleter (reportnr to reportlet)
64406452 {
64416453 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
64426454 // copy mutable arguments back from call to reportnr
6443- label = 478LLU; // continue to roll stack
6455+ label = 480LLU; // continue to roll stack
64446456 break;
64456457 }
6446- case 486LLU: // return from reportnr to reportlet
6458+ case 488LLU: // return from reportnr to reportlet
64476459 {
64486460 // copy mutable arguments back from call to reportnr
64496461 ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
@@ -6451,10 +6463,10 @@
64516463 ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
64526464 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
64536465 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6454- label = 476LLU; // case complete
6466+ label = 478LLU; // case complete
64556467 break;
64566468 }
6457- case 478LLU: // copy-back deleter (switch)
6469+ case 480LLU: // copy-back deleter (switch)
64586470 {
64596471 ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
64606472 ((uint64_t **)(stack[base + 0]))[1][3] = stack[base + 4];
@@ -6461,15 +6473,15 @@
64616473 ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
64626474 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
64636475 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6464- label = 475LLU; // continue to unroll stack
6476+ label = 477LLU; // continue to unroll stack
64656477 break;
64666478 }
6467- case 477LLU: // try next case
6479+ case 479LLU: // try next case
64686480 {
64696481 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
64706482 exit(-1);
64716483 }
6472- case 476LLU: // completed switch
6484+ case 478LLU: // completed switch
64736485 {
64746486 // return from reportlet
64756487 label = stack[base - 1];
@@ -6476,7 +6488,7 @@
64766488 base = stack[base - 2];
64776489 break;
64786490 }
6479- case 488LLU: // function equletdef failed
6491+ case 490LLU: // function equletdef failed
64806492 {
64816493 fprintf(stderr, "function equletdef failed\n");
64826494 label = stack[base - 3];
@@ -6483,7 +6495,7 @@
64836495 base = stack[base - 2];
64846496 break;
64856497 }
6486- case 487LLU: // equletdef
6498+ case 489LLU: // equletdef
64876499 {
64886500 //#define res0 0
64896501 //#define arg0 1
@@ -6490,7 +6502,7 @@
64906502 //#define arg1 2
64916503 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
64926504 {
6493- label = 490LLU; // jump to alternative
6505+ label = 492LLU; // jump to alternative
64946506 break;
64956507 }
64966508
@@ -6502,7 +6514,7 @@
65026514
65036515 if(/*letdef*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
65046516 {
6505- label = 490LLU; // jump to alternative
6517+ label = 492LLU; // jump to alternative
65066518 break;
65076519 }
65086520
@@ -6513,48 +6525,48 @@
65136525 /*ysubstruct*/stack[base + 12] = ((uint64_t **)(stack[base + 2]/*y*/))[1][4]/*substruct*/;
65146526
65156527 // case
6516- label = 493LLU; // skip deleter
6528+ label = 495LLU; // skip deleter
65176529 break;
65186530 }
6519- case 492LLU: // deleter
6531+ case 494LLU: // deleter
65206532 {
65216533 // throw from equletdef
65226534 if(!stack[base + 13])
65236535 {
65246536 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6525- label = 491LLU; // skip, variable already deleted/unscoped
6537+ label = 493LLU; // skip, variable already deleted/unscoped
65266538 break;
65276539 }
65286540 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6529- label = 491LLU; // continue unrolling stack, delete next variable
6541+ label = 493LLU; // continue unrolling stack, delete next variable
65306542 break;
65316543 }
6532- case 493LLU: // skipped deleter
6544+ case 495LLU: // skipped deleter
65336545 {
65346546 stack[base + 13] = 1;
6535- label = 495LLU; // skip deleter
6547+ label = 497LLU; // skip deleter
65366548 break;
65376549 }
6538- case 494LLU: // deleter
6550+ case 496LLU: // deleter
65396551 {
65406552 // throw from equletdef
65416553 if(!stack[base + 14])
65426554 {
65436555 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6544- label = 492LLU; // skip, variable already deleted/unscoped
6556+ label = 494LLU; // skip, variable already deleted/unscoped
65456557 break;
65466558 }
65476559 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6548- label = 492LLU; // continue unrolling stack, delete next variable
6560+ label = 494LLU; // continue unrolling stack, delete next variable
65496561 break;
65506562 }
6551- case 495LLU: // skipped deleter
6563+ case 497LLU: // skipped deleter
65526564 {
65536565 stack[base + 14] = 0;
65546566 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
65556567 if(!newstack)
65566568 {
6557- label = 494LLU; // throw: begin to unroll stack
6569+ label = 496LLU; // throw: begin to unroll stack
65586570 break;
65596571 }
65606572
@@ -6561,9 +6573,9 @@
65616573 newstack[15LLU] = 9876543210LLU; // overflow-marker
65626574 // call equtype from equletdef
65636575 newstack[0] = (uint64_t)stack; // backup stack location
6564- newstack[1] = 496LLU;
6576+ newstack[1] = 498LLU;
65656577 newstack[2] = base;
6566- newstack[3] = 497LLU;
6578+ newstack[3] = 499LLU;
65676579 // arguments for call to equtype
65686580 newstack[5LLU] = stack[base + 3]/*xtype*/;
65696581 newstack[6LLU] = stack[base + 8]/*ytype*/;
@@ -6570,10 +6582,10 @@
65706582 stack = newstack;
65716583 // set stack-base & callee-address
65726584 base = 4/*deloffset*/;
6573- label = 341LLU; // equtype
6585+ label = 342LLU; // equtype
65746586 break;
65756587 }
6576- case 496LLU: // copy-back deleter (equtype to equletdef)
6588+ case 498LLU: // copy-back deleter (equtype to equletdef)
65776589 {
65786590 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
65796591 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6585,10 +6597,10 @@
65856597 }
65866598 Free(15LLU + 1, sizeof(uint64_t), stack);
65876599 stack = oldstack;
6588- label = 494LLU; // continue to unroll stack
6600+ label = 496LLU; // continue to unroll stack
65896601 break;
65906602 }
6591- case 497LLU: // return from equtype to equletdef
6603+ case 499LLU: // return from equtype to equletdef
65926604 {
65936605 uint64_t *oldstack = (uint64_t *)stack[0];
65946606 // copy mutable arguments back from call to equtype
@@ -6602,9 +6614,9 @@
66026614 Free(15LLU + 1, sizeof(uint64_t), stack);
66036615 stack = oldstack;
66046616 // call and from equletdef
6605- stack[base + 15LLU] = 498LLU/*throw to this address*/;
6617+ stack[base + 15LLU] = 500LLU/*throw to this address*/;
66066618 stack[base + 16LLU] = base;
6607- stack[base + 17LLU] = 499LLU;
6619+ stack[base + 17LLU] = 501LLU;
66086620 // arguments for call to and
66096621 stack[base + 19LLU] = stack[base + 13]/*result*/;
66106622 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6613,22 +6625,22 @@
66136625 label = 18446744073709551613LLU; // and
66146626 break;
66156627 }
6616- case 498LLU: // copy-back deleter (and to equletdef)
6628+ case 500LLU: // copy-back deleter (and to equletdef)
66176629 {
66186630 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66196631 // copy mutable arguments back from call to and
6620- label = 494LLU; // continue to roll stack
6632+ label = 496LLU; // continue to roll stack
66216633 break;
66226634 }
6623- case 499LLU: // return from and to equletdef
6635+ case 501LLU: // return from and to equletdef
66246636 {
66256637 // copy mutable arguments back from call to and
66266638 // copy back results provided by call to and
66276639 stack[base + 13] = stack[base + 18LLU];
66286640 // call equ from equletdef
6629- stack[base + 15LLU] = 500LLU/*throw to this address*/;
6641+ stack[base + 15LLU] = 502LLU/*throw to this address*/;
66306642 stack[base + 16LLU] = base;
6631- stack[base + 17LLU] = 501LLU;
6643+ stack[base + 17LLU] = 503LLU;
66326644 // arguments for call to equ
66336645 stack[base + 19LLU] = stack[base + 4]/*xid*/;
66346646 stack[base + 20LLU] = stack[base + 9]/*yid*/;
@@ -6637,22 +6649,22 @@
66376649 label = 18446744073709551600LLU; // equ
66386650 break;
66396651 }
6640- case 500LLU: // copy-back deleter (equ to equletdef)
6652+ case 502LLU: // copy-back deleter (equ to equletdef)
66416653 {
66426654 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
66436655 // copy mutable arguments back from call to equ
6644- label = 494LLU; // continue to roll stack
6656+ label = 496LLU; // continue to roll stack
66456657 break;
66466658 }
6647- case 501LLU: // return from equ to equletdef
6659+ case 503LLU: // return from equ to equletdef
66486660 {
66496661 // copy mutable arguments back from call to equ
66506662 // copy back results provided by call to equ
66516663 stack[base + 14] = stack[base + 18LLU];
66526664 // call and from equletdef
6653- stack[base + 15LLU] = 502LLU/*throw to this address*/;
6665+ stack[base + 15LLU] = 504LLU/*throw to this address*/;
66546666 stack[base + 16LLU] = base;
6655- stack[base + 17LLU] = 503LLU;
6667+ stack[base + 17LLU] = 505LLU;
66566668 // arguments for call to and
66576669 stack[base + 19LLU] = stack[base + 13]/*result*/;
66586670 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6661,22 +6673,22 @@
66616673 label = 18446744073709551613LLU; // and
66626674 break;
66636675 }
6664- case 502LLU: // copy-back deleter (and to equletdef)
6676+ case 504LLU: // copy-back deleter (and to equletdef)
66656677 {
66666678 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66676679 // copy mutable arguments back from call to and
6668- label = 494LLU; // continue to roll stack
6680+ label = 496LLU; // continue to roll stack
66696681 break;
66706682 }
6671- case 503LLU: // return from and to equletdef
6683+ case 505LLU: // return from and to equletdef
66726684 {
66736685 // copy mutable arguments back from call to and
66746686 // copy back results provided by call to and
66756687 stack[base + 13] = stack[base + 18LLU];
66766688 // call equ from equletdef
6677- stack[base + 15LLU] = 504LLU/*throw to this address*/;
6689+ stack[base + 15LLU] = 506LLU/*throw to this address*/;
66786690 stack[base + 16LLU] = base;
6679- stack[base + 17LLU] = 505LLU;
6691+ stack[base + 17LLU] = 507LLU;
66806692 // arguments for call to equ
66816693 stack[base + 19LLU] = stack[base + 5]/*xindex*/;
66826694 stack[base + 20LLU] = stack[base + 10]/*yindex*/;
@@ -6685,22 +6697,22 @@
66856697 label = 18446744073709551600LLU; // equ
66866698 break;
66876699 }
6688- case 504LLU: // copy-back deleter (equ to equletdef)
6700+ case 506LLU: // copy-back deleter (equ to equletdef)
66896701 {
66906702 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
66916703 // copy mutable arguments back from call to equ
6692- label = 494LLU; // continue to roll stack
6704+ label = 496LLU; // continue to roll stack
66936705 break;
66946706 }
6695- case 505LLU: // return from equ to equletdef
6707+ case 507LLU: // return from equ to equletdef
66966708 {
66976709 // copy mutable arguments back from call to equ
66986710 // copy back results provided by call to equ
66996711 stack[base + 14] = stack[base + 18LLU];
67006712 // call and from equletdef
6701- stack[base + 15LLU] = 506LLU/*throw to this address*/;
6713+ stack[base + 15LLU] = 508LLU/*throw to this address*/;
67026714 stack[base + 16LLU] = base;
6703- stack[base + 17LLU] = 507LLU;
6715+ stack[base + 17LLU] = 509LLU;
67046716 // arguments for call to and
67056717 stack[base + 19LLU] = stack[base + 13]/*result*/;
67066718 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6709,22 +6721,22 @@
67096721 label = 18446744073709551613LLU; // and
67106722 break;
67116723 }
6712- case 506LLU: // copy-back deleter (and to equletdef)
6724+ case 508LLU: // copy-back deleter (and to equletdef)
67136725 {
67146726 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
67156727 // copy mutable arguments back from call to and
6716- label = 494LLU; // continue to roll stack
6728+ label = 496LLU; // continue to roll stack
67176729 break;
67186730 }
6719- case 507LLU: // return from and to equletdef
6731+ case 509LLU: // return from and to equletdef
67206732 {
67216733 // copy mutable arguments back from call to and
67226734 // copy back results provided by call to and
67236735 stack[base + 13] = stack[base + 18LLU];
67246736 // call equ from equletdef
6725- stack[base + 15LLU] = 508LLU/*throw to this address*/;
6737+ stack[base + 15LLU] = 510LLU/*throw to this address*/;
67266738 stack[base + 16LLU] = base;
6727- stack[base + 17LLU] = 509LLU;
6739+ stack[base + 17LLU] = 511LLU;
67286740 // arguments for call to equ
67296741 stack[base + 19LLU] = stack[base + 6]/*xmutable*/;
67306742 stack[base + 20LLU] = stack[base + 11]/*ymutable*/;
@@ -6733,22 +6745,22 @@
67336745 label = 18446744073709551600LLU; // equ
67346746 break;
67356747 }
6736- case 508LLU: // copy-back deleter (equ to equletdef)
6748+ case 510LLU: // copy-back deleter (equ to equletdef)
67376749 {
67386750 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
67396751 // copy mutable arguments back from call to equ
6740- label = 494LLU; // continue to roll stack
6752+ label = 496LLU; // continue to roll stack
67416753 break;
67426754 }
6743- case 509LLU: // return from equ to equletdef
6755+ case 511LLU: // return from equ to equletdef
67446756 {
67456757 // copy mutable arguments back from call to equ
67466758 // copy back results provided by call to equ
67476759 stack[base + 14] = stack[base + 18LLU];
67486760 // call and from equletdef
6749- stack[base + 15LLU] = 510LLU/*throw to this address*/;
6761+ stack[base + 15LLU] = 512LLU/*throw to this address*/;
67506762 stack[base + 16LLU] = base;
6751- stack[base + 17LLU] = 511LLU;
6763+ stack[base + 17LLU] = 513LLU;
67526764 // arguments for call to and
67536765 stack[base + 19LLU] = stack[base + 13]/*result*/;
67546766 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6757,22 +6769,22 @@
67576769 label = 18446744073709551613LLU; // and
67586770 break;
67596771 }
6760- case 510LLU: // copy-back deleter (and to equletdef)
6772+ case 512LLU: // copy-back deleter (and to equletdef)
67616773 {
67626774 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
67636775 // copy mutable arguments back from call to and
6764- label = 494LLU; // continue to roll stack
6776+ label = 496LLU; // continue to roll stack
67656777 break;
67666778 }
6767- case 511LLU: // return from and to equletdef
6779+ case 513LLU: // return from and to equletdef
67686780 {
67696781 // copy mutable arguments back from call to and
67706782 // copy back results provided by call to and
67716783 stack[base + 13] = stack[base + 18LLU];
67726784 // call equ from equletdef
6773- stack[base + 15LLU] = 512LLU/*throw to this address*/;
6785+ stack[base + 15LLU] = 514LLU/*throw to this address*/;
67746786 stack[base + 16LLU] = base;
6775- stack[base + 17LLU] = 513LLU;
6787+ stack[base + 17LLU] = 515LLU;
67766788 // arguments for call to equ
67776789 stack[base + 19LLU] = stack[base + 7]/*xsubstruct*/;
67786790 stack[base + 20LLU] = stack[base + 12]/*ysubstruct*/;
@@ -6781,22 +6793,22 @@
67816793 label = 18446744073709551600LLU; // equ
67826794 break;
67836795 }
6784- case 512LLU: // copy-back deleter (equ to equletdef)
6796+ case 514LLU: // copy-back deleter (equ to equletdef)
67856797 {
67866798 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
67876799 // copy mutable arguments back from call to equ
6788- label = 494LLU; // continue to roll stack
6800+ label = 496LLU; // continue to roll stack
67896801 break;
67906802 }
6791- case 513LLU: // return from equ to equletdef
6803+ case 515LLU: // return from equ to equletdef
67926804 {
67936805 // copy mutable arguments back from call to equ
67946806 // copy back results provided by call to equ
67956807 stack[base + 14] = stack[base + 18LLU];
67966808 // call and from equletdef
6797- stack[base + 15LLU] = 514LLU/*throw to this address*/;
6809+ stack[base + 15LLU] = 516LLU/*throw to this address*/;
67986810 stack[base + 16LLU] = base;
6799- stack[base + 17LLU] = 515LLU;
6811+ stack[base + 17LLU] = 517LLU;
68006812 // arguments for call to and
68016813 stack[base + 19LLU] = stack[base + 13]/*result*/;
68026814 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6805,35 +6817,35 @@
68056817 label = 18446744073709551613LLU; // and
68066818 break;
68076819 }
6808- case 514LLU: // copy-back deleter (and to equletdef)
6820+ case 516LLU: // copy-back deleter (and to equletdef)
68096821 {
68106822 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
68116823 // copy mutable arguments back from call to and
6812- label = 494LLU; // continue to roll stack
6824+ label = 496LLU; // continue to roll stack
68136825 break;
68146826 }
6815- case 515LLU: // return from and to equletdef
6827+ case 517LLU: // return from and to equletdef
68166828 {
68176829 // copy mutable arguments back from call to and
68186830 // copy back results provided by call to and
68196831 stack[base + 13] = stack[base + 18LLU];
6820- label = 517LLU; // skip deleter
6832+ label = 519LLU; // skip deleter
68216833 break;
68226834 }
6823- case 516LLU: // deleter
6835+ case 518LLU: // deleter
68246836 {
68256837 // throw from equletdef
68266838 if(!stack[base + 0])
68276839 {
68286840 fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6829- label = 494LLU; // skip, variable already deleted/unscoped
6841+ label = 496LLU; // skip, variable already deleted/unscoped
68306842 break;
68316843 }
68326844 fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6833- label = 494LLU; // continue unrolling stack, delete next variable
6845+ label = 496LLU; // continue unrolling stack, delete next variable
68346846 break;
68356847 }
6836- case 517LLU: // skipped deleter
6848+ case 519LLU: // skipped deleter
68376849 {
68386850 stack[base + 0] = stack[base + 13]/*result*/;
68396851 ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
@@ -6846,10 +6858,10 @@
68466858 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
68476859 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
68486860 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6849- label = 489LLU; // case complete
6861+ label = 491LLU; // case complete
68506862 break;
68516863 }
6852- case 491LLU: // copy-back deleter (switch)
6864+ case 493LLU: // copy-back deleter (switch)
68536865 {
68546866 ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
68556867 ((uint64_t **)(stack[base + 2]))[1][3] = stack[base + 11];
@@ -6861,15 +6873,15 @@
68616873 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
68626874 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
68636875 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6864- label = 488LLU; // continue to unroll stack
6876+ label = 490LLU; // continue to unroll stack
68656877 break;
68666878 }
6867- case 490LLU: // try next case
6879+ case 492LLU: // try next case
68686880 {
68696881 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
68706882 exit(-1);
68716883 }
6872- case 489LLU: // completed switch
6884+ case 491LLU: // completed switch
68736885 {
68746886 // return from equletdef
68756887 label = stack[base - 1];
@@ -6876,7 +6888,7 @@
68766888 base = stack[base - 2];
68776889 break;
68786890 }
6879- case 519LLU: // function copyletdef failed
6891+ case 521LLU: // function copyletdef failed
68806892 {
68816893 fprintf(stderr, "function copyletdef failed\n");
68826894 label = stack[base - 3];
@@ -6883,13 +6895,13 @@
68836895 base = stack[base - 2];
68846896 break;
68856897 }
6886- case 518LLU: // copyletdef
6898+ case 520LLU: // copyletdef
68876899 {
68886900 //#define res0 0
68896901 //#define arg0 1
68906902 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
68916903 {
6892- label = 521LLU; // jump to alternative
6904+ label = 523LLU; // jump to alternative
68936905 break;
68946906 }
68956907
@@ -6903,7 +6915,7 @@
69036915 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
69046916 if(!newstack)
69056917 {
6906- label = 522LLU; // throw: begin to unroll stack
6918+ label = 524LLU; // throw: begin to unroll stack
69076919 break;
69086920 }
69096921
@@ -6910,18 +6922,18 @@
69106922 newstack[15LLU] = 9876543210LLU; // overflow-marker
69116923 // call copytype from copyletdef
69126924 newstack[0] = (uint64_t)stack; // backup stack location
6913- newstack[1] = 523LLU;
6925+ newstack[1] = 525LLU;
69146926 newstack[2] = base;
6915- newstack[3] = 524LLU;
6927+ newstack[3] = 526LLU;
69166928 // arguments for call to copytype
69176929 newstack[5LLU] = stack[base + 2]/*type*/;
69186930 stack = newstack;
69196931 // set stack-base & callee-address
69206932 base = 4/*deloffset*/;
6921- label = 326LLU; // copytype
6933+ label = 327LLU; // copytype
69226934 break;
69236935 }
6924- case 523LLU: // copy-back deleter (copytype to copyletdef)
6936+ case 525LLU: // copy-back deleter (copytype to copyletdef)
69256937 {
69266938 fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
69276939 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6933,10 +6945,10 @@
69336945 }
69346946 Free(15LLU + 1, sizeof(uint64_t), stack);
69356947 stack = oldstack;
6936- label = 522LLU; // continue to unroll stack
6948+ label = 524LLU; // continue to unroll stack
69376949 break;
69386950 }
6939- case 524LLU: // return from copytype to copyletdef
6951+ case 526LLU: // return from copytype to copyletdef
69406952 {
69416953 uint64_t *oldstack = (uint64_t *)stack[0];
69426954 // copy mutable arguments back from call to copytype
@@ -6949,16 +6961,16 @@
69496961 }
69506962 Free(15LLU + 1, sizeof(uint64_t), stack);
69516963 stack = oldstack;
6952- label = 526LLU; // skip deleter
6964+ label = 528LLU; // skip deleter
69536965 break;
69546966 }
6955- case 525LLU: // deleter
6967+ case 527LLU: // deleter
69566968 {
69576969 // throw from copyletdef
69586970 if(!stack[base + 0])
69596971 {
69606972 fprintf(stderr, "in function copyletdef: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6961- label = 522LLU; // skip, variable already deleted/unscoped
6973+ label = 524LLU; // skip, variable already deleted/unscoped
69626974 break;
69636975 }
69646976 fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");
@@ -6968,28 +6980,28 @@
69686980 newstack[0] = (uint64_t)stack; // backup stack location
69696981 newstack[1] = 1234567890;
69706982 newstack[2] = base;
6971- newstack[3] = 527LLU;
6983+ newstack[3] = 529LLU;
69726984 stack = newstack;
69736985 // set stack-base & callee-address
69746986 base = 4/*deloffset*/;
6975- label = 455LLU; // ~letdef
6987+ label = 457LLU; // ~letdef
69766988 break;
69776989 }
6978- case 527LLU: // return from ~letdef to copyletdef
6990+ case 529LLU: // return from ~letdef to copyletdef
69796991 {
69806992 stack = (uint64_t *)stack[0];
69816993 // releasing toplevel container
69826994 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
69836995
6984- label = 522LLU; // continue unrolling stack, delete next variable
6996+ label = 524LLU; // continue unrolling stack, delete next variable
69856997 break;
69866998 }
6987- case 526LLU: // skipped deleter
6999+ case 528LLU: // skipped deleter
69887000 {
69897001 // construct letdef.letdef
69907002 if(!(stack[base + 0] = construct(5)))
69917003 {
6992- label = 522LLU; // throw: begin to unroll stack
7004+ label = 524LLU; // throw: begin to unroll stack
69937005 break;
69947006 }
69957007
@@ -7005,10 +7017,10 @@
70057017 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
70067018 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
70077019 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7008- label = 520LLU; // case complete
7020+ label = 522LLU; // case complete
70097021 break;
70107022 }
7011- case 522LLU: // copy-back deleter (switch)
7023+ case 524LLU: // copy-back deleter (switch)
70127024 {
70137025 ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
70147026 ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 5];
@@ -7015,15 +7027,15 @@
70157027 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
70167028 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
70177029 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7018- label = 519LLU; // continue to unroll stack
7030+ label = 521LLU; // continue to unroll stack
70197031 break;
70207032 }
7021- case 521LLU: // try next case
7033+ case 523LLU: // try next case
70227034 {
70237035 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
70247036 exit(-1);
70257037 }
7026- case 520LLU: // completed switch
7038+ case 522LLU: // completed switch
70277039 {
70287040 // return from copyletdef
70297041 label = stack[base - 1];
@@ -7030,7 +7042,7 @@
70307042 base = stack[base - 2];
70317043 break;
70327044 }
7033- case 528LLU: // ~scope
7045+ case 530LLU: // ~scope
70347046 {
70357047 if(stack[base + 0]/*variant-nr*/ >= 1)
70367048 {
@@ -7037,23 +7049,23 @@
70377049 fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
70387050 exit(-1);
70397051 }
7040- label = 528LLU + 1LLU + stack[base + 0]/*variant-nr*/;
7052+ label = 530LLU + 1LLU + stack[base + 0]/*variant-nr*/;
70417053 break;
70427054 }
7043- case 528LLU + 1LLU + 0LLU: // ~scope.scope
7055+ case 530LLU + 1LLU + 0LLU: // ~scope.scope
70447056 {
70457057 // release element deleteaddr
70467058 // release element letdefs
70477059 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[1/*element-nr*/];
70487060 // delete list
7049- label = 530LLU; // start to repeat
7061+ label = 532LLU; // start to repeat
70507062 break;
70517063 }
7052- case 530LLU: // repeat from here
7064+ case 532LLU: // repeat from here
70537065 {
70547066 if(!stack[base + 0])
70557067 {
7056- label = 531LLU; // break loop
7068+ label = 533LLU; // break loop
70577069 break;
70587070 }
70597071
@@ -7064,14 +7076,14 @@
70647076 newstack[0] = (uint64_t)stack; // backup stack location
70657077 newstack[1] = 1234567890;
70667078 newstack[2] = base;
7067- newstack[3] = 532LLU;
7079+ newstack[3] = 534LLU;
70687080 stack = newstack;
70697081 // set stack-base & callee-address
70707082 base = 4/*deloffset*/;
7071- label = 455LLU; // ~letdef
7083+ label = 457LLU; // ~letdef
70727084 break;
70737085 }
7074- case 532LLU: // return from ~letdef to scope
7086+ case 534LLU: // return from ~letdef to scope
70757087 {
70767088 stack = (uint64_t *)stack[0];
70777089 // releasing toplevel container
@@ -7082,10 +7094,10 @@
70827094 stack[base + 0] = (uint64_t)list->next;
70837095 Free(1, sizeof(struct listnode), list);
70847096 }
7085- label = 530LLU; // repeat
7097+ label = 532LLU; // repeat
70867098 break;
70877099 }
7088- case 531LLU: // loop finished
7100+ case 533LLU: // loop finished
70897101 {
70907102 // release variant container
70917103 Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
@@ -7093,7 +7105,7 @@
70937105 base = stack[base - 2];
70947106 break;
70957107 }
7096- case 534LLU: // function emptyscope failed
7108+ case 536LLU: // function emptyscope failed
70977109 {
70987110 fprintf(stderr, "function emptyscope failed\n");
70997111 label = stack[base - 3];
@@ -7100,50 +7112,50 @@
71007112 base = stack[base - 2];
71017113 break;
71027114 }
7103- case 533LLU: // emptyscope
7115+ case 535LLU: // emptyscope
71047116 {
71057117 //#define res0 0
7106- label = 536LLU; // skip deleter
7118+ label = 538LLU; // skip deleter
71077119 break;
71087120 }
7109- case 535LLU: // deleter
7121+ case 537LLU: // deleter
71107122 {
71117123 // throw from emptyscope
71127124 if(!stack[base + 1])
71137125 {
71147126 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7115- label = 534LLU; // skip, variable already deleted/unscoped
7127+ label = 536LLU; // skip, variable already deleted/unscoped
71167128 break;
71177129 }
71187130 fprintf(stderr, "in function emptyscope: unrolling stack, variable u64 \n");
7119- label = 534LLU; // continue unrolling stack, delete next variable
7131+ label = 536LLU; // continue unrolling stack, delete next variable
71207132 break;
71217133 }
7122- case 536LLU: // skipped deleter
7134+ case 538LLU: // skipped deleter
71237135 {
71247136 stack[base + 1] = 1234567890;
7125- label = 538LLU; // skip deleter
7137+ label = 540LLU; // skip deleter
71267138 break;
71277139 }
7128- case 537LLU: // deleter
7140+ case 539LLU: // deleter
71297141 {
71307142 // throw from emptyscope
71317143 if(!stack[base + 2])
71327144 {
71337145 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
7134- label = 535LLU; // skip, variable already deleted/unscoped
7146+ label = 537LLU; // skip, variable already deleted/unscoped
71357147 break;
71367148 }
71377149 fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] \n");
71387150 // delete list
7139- label = 539LLU; // start to repeat
7151+ label = 541LLU; // start to repeat
71407152 break;
71417153 }
7142- case 539LLU: // repeat from here
7154+ case 541LLU: // repeat from here
71437155 {
71447156 if(!stack[base + 2])
71457157 {
7146- label = 540LLU; // break loop
7158+ label = 542LLU; // break loop
71477159 break;
71487160 }
71497161
@@ -7154,14 +7166,14 @@
71547166 newstack[0] = (uint64_t)stack; // backup stack location
71557167 newstack[1] = 1234567890;
71567168 newstack[2] = base;
7157- newstack[3] = 541LLU;
7169+ newstack[3] = 543LLU;
71587170 stack = newstack;
71597171 // set stack-base & callee-address
71607172 base = 4/*deloffset*/;
7161- label = 455LLU; // ~letdef
7173+ label = 457LLU; // ~letdef
71627174 break;
71637175 }
7164- case 541LLU: // return from ~letdef to emptyscope
7176+ case 543LLU: // return from ~letdef to emptyscope
71657177 {
71667178 stack = (uint64_t *)stack[0];
71677179 // releasing toplevel container
@@ -7172,27 +7184,27 @@
71727184 stack[base + 2] = (uint64_t)list->next;
71737185 Free(1, sizeof(struct listnode), list);
71747186 }
7175- label = 539LLU; // repeat
7187+ label = 541LLU; // repeat
71767188 break;
71777189 }
7178- case 540LLU: // loop finished
7190+ case 542LLU: // loop finished
71797191 {
7180- label = 535LLU; // continue unrolling stack, delete next variable
7192+ label = 537LLU; // continue unrolling stack, delete next variable
71817193 break;
71827194 }
7183- case 538LLU: // skipped deleter
7195+ case 540LLU: // skipped deleter
71847196 {
71857197 stack[base + 2] = 0;
7186- label = 543LLU; // skip deleter
7198+ label = 545LLU; // skip deleter
71877199 break;
71887200 }
7189- case 542LLU: // deleter
7201+ case 544LLU: // deleter
71907202 {
71917203 // throw from emptyscope
71927204 if(!stack[base + 0])
71937205 {
71947206 fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7195- label = 537LLU; // skip, variable already deleted/unscoped
7207+ label = 539LLU; // skip, variable already deleted/unscoped
71967208 break;
71977209 }
71987210 fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");
@@ -7202,28 +7214,28 @@
72027214 newstack[0] = (uint64_t)stack; // backup stack location
72037215 newstack[1] = 1234567890;
72047216 newstack[2] = base;
7205- newstack[3] = 544LLU;
7217+ newstack[3] = 546LLU;
72067218 stack = newstack;
72077219 // set stack-base & callee-address
72087220 base = 4/*deloffset*/;
7209- label = 528LLU; // ~scope
7221+ label = 530LLU; // ~scope
72107222 break;
72117223 }
7212- case 544LLU: // return from ~scope to emptyscope
7224+ case 546LLU: // return from ~scope to emptyscope
72137225 {
72147226 stack = (uint64_t *)stack[0];
72157227 // releasing toplevel container
72167228 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
72177229
7218- label = 537LLU; // continue unrolling stack, delete next variable
7230+ label = 539LLU; // continue unrolling stack, delete next variable
72197231 break;
72207232 }
7221- case 543LLU: // skipped deleter
7233+ case 545LLU: // skipped deleter
72227234 {
72237235 // construct scope.scope
72247236 if(!(stack[base + 0] = construct(2)))
72257237 {
7226- label = 537LLU; // throw: begin to unroll stack
7238+ label = 539LLU; // throw: begin to unroll stack
72277239 break;
72287240 }
72297241
@@ -7236,7 +7248,7 @@
72367248 base = stack[base - 2];
72377249 break;
72387250 }
7239- case 546LLU: // function chainscope failed
7251+ case 548LLU: // function chainscope failed
72407252 {
72417253 fprintf(stderr, "function chainscope failed\n");
72427254 label = stack[base - 3];
@@ -7243,32 +7255,32 @@
72437255 base = stack[base - 2];
72447256 break;
72457257 }
7246- case 545LLU: // chainscope
7258+ case 547LLU: // chainscope
72477259 {
72487260 //#define res0 0
72497261 //#define arg0 1
7250- label = 548LLU; // skip deleter
7262+ label = 550LLU; // skip deleter
72517263 break;
72527264 }
7253- case 547LLU: // deleter
7265+ case 549LLU: // deleter
72547266 {
72557267 // throw from chainscope
72567268 if(!stack[base + 2])
72577269 {
72587270 fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
7259- label = 546LLU; // skip, variable already deleted/unscoped
7271+ label = 548LLU; // skip, variable already deleted/unscoped
72607272 break;
72617273 }
72627274 fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] \n");
72637275 // delete list
7264- label = 549LLU; // start to repeat
7276+ label = 551LLU; // start to repeat
72657277 break;
72667278 }
7267- case 549LLU: // repeat from here
7279+ case 551LLU: // repeat from here
72687280 {
72697281 if(!stack[base + 2])
72707282 {
7271- label = 550LLU; // break loop
7283+ label = 552LLU; // break loop
72727284 break;
72737285 }
72747286
@@ -7279,14 +7291,14 @@
72797291 newstack[0] = (uint64_t)stack; // backup stack location
72807292 newstack[1] = 1234567890;
72817293 newstack[2] = base;
7282- newstack[3] = 551LLU;
7294+ newstack[3] = 553LLU;
72837295 stack = newstack;
72847296 // set stack-base & callee-address
72857297 base = 4/*deloffset*/;
7286- label = 455LLU; // ~letdef
7298+ label = 457LLU; // ~letdef
72877299 break;
72887300 }
7289- case 551LLU: // return from ~letdef to chainscope
7301+ case 553LLU: // return from ~letdef to chainscope
72907302 {
72917303 stack = (uint64_t *)stack[0];
72927304 // releasing toplevel container
@@ -7297,27 +7309,27 @@
72977309 stack[base + 2] = (uint64_t)list->next;
72987310 Free(1, sizeof(struct listnode), list);
72997311 }
7300- label = 549LLU; // repeat
7312+ label = 551LLU; // repeat
73017313 break;
73027314 }
7303- case 550LLU: // loop finished
7315+ case 552LLU: // loop finished
73047316 {
7305- label = 546LLU; // continue unrolling stack, delete next variable
7317+ label = 548LLU; // continue unrolling stack, delete next variable
73067318 break;
73077319 }
7308- case 548LLU: // skipped deleter
7320+ case 550LLU: // skipped deleter
73097321 {
73107322 stack[base + 2] = 0;
7311- label = 553LLU; // skip deleter
7323+ label = 555LLU; // skip deleter
73127324 break;
73137325 }
7314- case 552LLU: // deleter
7326+ case 554LLU: // deleter
73157327 {
73167328 // throw from chainscope
73177329 if(!stack[base + 0])
73187330 {
73197331 fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7320- label = 547LLU; // skip, variable already deleted/unscoped
7332+ label = 549LLU; // skip, variable already deleted/unscoped
73217333 break;
73227334 }
73237335 fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");
@@ -7327,28 +7339,28 @@
73277339 newstack[0] = (uint64_t)stack; // backup stack location
73287340 newstack[1] = 1234567890;
73297341 newstack[2] = base;
7330- newstack[3] = 554LLU;
7342+ newstack[3] = 556LLU;
73317343 stack = newstack;
73327344 // set stack-base & callee-address
73337345 base = 4/*deloffset*/;
7334- label = 528LLU; // ~scope
7346+ label = 530LLU; // ~scope
73357347 break;
73367348 }
7337- case 554LLU: // return from ~scope to chainscope
7349+ case 556LLU: // return from ~scope to chainscope
73387350 {
73397351 stack = (uint64_t *)stack[0];
73407352 // releasing toplevel container
73417353 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
73427354
7343- label = 547LLU; // continue unrolling stack, delete next variable
7355+ label = 549LLU; // continue unrolling stack, delete next variable
73447356 break;
73457357 }
7346- case 553LLU: // skipped deleter
7358+ case 555LLU: // skipped deleter
73477359 {
73487360 // construct scope.scope
73497361 if(!(stack[base + 0] = construct(2)))
73507362 {
7351- label = 547LLU; // throw: begin to unroll stack
7363+ label = 549LLU; // throw: begin to unroll stack
73527364 break;
73537365 }
73547366
@@ -7361,7 +7373,7 @@
73617373 base = stack[base - 2];
73627374 break;
73637375 }
7364- case 556LLU: // function linkscope failed
7376+ case 558LLU: // function linkscope failed
73657377 {
73667378 fprintf(stderr, "function linkscope failed\n");
73677379 label = stack[base - 3];
@@ -7368,13 +7380,13 @@
73687380 base = stack[base - 2];
73697381 break;
73707382 }
7371- case 555LLU: // linkscope
7383+ case 557LLU: // linkscope
73727384 {
73737385 //#define res0 0
73747386 //#define arg0 1
73757387 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
73767388 {
7377- label = 558LLU; // jump to alternative
7389+ label = 560LLU; // jump to alternative
73787390 break;
73797391 }
73807392
@@ -7383,24 +7395,24 @@
73837395
73847396 // case
73857397 // call chainscope from linkscope
7386- stack[base + 4LLU] = 560LLU/*throw to this address*/;
7398+ stack[base + 4LLU] = 562LLU/*throw to this address*/;
73877399 stack[base + 5LLU] = base;
7388- stack[base + 6LLU] = 561LLU;
7400+ stack[base + 6LLU] = 563LLU;
73897401 // arguments for call to chainscope
73907402 stack[base + 8LLU] = stack[base + 2]/*labelthrow*/;
73917403 // set stack-base & callee-address
73927404 base += 7LLU;
7393- label = 545LLU; // chainscope
7405+ label = 547LLU; // chainscope
73947406 break;
73957407 }
7396- case 560LLU: // copy-back deleter (chainscope to linkscope)
7408+ case 562LLU: // copy-back deleter (chainscope to linkscope)
73977409 {
73987410 fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
73997411 // copy mutable arguments back from call to chainscope
7400- label = 559LLU; // continue to roll stack
7412+ label = 561LLU; // continue to roll stack
74017413 break;
74027414 }
7403- case 561LLU: // return from chainscope to linkscope
7415+ case 563LLU: // return from chainscope to linkscope
74047416 {
74057417 // copy mutable arguments back from call to chainscope
74067418 // copy back results provided by call to chainscope
@@ -7407,22 +7419,22 @@
74077419 stack[base + 0] = stack[base + 7LLU];
74087420 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74097421 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7410- label = 557LLU; // case complete
7422+ label = 559LLU; // case complete
74117423 break;
74127424 }
7413- case 559LLU: // copy-back deleter (switch)
7425+ case 561LLU: // copy-back deleter (switch)
74147426 {
74157427 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74167428 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7417- label = 556LLU; // continue to unroll stack
7429+ label = 558LLU; // continue to unroll stack
74187430 break;
74197431 }
7420- case 558LLU: // try next case
7432+ case 560LLU: // try next case
74217433 {
74227434 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
74237435 exit(-1);
74247436 }
7425- case 557LLU: // completed switch
7437+ case 559LLU: // completed switch
74267438 {
74277439 // return from linkscope
74287440 label = stack[base - 1];
@@ -7429,7 +7441,7 @@
74297441 base = stack[base - 2];
74307442 break;
74317443 }
7432- case 563LLU: // function getdeladdr failed
7444+ case 565LLU: // function getdeladdr failed
74337445 {
74347446 fprintf(stderr, "function getdeladdr failed\n");
74357447 label = stack[base - 3];
@@ -7436,13 +7448,13 @@
74367448 base = stack[base - 2];
74377449 break;
74387450 }
7439- case 562LLU: // getdeladdr
7451+ case 564LLU: // getdeladdr
74407452 {
74417453 //#define res0 0
74427454 //#define arg0 1
74437455 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
74447456 {
7445- label = 565LLU; // jump to alternative
7457+ label = 567LLU; // jump to alternative
74467458 break;
74477459 }
74487460
@@ -7450,43 +7462,43 @@
74507462 /*letdefs*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*scope*/))[1][1]/*letdefs*/;
74517463
74527464 // case
7453- label = 568LLU; // skip deleter
7465+ label = 570LLU; // skip deleter
74547466 break;
74557467 }
7456- case 567LLU: // deleter
7468+ case 569LLU: // deleter
74577469 {
74587470 // throw from getdeladdr
74597471 if(!stack[base + 0])
74607472 {
74617473 fprintf(stderr, "in function getdeladdr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7462- label = 566LLU; // skip, variable already deleted/unscoped
7474+ label = 568LLU; // skip, variable already deleted/unscoped
74637475 break;
74647476 }
74657477 fprintf(stderr, "in function getdeladdr: unrolling stack, variable u64 \n");
7466- label = 566LLU; // continue unrolling stack, delete next variable
7478+ label = 568LLU; // continue unrolling stack, delete next variable
74677479 break;
74687480 }
7469- case 568LLU: // skipped deleter
7481+ case 570LLU: // skipped deleter
74707482 {
74717483 stack[base + 0] = stack[base + 2]/*labelthrow*/;
74727484 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74737485 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7474- label = 564LLU; // case complete
7486+ label = 566LLU; // case complete
74757487 break;
74767488 }
7477- case 566LLU: // copy-back deleter (switch)
7489+ case 568LLU: // copy-back deleter (switch)
74787490 {
74797491 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
74807492 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7481- label = 563LLU; // continue to unroll stack
7493+ label = 565LLU; // continue to unroll stack
74827494 break;
74837495 }
7484- case 565LLU: // try next case
7496+ case 567LLU: // try next case
74857497 {
74867498 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
74877499 exit(-1);
74887500 }
7489- case 564LLU: // completed switch
7501+ case 566LLU: // completed switch
74907502 {
74917503 // return from getdeladdr
74927504 label = stack[base - 1];
@@ -7493,7 +7505,7 @@
74937505 base = stack[base - 2];
74947506 break;
74957507 }
7496- case 570LLU: // function existslet failed
7508+ case 572LLU: // function existslet failed
74977509 {
74987510 fprintf(stderr, "function existslet failed\n");
74997511 label = stack[base - 3];
@@ -7500,39 +7512,39 @@
75007512 base = stack[base - 2];
75017513 break;
75027514 }
7503- case 569LLU: // existslet
7515+ case 571LLU: // existslet
75047516 {
75057517 //#define res0 0
75067518 //#define arg0 1
75077519 //#define arg1 2
7508- label = 572LLU; // skip deleter
7520+ label = 574LLU; // skip deleter
75097521 break;
75107522 }
7511- case 571LLU: // deleter
7523+ case 573LLU: // deleter
75127524 {
75137525 // throw from existslet
75147526 if(!stack[base + 3])
75157527 {
75167528 fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7517- label = 570LLU; // skip, variable already deleted/unscoped
7529+ label = 572LLU; // skip, variable already deleted/unscoped
75187530 break;
75197531 }
75207532 fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7521- label = 570LLU; // continue unrolling stack, delete next variable
7533+ label = 572LLU; // continue unrolling stack, delete next variable
75227534 break;
75237535 }
7524- case 572LLU: // skipped deleter
7536+ case 574LLU: // skipped deleter
75257537 {
75267538 stack[base + 3] = 0;
75277539 flippedassign(stack[base + 1]/*letdefs*/, &stack[base + 4]);
7528- label = 573LLU; // start to repeat
7540+ label = 575LLU; // start to repeat
75297541 break;
75307542 }
7531- case 573LLU: // repeat from here
7543+ case 575LLU: // repeat from here
75327544 {
75337545 if(!stack[base + 4])
75347546 {
7535- label = 574LLU; // break loop
7547+ label = 576LLU; // break loop
75367548 break;
75377549 }
75387550
@@ -7542,19 +7554,19 @@
75427554 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
75437555 if(!stack[base + 3]/*found*/)
75447556 {
7545- label = 575LLU; // jump to alternative
7557+ label = 578LLU; // jump to alternative
75467558 break;
75477559 }
75487560
75497561 // consequent
7550- label = 576LLU; // consequent complete
7562+ label = 579LLU; // consequent complete
75517563 break;
75527564 }
7553- case 575LLU: // alternative
7565+ case 578LLU: // alternative
75547566 {
75557567 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
75567568 {
7557- label = 578LLU; // jump to alternative
7569+ label = 581LLU; // jump to alternative
75587570 break;
75597571 }
75607572
@@ -7566,9 +7578,9 @@
75667578
75677579 // case
75687580 // call equ from existslet
7569- stack[base + 12LLU] = 580LLU/*throw to this address*/;
7581+ stack[base + 12LLU] = 583LLU/*throw to this address*/;
75707582 stack[base + 13LLU] = base;
7571- stack[base + 14LLU] = 581LLU;
7583+ stack[base + 14LLU] = 584LLU;
75727584 // arguments for call to equ
75737585 stack[base + 16LLU] = stack[base + 8]/*curid*/;
75747586 stack[base + 17LLU] = stack[base + 2]/*id*/;
@@ -7577,14 +7589,14 @@
75777589 label = 18446744073709551600LLU; // equ
75787590 break;
75797591 }
7580- case 580LLU: // copy-back deleter (equ to existslet)
7592+ case 583LLU: // copy-back deleter (equ to existslet)
75817593 {
75827594 fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
75837595 // copy mutable arguments back from call to equ
7584- label = 579LLU; // continue to roll stack
7596+ label = 582LLU; // continue to roll stack
75857597 break;
75867598 }
7587- case 581LLU: // return from equ to existslet
7599+ case 584LLU: // return from equ to existslet
75887600 {
75897601 // copy mutable arguments back from call to equ
75907602 // copy back results provided by call to equ
@@ -7594,10 +7606,10 @@
75947606 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
75957607 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
75967608 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7597- label = 577LLU; // case complete
7609+ label = 580LLU; // case complete
75987610 break;
75997611 }
7600- case 579LLU: // copy-back deleter (switch)
7612+ case 582LLU: // copy-back deleter (switch)
76017613 {
76027614 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
76037615 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
@@ -7604,44 +7616,50 @@
76047616 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
76057617 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
76067618 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7607- label = 571LLU; // continue to unroll stack
7619+ label = 577LLU; // continue to unroll stack
76087620 break;
76097621 }
7610- case 578LLU: // try next case
7622+ case 581LLU: // try next case
76117623 {
76127624 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
76137625 exit(-1);
76147626 }
7615- case 577LLU: // completed switch
7627+ case 580LLU: // completed switch
76167628 {
7617- label = 576LLU; // alternative complete
7629+ label = 579LLU; // alternative complete
76187630 break;
76197631 }
7620- case 576LLU: // completed if-then-else
7632+ case 579LLU: // completed if-then-else
76217633 {
76227634 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
7623- label = 573LLU; // repeat
7635+ label = 575LLU; // repeat
76247636 break;
76257637 }
7626- case 574LLU: // loop finished
7638+ case 577LLU: // copy-back deleter for while next
76277639 {
7628- label = 583LLU; // skip deleter
7640+ ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
7641+ label = 573LLU; // continue to unroll stack
76297642 break;
76307643 }
7631- case 582LLU: // deleter
7644+ case 576LLU: // loop finished
76327645 {
7646+ label = 586LLU; // skip deleter
7647+ break;
7648+ }
7649+ case 585LLU: // deleter
7650+ {
76337651 // throw from existslet
76347652 if(!stack[base + 0])
76357653 {
76367654 fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7637- label = 571LLU; // skip, variable already deleted/unscoped
7655+ label = 573LLU; // skip, variable already deleted/unscoped
76387656 break;
76397657 }
76407658 fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7641- label = 571LLU; // continue unrolling stack, delete next variable
7659+ label = 573LLU; // continue unrolling stack, delete next variable
76427660 break;
76437661 }
7644- case 583LLU: // skipped deleter
7662+ case 586LLU: // skipped deleter
76457663 {
76467664 stack[base + 0] = stack[base + 3]/*found*/;
76477665 // return from existslet
@@ -7649,7 +7667,7 @@
76497667 base = stack[base - 2];
76507668 break;
76517669 }
7652- case 585LLU: // function FindLetNew failed
7670+ case 588LLU: // function FindLetNew failed
76537671 {
76547672 fprintf(stderr, "function FindLetNew failed\n");
76557673 label = stack[base - 3];
@@ -7656,7 +7674,7 @@
76567674 base = stack[base - 2];
76577675 break;
76587676 }
7659- case 584LLU: // FindLetNew
7677+ case 587LLU: // FindLetNew
76607678 {
76617679 //#define res0 0
76627680 //#define arg0 1
@@ -7664,87 +7682,87 @@
76647682 //#define arg2 3
76657683 //#define arg3 4
76667684 // call mkletdummy from FindLetNew
7667- stack[base + 6LLU] = 586LLU/*throw to this address*/;
7685+ stack[base + 6LLU] = 589LLU/*throw to this address*/;
76687686 stack[base + 7LLU] = base;
7669- stack[base + 8LLU] = 587LLU;
7687+ stack[base + 8LLU] = 590LLU;
76707688 // arguments for call to mkletdummy
76717689 // set stack-base & callee-address
76727690 base += 9LLU;
7673- label = 458LLU; // mkletdummy
7691+ label = 460LLU; // mkletdummy
76747692 break;
76757693 }
7676- case 586LLU: // copy-back deleter (mkletdummy to FindLetNew)
7694+ case 589LLU: // copy-back deleter (mkletdummy to FindLetNew)
76777695 {
76787696 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (mkletdummy to FindLetNew)\n");
76797697 // copy mutable arguments back from call to mkletdummy
7680- label = 585LLU; // continue to roll stack
7698+ label = 588LLU; // continue to roll stack
76817699 break;
76827700 }
7683- case 587LLU: // return from mkletdummy to FindLetNew
7701+ case 590LLU: // return from mkletdummy to FindLetNew
76847702 {
76857703 // copy mutable arguments back from call to mkletdummy
76867704 // copy back results provided by call to mkletdummy
76877705 stack[base + 5] = stack[base + 9LLU];
7688- label = 589LLU; // skip deleter
7706+ label = 592LLU; // skip deleter
76897707 break;
76907708 }
7691- case 588LLU: // deleter
7709+ case 591LLU: // deleter
76927710 {
76937711 // throw from FindLetNew
76947712 if(!stack[base + 6])
76957713 {
76967714 fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7697- label = 585LLU; // skip, variable already deleted/unscoped
7715+ label = 588LLU; // skip, variable already deleted/unscoped
76987716 break;
76997717 }
77007718 fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7701- label = 585LLU; // continue unrolling stack, delete next variable
7719+ label = 588LLU; // continue unrolling stack, delete next variable
77027720 break;
77037721 }
7704- case 589LLU: // skipped deleter
7722+ case 592LLU: // skipped deleter
77057723 {
77067724 stack[base + 6] = 0;
7707- label = 591LLU; // skip deleter
7725+ label = 594LLU; // skip deleter
77087726 break;
77097727 }
7710- case 590LLU: // deleter
7728+ case 593LLU: // deleter
77117729 {
77127730 // throw from FindLetNew
77137731 if(!stack[base + 7])
77147732 {
77157733 fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7716- label = 588LLU; // skip, variable already deleted/unscoped
7734+ label = 591LLU; // skip, variable already deleted/unscoped
77177735 break;
77187736 }
77197737 fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7720- label = 588LLU; // continue unrolling stack, delete next variable
7738+ label = 591LLU; // continue unrolling stack, delete next variable
77217739 break;
77227740 }
7723- case 591LLU: // skipped deleter
7741+ case 594LLU: // skipped deleter
77247742 {
77257743 stack[base + 7] = 0;
7726- label = 593LLU; // skip deleter
7744+ label = 596LLU; // skip deleter
77277745 break;
77287746 }
7729- case 592LLU: // deleter
7747+ case 595LLU: // deleter
77307748 {
77317749 // throw from FindLetNew
77327750 if(!stack[base + 8])
77337751 {
77347752 fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7735- label = 590LLU; // skip, variable already deleted/unscoped
7753+ label = 593LLU; // skip, variable already deleted/unscoped
77367754 break;
77377755 }
77387756 fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7739- label = 590LLU; // continue unrolling stack, delete next variable
7757+ label = 593LLU; // continue unrolling stack, delete next variable
77407758 break;
77417759 }
7742- case 593LLU: // skipped deleter
7760+ case 596LLU: // skipped deleter
77437761 {
77447762 stack[base + 8] = 0;
77457763 if(/*scope*/0 != ((uint64_t *)(stack[base + 4]/*SCOPE*/))[0])
77467764 {
7747- label = 595LLU; // jump to alternative
7765+ label = 598LLU; // jump to alternative
77487766 break;
77497767 }
77507768
@@ -7753,14 +7771,14 @@
77537771
77547772 // case
77557773 flippedassign(stack[base + 10]/*scope*/, &stack[base + 11]);
7756- label = 597LLU; // start to repeat
7774+ label = 600LLU; // start to repeat
77577775 break;
77587776 }
7759- case 597LLU: // repeat from here
7777+ case 600LLU: // repeat from here
77607778 {
77617779 if(!stack[base + 11])
77627780 {
7763- label = 598LLU; // break loop
7781+ label = 601LLU; // break loop
77647782 break;
77657783 }
77667784
@@ -7770,19 +7788,19 @@
77707788 stack[base + 11] = (uint64_t)(((const struct listnode *)(stack[base + 11]))->next);
77717789 if(!stack[base + 8]/*found*/)
77727790 {
7773- label = 599LLU; // jump to alternative
7791+ label = 603LLU; // jump to alternative
77747792 break;
77757793 }
77767794
77777795 // consequent
7778- label = 600LLU; // consequent complete
7796+ label = 604LLU; // consequent complete
77797797 break;
77807798 }
7781- case 599LLU: // alternative
7799+ case 603LLU: // alternative
77827800 {
77837801 if(/*letdef*/0 != ((uint64_t *)(stack[base + 12]/*letdef*/))[0])
77847802 {
7785- label = 602LLU; // jump to alternative
7803+ label = 606LLU; // jump to alternative
77867804 break;
77877805 }
77887806
@@ -7794,9 +7812,9 @@
77947812
77957813 // case
77967814 // call equ from FindLetNew
7797- stack[base + 19LLU] = 604LLU/*throw to this address*/;
7815+ stack[base + 19LLU] = 608LLU/*throw to this address*/;
77987816 stack[base + 20LLU] = base;
7799- stack[base + 21LLU] = 605LLU;
7817+ stack[base + 21LLU] = 609LLU;
78007818 // arguments for call to equ
78017819 stack[base + 23LLU] = stack[base + 15]/*curid*/;
78027820 stack[base + 24LLU] = stack[base + 2]/*id*/;
@@ -7805,14 +7823,14 @@
78057823 label = 18446744073709551600LLU; // equ
78067824 break;
78077825 }
7808- case 604LLU: // copy-back deleter (equ to FindLetNew)
7826+ case 608LLU: // copy-back deleter (equ to FindLetNew)
78097827 {
78107828 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
78117829 // copy mutable arguments back from call to equ
7812- label = 603LLU; // continue to roll stack
7830+ label = 607LLU; // continue to roll stack
78137831 break;
78147832 }
7815- case 605LLU: // return from equ to FindLetNew
7833+ case 609LLU: // return from equ to FindLetNew
78167834 {
78177835 // copy mutable arguments back from call to equ
78187836 // copy back results provided by call to equ
@@ -7819,30 +7837,30 @@
78197837 stack[base + 8] = stack[base + 22LLU];
78207838 if(!stack[base + 8]/*found*/)
78217839 {
7822- label = 606LLU; // jump to alternative
7840+ label = 610LLU; // jump to alternative
78237841 break;
78247842 }
78257843
78267844 // consequent
78277845 // call copyletdef from FindLetNew
7828- stack[base + 20LLU] = 608LLU/*throw to this address*/;
7846+ stack[base + 20LLU] = 612LLU/*throw to this address*/;
78297847 stack[base + 21LLU] = base;
7830- stack[base + 22LLU] = 609LLU;
7848+ stack[base + 22LLU] = 613LLU;
78317849 // arguments for call to copyletdef
78327850 stack[base + 24LLU] = stack[base + 12]/*letdef*/;
78337851 // set stack-base & callee-address
78347852 base += 23LLU;
7835- label = 518LLU; // copyletdef
7853+ label = 520LLU; // copyletdef
78367854 break;
78377855 }
7838- case 608LLU: // copy-back deleter (copyletdef to FindLetNew)
7856+ case 612LLU: // copy-back deleter (copyletdef to FindLetNew)
78397857 {
78407858 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
78417859 // copy mutable arguments back from call to copyletdef
7842- label = 603LLU; // continue to roll stack
7860+ label = 607LLU; // continue to roll stack
78437861 break;
78447862 }
7845- case 609LLU: // return from copyletdef to FindLetNew
7863+ case 613LLU: // return from copyletdef to FindLetNew
78467864 {
78477865 // copy mutable arguments back from call to copyletdef
78487866 // copy back results provided by call to copyletdef
@@ -7854,28 +7872,28 @@
78547872 newstack[0] = (uint64_t)stack; // backup stack location
78557873 newstack[1] = 1234567890;
78567874 newstack[2] = base;
7857- newstack[3] = 610LLU;
7875+ newstack[3] = 614LLU;
78587876 stack = newstack;
78597877 // set stack-base & callee-address
78607878 base = 4/*deloffset*/;
7861- label = 455LLU; // ~letdef
7879+ label = 457LLU; // ~letdef
78627880 break;
78637881 }
7864- case 610LLU: // return from ~letdef to FindLetNew
7882+ case 614LLU: // return from ~letdef to FindLetNew
78657883 {
78667884 stack = (uint64_t *)stack[0];
78677885 // releasing toplevel container
78687886 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 19] - sizeof(uint64_t) * 4));
78697887
7870- label = 607LLU; // consequent complete
7888+ label = 611LLU; // consequent complete
78717889 break;
78727890 }
7873- case 606LLU: // alternative
7891+ case 610LLU: // alternative
78747892 {
7875- label = 607LLU; // alternative complete
7893+ label = 611LLU; // alternative complete
78767894 break;
78777895 }
7878- case 607LLU: // completed if-then-else
7896+ case 611LLU: // completed if-then-else
78797897 {
78807898 ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
78817899 ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];
@@ -7882,10 +7900,10 @@
78827900 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
78837901 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
78847902 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7885- label = 601LLU; // case complete
7903+ label = 605LLU; // case complete
78867904 break;
78877905 }
7888- case 603LLU: // copy-back deleter (switch)
7906+ case 607LLU: // copy-back deleter (switch)
78897907 {
78907908 ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
78917909 ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];
@@ -7892,67 +7910,73 @@
78927910 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
78937911 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
78947912 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7895- label = 596LLU; // continue to unroll stack
7913+ label = 602LLU; // continue to unroll stack
78967914 break;
78977915 }
7898- case 602LLU: // try next case
7916+ case 606LLU: // try next case
78997917 {
79007918 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
79017919 exit(-1);
79027920 }
7903- case 601LLU: // completed switch
7921+ case 605LLU: // completed switch
79047922 {
7905- label = 600LLU; // alternative complete
7923+ label = 604LLU; // alternative complete
79067924 break;
79077925 }
7908- case 600LLU: // completed if-then-else
7926+ case 604LLU: // completed if-then-else
79097927 {
79107928 ((struct listnode *)(stack[base + 13]/*previous*/))->data = stack[base + 12];
7911- label = 597LLU; // repeat
7929+ label = 600LLU; // repeat
79127930 break;
79137931 }
7914- case 598LLU: // loop finished
7932+ case 602LLU: // copy-back deleter for while next
79157933 {
7934+ ((struct listnode *)(stack[base + 13]/*previous*/))->data = stack[base + 12];
7935+ label = 599LLU; // continue to unroll stack
7936+ break;
7937+ }
7938+ case 601LLU: // loop finished
7939+ {
79167940 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
79177941 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7918- label = 594LLU; // case complete
7942+ label = 597LLU; // case complete
79197943 break;
79207944 }
7921- case 596LLU: // copy-back deleter (switch)
7945+ case 599LLU: // copy-back deleter (switch)
79227946 {
79237947 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
79247948 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7925- label = 592LLU; // continue to unroll stack
7949+ label = 595LLU; // continue to unroll stack
79267950 break;
79277951 }
7928- case 595LLU: // try next case
7952+ case 598LLU: // try next case
79297953 {
79307954 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
79317955 exit(-1);
79327956 }
7933- case 594LLU: // completed switch
7957+ case 597LLU: // completed switch
79347958 {
79357959 if(!stack[base + 8]/*found*/)
79367960 {
7937- label = 611LLU; // jump to alternative
7961+ label = 615LLU; // jump to alternative
79387962 break;
79397963 }
79407964
79417965 // consequent
7942- label = 612LLU; // consequent complete
7966+ label = 616LLU; // consequent complete
79437967 break;
79447968 }
7945- case 611LLU: // alternative
7969+ case 615LLU: // alternative
79467970 {
79477971 flippedassign(stack[base + 3]/*scopes*/, &stack[base + 9]);
7948- label = 613LLU; // start to repeat
7972+ label = 617LLU; // start to repeat
79497973 break;
79507974 }
7951- case 613LLU: // repeat from here
7975+ case 617LLU: // repeat from here
79527976 {
79537977 if(!stack[base + 9])
79547978 {
7955- label = 614LLU; // break loop
7979+ label = 618LLU; // break loop
79567980 break;
79577981 }
79587982
@@ -7962,19 +7986,19 @@
79627986 stack[base + 9] = (uint64_t)(((const struct listnode *)(stack[base + 9]))->next);
79637987 if(!stack[base + 8]/*found*/)
79647988 {
7965- label = 615LLU; // jump to alternative
7989+ label = 620LLU; // jump to alternative
79667990 break;
79677991 }
79687992
79697993 // consequent
7970- label = 616LLU; // consequent complete
7994+ label = 621LLU; // consequent complete
79717995 break;
79727996 }
7973- case 615LLU: // alternative
7997+ case 620LLU: // alternative
79747998 {
79757999 if(/*scope*/0 != ((uint64_t *)(stack[base + 10]/*SCOPE*/))[0])
79768000 {
7977- label = 618LLU; // jump to alternative
8001+ label = 623LLU; // jump to alternative
79788002 break;
79798003 }
79808004
@@ -7983,14 +8007,14 @@
79838007
79848008 // case
79858009 flippedassign(stack[base + 13]/*scope*/, &stack[base + 14]);
7986- label = 620LLU; // start to repeat
8010+ label = 625LLU; // start to repeat
79878011 break;
79888012 }
7989- case 620LLU: // repeat from here
8013+ case 625LLU: // repeat from here
79908014 {
79918015 if(!stack[base + 14])
79928016 {
7993- label = 621LLU; // break loop
8017+ label = 626LLU; // break loop
79948018 break;
79958019 }
79968020
@@ -8000,19 +8024,19 @@
80008024 stack[base + 14] = (uint64_t)(((const struct listnode *)(stack[base + 14]))->next);
80018025 if(!stack[base + 8]/*found*/)
80028026 {
8003- label = 622LLU; // jump to alternative
8027+ label = 628LLU; // jump to alternative
80048028 break;
80058029 }
80068030
80078031 // consequent
8008- label = 623LLU; // consequent complete
8032+ label = 629LLU; // consequent complete
80098033 break;
80108034 }
8011- case 622LLU: // alternative
8035+ case 628LLU: // alternative
80128036 {
80138037 if(!stack[base + 15]/*letdef*/)
80148038 {
8015- label = 624LLU; // jump to alternative
8039+ label = 630LLU; // jump to alternative
80168040 break;
80178041 }
80188042
@@ -8019,7 +8043,7 @@
80198043 // consequent
80208044 if(/*letdef*/0 != ((uint64_t *)(stack[base + 15]/*letdef*/))[0])
80218045 {
8022- label = 627LLU; // jump to alternative
8046+ label = 633LLU; // jump to alternative
80238047 break;
80248048 }
80258049
@@ -8031,9 +8055,9 @@
80318055
80328056 // case
80338057 // call equ from FindLetNew
8034- stack[base + 22LLU] = 629LLU/*throw to this address*/;
8058+ stack[base + 22LLU] = 635LLU/*throw to this address*/;
80358059 stack[base + 23LLU] = base;
8036- stack[base + 24LLU] = 630LLU;
8060+ stack[base + 24LLU] = 636LLU;
80378061 // arguments for call to equ
80388062 stack[base + 26LLU] = stack[base + 18]/*curid*/;
80398063 stack[base + 27LLU] = stack[base + 2]/*id*/;
@@ -8042,14 +8066,14 @@
80428066 label = 18446744073709551600LLU; // equ
80438067 break;
80448068 }
8045- case 629LLU: // copy-back deleter (equ to FindLetNew)
8069+ case 635LLU: // copy-back deleter (equ to FindLetNew)
80468070 {
80478071 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
80488072 // copy mutable arguments back from call to equ
8049- label = 628LLU; // continue to roll stack
8073+ label = 634LLU; // continue to roll stack
80508074 break;
80518075 }
8052- case 630LLU: // return from equ to FindLetNew
8076+ case 636LLU: // return from equ to FindLetNew
80538077 {
80548078 // copy mutable arguments back from call to equ
80558079 // copy back results provided by call to equ
@@ -8056,30 +8080,30 @@
80568080 stack[base + 8] = stack[base + 25LLU];
80578081 if(!stack[base + 8]/*found*/)
80588082 {
8059- label = 631LLU; // jump to alternative
8083+ label = 637LLU; // jump to alternative
80608084 break;
80618085 }
80628086
80638087 // consequent
80648088 // call copyletdef from FindLetNew
8065- stack[base + 23LLU] = 633LLU/*throw to this address*/;
8089+ stack[base + 23LLU] = 639LLU/*throw to this address*/;
80668090 stack[base + 24LLU] = base;
8067- stack[base + 25LLU] = 634LLU;
8091+ stack[base + 25LLU] = 640LLU;
80688092 // arguments for call to copyletdef
80698093 stack[base + 27LLU] = stack[base + 15]/*letdef*/;
80708094 // set stack-base & callee-address
80718095 base += 26LLU;
8072- label = 518LLU; // copyletdef
8096+ label = 520LLU; // copyletdef
80738097 break;
80748098 }
8075- case 633LLU: // copy-back deleter (copyletdef to FindLetNew)
8099+ case 639LLU: // copy-back deleter (copyletdef to FindLetNew)
80768100 {
80778101 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
80788102 // copy mutable arguments back from call to copyletdef
8079- label = 628LLU; // continue to roll stack
8103+ label = 634LLU; // continue to roll stack
80808104 break;
80818105 }
8082- case 634LLU: // return from copyletdef to FindLetNew
8106+ case 640LLU: // return from copyletdef to FindLetNew
80838107 {
80848108 // copy mutable arguments back from call to copyletdef
80858109 // copy back results provided by call to copyletdef
@@ -8091,28 +8115,28 @@
80918115 newstack[0] = (uint64_t)stack; // backup stack location
80928116 newstack[1] = 1234567890;
80938117 newstack[2] = base;
8094- newstack[3] = 635LLU;
8118+ newstack[3] = 641LLU;
80958119 stack = newstack;
80968120 // set stack-base & callee-address
80978121 base = 4/*deloffset*/;
8098- label = 455LLU; // ~letdef
8122+ label = 457LLU; // ~letdef
80998123 break;
81008124 }
8101- case 635LLU: // return from ~letdef to FindLetNew
8125+ case 641LLU: // return from ~letdef to FindLetNew
81028126 {
81038127 stack = (uint64_t *)stack[0];
81048128 // releasing toplevel container
81058129 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
81068130
8107- label = 632LLU; // consequent complete
8131+ label = 638LLU; // consequent complete
81088132 break;
81098133 }
8110- case 631LLU: // alternative
8134+ case 637LLU: // alternative
81118135 {
8112- label = 632LLU; // alternative complete
8136+ label = 638LLU; // alternative complete
81138137 break;
81148138 }
8115- case 632LLU: // completed if-then-else
8139+ case 638LLU: // completed if-then-else
81168140 {
81178141 ((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
81188142 ((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];
@@ -8119,10 +8143,10 @@
81198143 ((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
81208144 ((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
81218145 ((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
8122- label = 626LLU; // case complete
8146+ label = 632LLU; // case complete
81238147 break;
81248148 }
8125- case 628LLU: // copy-back deleter (switch)
8149+ case 634LLU: // copy-back deleter (switch)
81268150 {
81278151 ((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
81288152 ((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];
@@ -8129,85 +8153,97 @@
81298153 ((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
81308154 ((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
81318155 ((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
8132- label = 619LLU; // continue to unroll stack
8156+ label = 627LLU; // continue to unroll stack
81338157 break;
81348158 }
8135- case 627LLU: // try next case
8159+ case 633LLU: // try next case
81368160 {
81378161 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
81388162 exit(-1);
81398163 }
8140- case 626LLU: // completed switch
8164+ case 632LLU: // completed switch
81418165 {
8142- label = 625LLU; // consequent complete
8166+ label = 631LLU; // consequent complete
81438167 break;
81448168 }
8145- case 624LLU: // alternative
8169+ case 630LLU: // alternative
81468170 {
81478171 fprintf(stderr, "%s", "INTERNAL ERROR empty scope\n");
8148- label = 625LLU; // alternative complete
8172+ label = 631LLU; // alternative complete
81498173 break;
81508174 }
8151- case 625LLU: // completed if-then-else
8175+ case 631LLU: // completed if-then-else
81528176 {
8153- label = 623LLU; // alternative complete
8177+ label = 629LLU; // alternative complete
81548178 break;
81558179 }
8156- case 623LLU: // completed if-then-else
8180+ case 629LLU: // completed if-then-else
81578181 {
81588182 ((struct listnode *)(stack[base + 16]/*previous*/))->data = stack[base + 15];
8159- label = 620LLU; // repeat
8183+ label = 625LLU; // repeat
81608184 break;
81618185 }
8162- case 621LLU: // loop finished
8186+ case 627LLU: // copy-back deleter for while next
81638187 {
8188+ ((struct listnode *)(stack[base + 16]/*previous*/))->data = stack[base + 15];
8189+ label = 624LLU; // continue to unroll stack
8190+ break;
8191+ }
8192+ case 626LLU: // loop finished
8193+ {
81648194 ((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
81658195 ((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
8166- label = 617LLU; // case complete
8196+ label = 622LLU; // case complete
81678197 break;
81688198 }
8169- case 619LLU: // copy-back deleter (switch)
8199+ case 624LLU: // copy-back deleter (switch)
81708200 {
81718201 ((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
81728202 ((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
8173- label = 592LLU; // continue to unroll stack
8203+ label = 619LLU; // continue to unroll stack
81748204 break;
81758205 }
8176- case 618LLU: // try next case
8206+ case 623LLU: // try next case
81778207 {
81788208 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
81798209 exit(-1);
81808210 }
8181- case 617LLU: // completed switch
8211+ case 622LLU: // completed switch
81828212 {
8183- label = 616LLU; // alternative complete
8213+ label = 621LLU; // alternative complete
81848214 break;
81858215 }
8186- case 616LLU: // completed if-then-else
8216+ case 621LLU: // completed if-then-else
81878217 {
81888218 ((struct listnode *)(stack[base + 11]/*previous*/))->data = stack[base + 10];
8189- label = 613LLU; // repeat
8219+ label = 617LLU; // repeat
81908220 break;
81918221 }
8192- case 614LLU: // loop finished
8222+ case 619LLU: // copy-back deleter for while next
81938223 {
8224+ ((struct listnode *)(stack[base + 11]/*previous*/))->data = stack[base + 10];
8225+ label = 595LLU; // continue to unroll stack
8226+ break;
8227+ }
8228+ case 618LLU: // loop finished
8229+ {
81948230 if(!stack[base + 8]/*found*/)
81958231 {
8196- label = 636LLU; // jump to alternative
8232+ label = 642LLU; // jump to alternative
81978233 break;
81988234 }
81998235
82008236 // consequent
8201- label = 637LLU; // consequent complete
8237+ label = 643LLU; // consequent complete
82028238 break;
82038239 }
8204- case 636LLU: // alternative
8240+ case 642LLU: // alternative
82058241 {
82068242 fprintf(stderr, "%s", "in function ");
82078243 // call reportid from FindLetNew
8208- stack[base + 12LLU] = 638LLU/*throw to this address*/;
8244+ stack[base + 12LLU] = 644LLU/*throw to this address*/;
82098245 stack[base + 13LLU] = base;
8210- stack[base + 14LLU] = 639LLU;
8246+ stack[base + 14LLU] = 645LLU;
82118247 // arguments for call to reportid
82128248 stack[base + 15LLU] = stack[base + 1]/*fnid*/;
82138249 // set stack-base & callee-address
@@ -8215,22 +8251,22 @@
82158251 label = 18446744073709551586LLU; // reportid
82168252 break;
82178253 }
8218- case 638LLU: // copy-back deleter (reportid to FindLetNew)
8254+ case 644LLU: // copy-back deleter (reportid to FindLetNew)
82198255 {
82208256 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
82218257 // copy mutable arguments back from call to reportid
8222- label = 592LLU; // continue to roll stack
8258+ label = 595LLU; // continue to roll stack
82238259 break;
82248260 }
8225- case 639LLU: // return from reportid to FindLetNew
8261+ case 645LLU: // return from reportid to FindLetNew
82268262 {
82278263 // copy mutable arguments back from call to reportid
82288264 fprintf(stderr, "%s", ": ");
82298265 fprintf(stderr, "%s", "variable ");
82308266 // call reportid from FindLetNew
8231- stack[base + 12LLU] = 640LLU/*throw to this address*/;
8267+ stack[base + 12LLU] = 646LLU/*throw to this address*/;
82328268 stack[base + 13LLU] = base;
8233- stack[base + 14LLU] = 641LLU;
8269+ stack[base + 14LLU] = 647LLU;
82348270 // arguments for call to reportid
82358271 stack[base + 15LLU] = stack[base + 2]/*id*/;
82368272 // set stack-base & callee-address
@@ -8238,38 +8274,38 @@
82388274 label = 18446744073709551586LLU; // reportid
82398275 break;
82408276 }
8241- case 640LLU: // copy-back deleter (reportid to FindLetNew)
8277+ case 646LLU: // copy-back deleter (reportid to FindLetNew)
82428278 {
82438279 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
82448280 // copy mutable arguments back from call to reportid
8245- label = 592LLU; // continue to roll stack
8281+ label = 595LLU; // continue to roll stack
82468282 break;
82478283 }
8248- case 641LLU: // return from reportid to FindLetNew
8284+ case 647LLU: // return from reportid to FindLetNew
82498285 {
82508286 // copy mutable arguments back from call to reportid
82518287 fprintf(stderr, "%s", " not in scope\n");
82528288 exit(-1);
8253- label = 637LLU; // alternative complete
8289+ label = 643LLU; // alternative complete
82548290 break;
82558291 }
8256- case 637LLU: // completed if-then-else
8292+ case 643LLU: // completed if-then-else
82578293 {
8258- label = 612LLU; // alternative complete
8294+ label = 616LLU; // alternative complete
82598295 break;
82608296 }
8261- case 612LLU: // completed if-then-else
8297+ case 616LLU: // completed if-then-else
82628298 {
8263- label = 643LLU; // skip deleter
8299+ label = 649LLU; // skip deleter
82648300 break;
82658301 }
8266- case 642LLU: // deleter
8302+ case 648LLU: // deleter
82678303 {
82688304 // throw from FindLetNew
82698305 if(!stack[base + 0])
82708306 {
82718307 fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable letdef \n");
8272- label = 592LLU; // skip, variable already deleted/unscoped
8308+ label = 595LLU; // skip, variable already deleted/unscoped
82738309 break;
82748310 }
82758311 fprintf(stderr, "in function FindLetNew: unrolling stack, variable letdef \n");
@@ -8279,23 +8315,23 @@
82798315 newstack[0] = (uint64_t)stack; // backup stack location
82808316 newstack[1] = 1234567890;
82818317 newstack[2] = base;
8282- newstack[3] = 644LLU;
8318+ newstack[3] = 650LLU;
82838319 stack = newstack;
82848320 // set stack-base & callee-address
82858321 base = 4/*deloffset*/;
8286- label = 455LLU; // ~letdef
8322+ label = 457LLU; // ~letdef
82878323 break;
82888324 }
8289- case 644LLU: // return from ~letdef to FindLetNew
8325+ case 650LLU: // return from ~letdef to FindLetNew
82908326 {
82918327 stack = (uint64_t *)stack[0];
82928328 // releasing toplevel container
82938329 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
82948330
8295- label = 592LLU; // continue unrolling stack, delete next variable
8331+ label = 595LLU; // continue unrolling stack, delete next variable
82968332 break;
82978333 }
8298- case 643LLU: // skipped deleter
8334+ case 649LLU: // skipped deleter
82998335 {
83008336 INIT(&stack[base + 0], &stack[base + 5]/*result*/);
83018337 // return from FindLetNew
@@ -8303,7 +8339,7 @@
83038339 base = stack[base - 2];
83048340 break;
83058341 }
8306- case 646LLU: // function getlettype failed
8342+ case 652LLU: // function getlettype failed
83078343 {
83088344 fprintf(stderr, "function getlettype failed\n");
83098345 label = stack[base - 3];
@@ -8310,7 +8346,7 @@
83108346 base = stack[base - 2];
83118347 break;
83128348 }
8313- case 645LLU: // getlettype
8349+ case 651LLU: // getlettype
83148350 {
83158351 //#define res0 0
83168352 //#define arg0 1
@@ -8318,9 +8354,9 @@
83188354 //#define arg2 3
83198355 //#define arg3 4
83208356 // call FindLetNew from getlettype
8321- stack[base + 6LLU] = 647LLU/*throw to this address*/;
8357+ stack[base + 6LLU] = 653LLU/*throw to this address*/;
83228358 stack[base + 7LLU] = base;
8323- stack[base + 8LLU] = 648LLU;
8359+ stack[base + 8LLU] = 654LLU;
83248360 // arguments for call to FindLetNew
83258361 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
83268362 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8328,17 +8364,17 @@
83288364 stack[base + 13LLU] = stack[base + 4]/*scope*/;
83298365 // set stack-base & callee-address
83308366 base += 9LLU;
8331- label = 584LLU; // FindLetNew
8367+ label = 587LLU; // FindLetNew
83328368 break;
83338369 }
8334- case 647LLU: // copy-back deleter (FindLetNew to getlettype)
8370+ case 653LLU: // copy-back deleter (FindLetNew to getlettype)
83358371 {
83368372 fprintf(stderr, "in function getlettype: unrolling stack, copy-back (FindLetNew to getlettype)\n");
83378373 // copy mutable arguments back from call to FindLetNew
8338- label = 646LLU; // continue to roll stack
8374+ label = 652LLU; // continue to roll stack
83398375 break;
83408376 }
8341- case 648LLU: // return from FindLetNew to getlettype
8377+ case 654LLU: // return from FindLetNew to getlettype
83428378 {
83438379 // copy mutable arguments back from call to FindLetNew
83448380 // copy back results provided by call to FindLetNew
@@ -8345,7 +8381,7 @@
83458381 stack[base + 5] = stack[base + 9LLU];
83468382 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
83478383 {
8348- label = 650LLU; // jump to alternative
8384+ label = 656LLU; // jump to alternative
83498385 break;
83508386 }
83518387
@@ -8359,7 +8395,7 @@
83598395 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
83608396 if(!newstack)
83618397 {
8362- label = 651LLU; // throw: begin to unroll stack
8398+ label = 657LLU; // throw: begin to unroll stack
83638399 break;
83648400 }
83658401
@@ -8366,18 +8402,18 @@
83668402 newstack[15LLU] = 9876543210LLU; // overflow-marker
83678403 // call copytype from getlettype
83688404 newstack[0] = (uint64_t)stack; // backup stack location
8369- newstack[1] = 652LLU;
8405+ newstack[1] = 658LLU;
83708406 newstack[2] = base;
8371- newstack[3] = 653LLU;
8407+ newstack[3] = 659LLU;
83728408 // arguments for call to copytype
83738409 newstack[5LLU] = stack[base + 6]/*type*/;
83748410 stack = newstack;
83758411 // set stack-base & callee-address
83768412 base = 4/*deloffset*/;
8377- label = 326LLU; // copytype
8413+ label = 327LLU; // copytype
83788414 break;
83798415 }
8380- case 652LLU: // copy-back deleter (copytype to getlettype)
8416+ case 658LLU: // copy-back deleter (copytype to getlettype)
83818417 {
83828418 fprintf(stderr, "in function getlettype: unrolling stack, copy-back (copytype to getlettype)\n");
83838419 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -8389,10 +8425,10 @@
83898425 }
83908426 Free(15LLU + 1, sizeof(uint64_t), stack);
83918427 stack = oldstack;
8392- label = 651LLU; // continue to unroll stack
8428+ label = 657LLU; // continue to unroll stack
83938429 break;
83948430 }
8395- case 653LLU: // return from copytype to getlettype
8431+ case 659LLU: // return from copytype to getlettype
83968432 {
83978433 uint64_t *oldstack = (uint64_t *)stack[0];
83988434 // copy mutable arguments back from call to copytype
@@ -8410,10 +8446,10 @@
84108446 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
84118447 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
84128448 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8413- label = 649LLU; // case complete
8449+ label = 655LLU; // case complete
84148450 break;
84158451 }
8416- case 651LLU: // copy-back deleter (switch)
8452+ case 657LLU: // copy-back deleter (switch)
84178453 {
84188454 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
84198455 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
@@ -8420,15 +8456,15 @@
84208456 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
84218457 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
84228458 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8423- label = 646LLU; // continue to unroll stack
8459+ label = 652LLU; // continue to unroll stack
84248460 break;
84258461 }
8426- case 650LLU: // try next case
8462+ case 656LLU: // try next case
84278463 {
84288464 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
84298465 exit(-1);
84308466 }
8431- case 649LLU: // completed switch
8467+ case 655LLU: // completed switch
84328468 {
84338469
84348470 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8436,14 +8472,14 @@
84368472 newstack[0] = (uint64_t)stack; // backup stack location
84378473 newstack[1] = 1234567890;
84388474 newstack[2] = base;
8439- newstack[3] = 654LLU;
8475+ newstack[3] = 660LLU;
84408476 stack = newstack;
84418477 // set stack-base & callee-address
84428478 base = 4/*deloffset*/;
8443- label = 455LLU; // ~letdef
8479+ label = 457LLU; // ~letdef
84448480 break;
84458481 }
8446- case 654LLU: // return from ~letdef to getlettype
8482+ case 660LLU: // return from ~letdef to getlettype
84478483 {
84488484 stack = (uint64_t *)stack[0];
84498485 // releasing toplevel container
@@ -8454,7 +8490,7 @@
84548490 base = stack[base - 2];
84558491 break;
84568492 }
8457- case 656LLU: // function findletidx failed
8493+ case 662LLU: // function findletidx failed
84588494 {
84598495 fprintf(stderr, "function findletidx failed\n");
84608496 label = stack[base - 3];
@@ -8461,7 +8497,7 @@
84618497 base = stack[base - 2];
84628498 break;
84638499 }
8464- case 655LLU: // findletidx
8500+ case 661LLU: // findletidx
84658501 {
84668502 //#define res0 0
84678503 //#define arg0 1
@@ -8469,9 +8505,9 @@
84698505 //#define arg2 3
84708506 //#define arg3 4
84718507 // call FindLetNew from findletidx
8472- stack[base + 6LLU] = 657LLU/*throw to this address*/;
8508+ stack[base + 6LLU] = 663LLU/*throw to this address*/;
84738509 stack[base + 7LLU] = base;
8474- stack[base + 8LLU] = 658LLU;
8510+ stack[base + 8LLU] = 664LLU;
84758511 // arguments for call to FindLetNew
84768512 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
84778513 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8479,17 +8515,17 @@
84798515 stack[base + 13LLU] = stack[base + 4]/*scope*/;
84808516 // set stack-base & callee-address
84818517 base += 9LLU;
8482- label = 584LLU; // FindLetNew
8518+ label = 587LLU; // FindLetNew
84838519 break;
84848520 }
8485- case 657LLU: // copy-back deleter (FindLetNew to findletidx)
8521+ case 663LLU: // copy-back deleter (FindLetNew to findletidx)
84868522 {
84878523 fprintf(stderr, "in function findletidx: unrolling stack, copy-back (FindLetNew to findletidx)\n");
84888524 // copy mutable arguments back from call to FindLetNew
8489- label = 656LLU; // continue to roll stack
8525+ label = 662LLU; // continue to roll stack
84908526 break;
84918527 }
8492- case 658LLU: // return from FindLetNew to findletidx
8528+ case 664LLU: // return from FindLetNew to findletidx
84938529 {
84948530 // copy mutable arguments back from call to FindLetNew
84958531 // copy back results provided by call to FindLetNew
@@ -8496,7 +8532,7 @@
84968532 stack[base + 5] = stack[base + 9LLU];
84978533 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
84988534 {
8499- label = 660LLU; // jump to alternative
8535+ label = 666LLU; // jump to alternative
85008536 break;
85018537 }
85028538
@@ -8507,23 +8543,23 @@
85078543 /*substruct*/stack[base + 10] = ((uint64_t **)(stack[base + 5]/*letdef*/))[1][4]/*substruct*/;
85088544
85098545 // case
8510- label = 663LLU; // skip deleter
8546+ label = 669LLU; // skip deleter
85118547 break;
85128548 }
8513- case 662LLU: // deleter
8549+ case 668LLU: // deleter
85148550 {
85158551 // throw from findletidx
85168552 if(!stack[base + 0])
85178553 {
85188554 fprintf(stderr, "in function findletidx: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8519- label = 661LLU; // skip, variable already deleted/unscoped
8555+ label = 667LLU; // skip, variable already deleted/unscoped
85208556 break;
85218557 }
85228558 fprintf(stderr, "in function findletidx: unrolling stack, variable u64 \n");
8523- label = 661LLU; // continue unrolling stack, delete next variable
8559+ label = 667LLU; // continue unrolling stack, delete next variable
85248560 break;
85258561 }
8526- case 663LLU: // skipped deleter
8562+ case 669LLU: // skipped deleter
85278563 {
85288564 stack[base + 0] = stack[base + 8]/*index*/;
85298565 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
@@ -8531,10 +8567,10 @@
85318567 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
85328568 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
85338569 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8534- label = 659LLU; // case complete
8570+ label = 665LLU; // case complete
85358571 break;
85368572 }
8537- case 661LLU: // copy-back deleter (switch)
8573+ case 667LLU: // copy-back deleter (switch)
85388574 {
85398575 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
85408576 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
@@ -8541,15 +8577,15 @@
85418577 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
85428578 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
85438579 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8544- label = 656LLU; // continue to unroll stack
8580+ label = 662LLU; // continue to unroll stack
85458581 break;
85468582 }
8547- case 660LLU: // try next case
8583+ case 666LLU: // try next case
85488584 {
85498585 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
85508586 exit(-1);
85518587 }
8552- case 659LLU: // completed switch
8588+ case 665LLU: // completed switch
85538589 {
85548590
85558591 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8557,14 +8593,14 @@
85578593 newstack[0] = (uint64_t)stack; // backup stack location
85588594 newstack[1] = 1234567890;
85598595 newstack[2] = base;
8560- newstack[3] = 664LLU;
8596+ newstack[3] = 670LLU;
85618597 stack = newstack;
85628598 // set stack-base & callee-address
85638599 base = 4/*deloffset*/;
8564- label = 455LLU; // ~letdef
8600+ label = 457LLU; // ~letdef
85658601 break;
85668602 }
8567- case 664LLU: // return from ~letdef to findletidx
8603+ case 670LLU: // return from ~letdef to findletidx
85688604 {
85698605 stack = (uint64_t *)stack[0];
85708606 // releasing toplevel container
@@ -8575,7 +8611,7 @@
85758611 base = stack[base - 2];
85768612 break;
85778613 }
8578- case 666LLU: // function findletmut failed
8614+ case 672LLU: // function findletmut failed
85798615 {
85808616 fprintf(stderr, "function findletmut failed\n");
85818617 label = stack[base - 3];
@@ -8582,7 +8618,7 @@
85828618 base = stack[base - 2];
85838619 break;
85848620 }
8585- case 665LLU: // findletmut
8621+ case 671LLU: // findletmut
85868622 {
85878623 //#define res0 0
85888624 //#define arg0 1
@@ -8590,9 +8626,9 @@
85908626 //#define arg2 3
85918627 //#define arg3 4
85928628 // call FindLetNew from findletmut
8593- stack[base + 6LLU] = 667LLU/*throw to this address*/;
8629+ stack[base + 6LLU] = 673LLU/*throw to this address*/;
85948630 stack[base + 7LLU] = base;
8595- stack[base + 8LLU] = 668LLU;
8631+ stack[base + 8LLU] = 674LLU;
85968632 // arguments for call to FindLetNew
85978633 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
85988634 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8600,17 +8636,17 @@
86008636 stack[base + 13LLU] = stack[base + 4]/*scope*/;
86018637 // set stack-base & callee-address
86028638 base += 9LLU;
8603- label = 584LLU; // FindLetNew
8639+ label = 587LLU; // FindLetNew
86048640 break;
86058641 }
8606- case 667LLU: // copy-back deleter (FindLetNew to findletmut)
8642+ case 673LLU: // copy-back deleter (FindLetNew to findletmut)
86078643 {
86088644 fprintf(stderr, "in function findletmut: unrolling stack, copy-back (FindLetNew to findletmut)\n");
86098645 // copy mutable arguments back from call to FindLetNew
8610- label = 666LLU; // continue to roll stack
8646+ label = 672LLU; // continue to roll stack
86118647 break;
86128648 }
8613- case 668LLU: // return from FindLetNew to findletmut
8649+ case 674LLU: // return from FindLetNew to findletmut
86148650 {
86158651 // copy mutable arguments back from call to FindLetNew
86168652 // copy back results provided by call to FindLetNew
@@ -8617,7 +8653,7 @@
86178653 stack[base + 5] = stack[base + 9LLU];
86188654 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
86198655 {
8620- label = 670LLU; // jump to alternative
8656+ label = 676LLU; // jump to alternative
86218657 break;
86228658 }
86238659
@@ -8628,23 +8664,23 @@
86288664 /*substruct*/stack[base + 10] = ((uint64_t **)(stack[base + 5]/*letdef*/))[1][4]/*substruct*/;
86298665
86308666 // case
8631- label = 673LLU; // skip deleter
8667+ label = 679LLU; // skip deleter
86328668 break;
86338669 }
8634- case 672LLU: // deleter
8670+ case 678LLU: // deleter
86358671 {
86368672 // throw from findletmut
86378673 if(!stack[base + 0])
86388674 {
86398675 fprintf(stderr, "in function findletmut: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8640- label = 671LLU; // skip, variable already deleted/unscoped
8676+ label = 677LLU; // skip, variable already deleted/unscoped
86418677 break;
86428678 }
86438679 fprintf(stderr, "in function findletmut: unrolling stack, variable u64 \n");
8644- label = 671LLU; // continue unrolling stack, delete next variable
8680+ label = 677LLU; // continue unrolling stack, delete next variable
86458681 break;
86468682 }
8647- case 673LLU: // skipped deleter
8683+ case 679LLU: // skipped deleter
86488684 {
86498685 stack[base + 0] = stack[base + 9]/*mutable*/;
86508686 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
@@ -8652,10 +8688,10 @@
86528688 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
86538689 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
86548690 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8655- label = 669LLU; // case complete
8691+ label = 675LLU; // case complete
86568692 break;
86578693 }
8658- case 671LLU: // copy-back deleter (switch)
8694+ case 677LLU: // copy-back deleter (switch)
86598695 {
86608696 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
86618697 ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
@@ -8662,15 +8698,15 @@
86628698 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
86638699 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
86648700 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8665- label = 666LLU; // continue to unroll stack
8701+ label = 672LLU; // continue to unroll stack
86668702 break;
86678703 }
8668- case 670LLU: // try next case
8704+ case 676LLU: // try next case
86698705 {
86708706 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
86718707 exit(-1);
86728708 }
8673- case 669LLU: // completed switch
8709+ case 675LLU: // completed switch
86748710 {
86758711
86768712 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8678,14 +8714,14 @@
86788714 newstack[0] = (uint64_t)stack; // backup stack location
86798715 newstack[1] = 1234567890;
86808716 newstack[2] = base;
8681- newstack[3] = 674LLU;
8717+ newstack[3] = 680LLU;
86828718 stack = newstack;
86838719 // set stack-base & callee-address
86848720 base = 4/*deloffset*/;
8685- label = 455LLU; // ~letdef
8721+ label = 457LLU; // ~letdef
86868722 break;
86878723 }
8688- case 674LLU: // return from ~letdef to findletmut
8724+ case 680LLU: // return from ~letdef to findletmut
86898725 {
86908726 stack = (uint64_t *)stack[0];
86918727 // releasing toplevel container
@@ -8696,7 +8732,7 @@
86968732 base = stack[base - 2];
86978733 break;
86988734 }
8699- case 676LLU: // function assertvar failed
8735+ case 682LLU: // function assertvar failed
87008736 {
87018737 fprintf(stderr, "function assertvar failed\n");
87028738 label = stack[base - 3];
@@ -8703,7 +8739,7 @@
87038739 base = stack[base - 2];
87048740 break;
87058741 }
8706- case 675LLU: // assertvar
8742+ case 681LLU: // assertvar
87078743 {
87088744 //#define arg0 0
87098745 //#define arg1 1
@@ -8710,9 +8746,9 @@
87108746 //#define arg2 2
87118747 //#define arg3 3
87128748 // call findletidx from assertvar
8713- stack[base + 5LLU] = 677LLU/*throw to this address*/;
8749+ stack[base + 5LLU] = 683LLU/*throw to this address*/;
87148750 stack[base + 6LLU] = base;
8715- stack[base + 7LLU] = 678LLU;
8751+ stack[base + 7LLU] = 684LLU;
87168752 // arguments for call to findletidx
87178753 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
87188754 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8720,17 +8756,17 @@
87208756 stack[base + 12LLU] = stack[base + 3]/*scope*/;
87218757 // set stack-base & callee-address
87228758 base += 8LLU;
8723- label = 655LLU; // findletidx
8759+ label = 661LLU; // findletidx
87248760 break;
87258761 }
8726- case 677LLU: // copy-back deleter (findletidx to assertvar)
8762+ case 683LLU: // copy-back deleter (findletidx to assertvar)
87278763 {
87288764 fprintf(stderr, "in function assertvar: unrolling stack, copy-back (findletidx to assertvar)\n");
87298765 // copy mutable arguments back from call to findletidx
8730- label = 676LLU; // continue to roll stack
8766+ label = 682LLU; // continue to roll stack
87318767 break;
87328768 }
8733- case 678LLU: // return from findletidx to assertvar
8769+ case 684LLU: // return from findletidx to assertvar
87348770 {
87358771 // copy mutable arguments back from call to findletidx
87368772 // copy back results provided by call to findletidx
@@ -8740,7 +8776,7 @@
87408776 base = stack[base - 2];
87418777 break;
87428778 }
8743- case 680LLU: // function emitindex failed
8779+ case 686LLU: // function emitindex failed
87448780 {
87458781 fprintf(stderr, "function emitindex failed\n");
87468782 label = stack[base - 3];
@@ -8747,7 +8783,7 @@
87478783 base = stack[base - 2];
87488784 break;
87498785 }
8750- case 679LLU: // emitindex
8786+ case 685LLU: // emitindex
87518787 {
87528788 //#define arg0 0
87538789 //#define arg1 1
@@ -8754,9 +8790,9 @@
87548790 //#define arg2 2
87558791 //#define arg3 3
87568792 // call findletidx from emitindex
8757- stack[base + 5LLU] = 681LLU/*throw to this address*/;
8793+ stack[base + 5LLU] = 687LLU/*throw to this address*/;
87588794 stack[base + 6LLU] = base;
8759- stack[base + 7LLU] = 682LLU;
8795+ stack[base + 7LLU] = 688LLU;
87608796 // arguments for call to findletidx
87618797 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
87628798 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8764,25 +8800,25 @@
87648800 stack[base + 12LLU] = stack[base + 3]/*scope*/;
87658801 // set stack-base & callee-address
87668802 base += 8LLU;
8767- label = 655LLU; // findletidx
8803+ label = 661LLU; // findletidx
87688804 break;
87698805 }
8770- case 681LLU: // copy-back deleter (findletidx to emitindex)
8806+ case 687LLU: // copy-back deleter (findletidx to emitindex)
87718807 {
87728808 fprintf(stderr, "in function emitindex: unrolling stack, copy-back (findletidx to emitindex)\n");
87738809 // copy mutable arguments back from call to findletidx
8774- label = 680LLU; // continue to roll stack
8810+ label = 686LLU; // continue to roll stack
87758811 break;
87768812 }
8777- case 682LLU: // return from findletidx to emitindex
8813+ case 688LLU: // return from findletidx to emitindex
87788814 {
87798815 // copy mutable arguments back from call to findletidx
87808816 // copy back results provided by call to findletidx
87818817 stack[base + 4] = stack[base + 8LLU];
87828818 // call printnr from emitindex
8783- stack[base + 5LLU] = 683LLU/*throw to this address*/;
8819+ stack[base + 5LLU] = 689LLU/*throw to this address*/;
87848820 stack[base + 6LLU] = base;
8785- stack[base + 7LLU] = 684LLU;
8821+ stack[base + 7LLU] = 690LLU;
87868822 // arguments for call to printnr
87878823 stack[base + 8LLU] = stack[base + 4]/*index*/;
87888824 // set stack-base & callee-address
@@ -8790,14 +8826,14 @@
87908826 label = 18446744073709551590LLU; // printnr
87918827 break;
87928828 }
8793- case 683LLU: // copy-back deleter (printnr to emitindex)
8829+ case 689LLU: // copy-back deleter (printnr to emitindex)
87948830 {
87958831 fprintf(stderr, "in function emitindex: unrolling stack, copy-back (printnr to emitindex)\n");
87968832 // copy mutable arguments back from call to printnr
8797- label = 680LLU; // continue to roll stack
8833+ label = 686LLU; // continue to roll stack
87988834 break;
87998835 }
8800- case 684LLU: // return from printnr to emitindex
8836+ case 690LLU: // return from printnr to emitindex
88018837 {
88028838 // copy mutable arguments back from call to printnr
88038839 // return from emitindex
@@ -8805,7 +8841,7 @@
88058841 base = stack[base - 2];
88068842 break;
88078843 }
8808- case 686LLU: // function emitvaridx failed
8844+ case 692LLU: // function emitvaridx failed
88098845 {
88108846 fprintf(stderr, "function emitvaridx failed\n");
88118847 label = stack[base - 3];
@@ -8812,14 +8848,14 @@
88128848 base = stack[base - 2];
88138849 break;
88148850 }
8815- case 685LLU: // emitvaridx
8851+ case 691LLU: // emitvaridx
88168852 {
88178853 //#define arg0 0
88188854 printf("%s", "stack[base + ");
88198855 // call printnr from emitvaridx
8820- stack[base + 1LLU] = 687LLU/*throw to this address*/;
8856+ stack[base + 1LLU] = 693LLU/*throw to this address*/;
88218857 stack[base + 2LLU] = base;
8822- stack[base + 3LLU] = 688LLU;
8858+ stack[base + 3LLU] = 694LLU;
88238859 // arguments for call to printnr
88248860 stack[base + 4LLU] = stack[base + 0]/*index*/;
88258861 // set stack-base & callee-address
@@ -8827,14 +8863,14 @@
88278863 label = 18446744073709551590LLU; // printnr
88288864 break;
88298865 }
8830- case 687LLU: // copy-back deleter (printnr to emitvaridx)
8866+ case 693LLU: // copy-back deleter (printnr to emitvaridx)
88318867 {
88328868 fprintf(stderr, "in function emitvaridx: unrolling stack, copy-back (printnr to emitvaridx)\n");
88338869 // copy mutable arguments back from call to printnr
8834- label = 686LLU; // continue to roll stack
8870+ label = 692LLU; // continue to roll stack
88358871 break;
88368872 }
8837- case 688LLU: // return from printnr to emitvaridx
8873+ case 694LLU: // return from printnr to emitvaridx
88388874 {
88398875 // copy mutable arguments back from call to printnr
88408876 printf("%s", "]");
@@ -8843,7 +8879,7 @@
88438879 base = stack[base - 2];
88448880 break;
88458881 }
8846- case 690LLU: // function emitvar failed
8882+ case 696LLU: // function emitvar failed
88478883 {
88488884 fprintf(stderr, "function emitvar failed\n");
88498885 label = stack[base - 3];
@@ -8850,7 +8886,7 @@
88508886 base = stack[base - 2];
88518887 break;
88528888 }
8853- case 689LLU: // emitvar
8889+ case 695LLU: // emitvar
88548890 {
88558891 //#define arg0 0
88568892 //#define arg1 1
@@ -8857,9 +8893,9 @@
88578893 //#define arg2 2
88588894 //#define arg3 3
88598895 // call findletidx from emitvar
8860- stack[base + 5LLU] = 691LLU/*throw to this address*/;
8896+ stack[base + 5LLU] = 697LLU/*throw to this address*/;
88618897 stack[base + 6LLU] = base;
8862- stack[base + 7LLU] = 692LLU;
8898+ stack[base + 7LLU] = 698LLU;
88638899 // arguments for call to findletidx
88648900 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
88658901 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8867,47 +8903,47 @@
88678903 stack[base + 12LLU] = stack[base + 3]/*scope*/;
88688904 // set stack-base & callee-address
88698905 base += 8LLU;
8870- label = 655LLU; // findletidx
8906+ label = 661LLU; // findletidx
88718907 break;
88728908 }
8873- case 691LLU: // copy-back deleter (findletidx to emitvar)
8909+ case 697LLU: // copy-back deleter (findletidx to emitvar)
88748910 {
88758911 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (findletidx to emitvar)\n");
88768912 // copy mutable arguments back from call to findletidx
8877- label = 690LLU; // continue to roll stack
8913+ label = 696LLU; // continue to roll stack
88788914 break;
88798915 }
8880- case 692LLU: // return from findletidx to emitvar
8916+ case 698LLU: // return from findletidx to emitvar
88818917 {
88828918 // copy mutable arguments back from call to findletidx
88838919 // copy back results provided by call to findletidx
88848920 stack[base + 4] = stack[base + 8LLU];
88858921 // call emitvaridx from emitvar
8886- stack[base + 5LLU] = 693LLU/*throw to this address*/;
8922+ stack[base + 5LLU] = 699LLU/*throw to this address*/;
88878923 stack[base + 6LLU] = base;
8888- stack[base + 7LLU] = 694LLU;
8924+ stack[base + 7LLU] = 700LLU;
88898925 // arguments for call to emitvaridx
88908926 stack[base + 8LLU] = stack[base + 4]/*index*/;
88918927 // set stack-base & callee-address
88928928 base += 8LLU;
8893- label = 685LLU; // emitvaridx
8929+ label = 691LLU; // emitvaridx
88948930 break;
88958931 }
8896- case 693LLU: // copy-back deleter (emitvaridx to emitvar)
8932+ case 699LLU: // copy-back deleter (emitvaridx to emitvar)
88978933 {
88988934 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (emitvaridx to emitvar)\n");
88998935 // copy mutable arguments back from call to emitvaridx
8900- label = 690LLU; // continue to roll stack
8936+ label = 696LLU; // continue to roll stack
89018937 break;
89028938 }
8903- case 694LLU: // return from emitvaridx to emitvar
8939+ case 700LLU: // return from emitvaridx to emitvar
89048940 {
89058941 // copy mutable arguments back from call to emitvaridx
89068942 printf("%s", "/*");
89078943 // call printid from emitvar
8908- stack[base + 5LLU] = 695LLU/*throw to this address*/;
8944+ stack[base + 5LLU] = 701LLU/*throw to this address*/;
89098945 stack[base + 6LLU] = base;
8910- stack[base + 7LLU] = 696LLU;
8946+ stack[base + 7LLU] = 702LLU;
89118947 // arguments for call to printid
89128948 stack[base + 8LLU] = stack[base + 1]/*id*/;
89138949 // set stack-base & callee-address
@@ -8915,14 +8951,14 @@
89158951 label = 18446744073709551587LLU; // printid
89168952 break;
89178953 }
8918- case 695LLU: // copy-back deleter (printid to emitvar)
8954+ case 701LLU: // copy-back deleter (printid to emitvar)
89198955 {
89208956 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (printid to emitvar)\n");
89218957 // copy mutable arguments back from call to printid
8922- label = 690LLU; // continue to roll stack
8958+ label = 696LLU; // continue to roll stack
89238959 break;
89248960 }
8925- case 696LLU: // return from printid to emitvar
8961+ case 702LLU: // return from printid to emitvar
89268962 {
89278963 // copy mutable arguments back from call to printid
89288964 printf("%s", "*/");
@@ -8931,7 +8967,7 @@
89318967 base = stack[base - 2];
89328968 break;
89338969 }
8934- case 698LLU: // function newvarraw failed
8970+ case 704LLU: // function newvarraw failed
89358971 {
89368972 fprintf(stderr, "function newvarraw failed\n");
89378973 label = stack[base - 3];
@@ -8938,7 +8974,7 @@
89388974 base = stack[base - 2];
89398975 break;
89408976 }
8941- case 697LLU: // newvarraw
8977+ case 703LLU: // newvarraw
89428978 {
89438979 //#define res0 0
89448980 //#define arg0 1
@@ -8950,28 +8986,28 @@
89508986 //#define arg6 7
89518987 //#define arg7 8
89528988 //#define arg8 9
8953- label = 700LLU; // skip deleter
8989+ label = 706LLU; // skip deleter
89548990 break;
89558991 }
8956- case 699LLU: // deleter
8992+ case 705LLU: // deleter
89578993 {
89588994 // throw from newvarraw
89598995 if(!stack[base + 10])
89608996 {
89618997 fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8962- label = 698LLU; // skip, variable already deleted/unscoped
8998+ label = 704LLU; // skip, variable already deleted/unscoped
89638999 break;
89649000 }
89659001 fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
8966- label = 698LLU; // continue unrolling stack, delete next variable
9002+ label = 704LLU; // continue unrolling stack, delete next variable
89679003 break;
89689004 }
8969- case 700LLU: // skipped deleter
9005+ case 706LLU: // skipped deleter
89709006 {
89719007 stack[base + 10] = 0;
89729008 if(/*scope*/0 != ((uint64_t *)(stack[base + 8]/*scope*/))[0])
89739009 {
8974- label = 702LLU; // jump to alternative
9010+ label = 708LLU; // jump to alternative
89759011 break;
89769012 }
89779013
@@ -8979,29 +9015,29 @@
89799015 /*letdefs*/stack[base + 12] = ((uint64_t **)(stack[base + 8]/*scope*/))[1][1]/*letdefs*/;
89809016
89819017 // case
8982- label = 705LLU; // skip deleter
9018+ label = 711LLU; // skip deleter
89839019 break;
89849020 }
8985- case 704LLU: // deleter
9021+ case 710LLU: // deleter
89869022 {
89879023 // throw from newvarraw
89889024 if(!stack[base + 13])
89899025 {
89909026 fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8991- label = 703LLU; // skip, variable already deleted/unscoped
9027+ label = 709LLU; // skip, variable already deleted/unscoped
89929028 break;
89939029 }
89949030 fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
8995- label = 703LLU; // continue unrolling stack, delete next variable
9031+ label = 709LLU; // continue unrolling stack, delete next variable
89969032 break;
89979033 }
8998- case 705LLU: // skipped deleter
9034+ case 711LLU: // skipped deleter
89999035 {
90009036 stack[base + 13] = 0;
90019037 // call add from newvarraw
9002- stack[base + 14LLU] = 706LLU/*throw to this address*/;
9038+ stack[base + 14LLU] = 712LLU/*throw to this address*/;
90039039 stack[base + 15LLU] = base;
9004- stack[base + 16LLU] = 707LLU;
9040+ stack[base + 16LLU] = 713LLU;
90059041 // arguments for call to add
90069042 stack[base + 18LLU] = stack[base + 4]/*fnrescount*/;
90079043 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -9010,22 +9046,22 @@
90109046 label = 18446744073709551605LLU; // add
90119047 break;
90129048 }
9013- case 706LLU: // copy-back deleter (add to newvarraw)
9049+ case 712LLU: // copy-back deleter (add to newvarraw)
90149050 {
90159051 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
90169052 // copy mutable arguments back from call to add
9017- label = 704LLU; // continue to roll stack
9053+ label = 710LLU; // continue to roll stack
90189054 break;
90199055 }
9020- case 707LLU: // return from add to newvarraw
9056+ case 713LLU: // return from add to newvarraw
90219057 {
90229058 // copy mutable arguments back from call to add
90239059 // copy back results provided by call to add
90249060 stack[base + 13] = stack[base + 17LLU];
90259061 // call add from newvarraw
9026- stack[base + 14LLU] = 708LLU/*throw to this address*/;
9062+ stack[base + 14LLU] = 714LLU/*throw to this address*/;
90279063 stack[base + 15LLU] = base;
9028- stack[base + 16LLU] = 709LLU;
9064+ stack[base + 16LLU] = 715LLU;
90299065 // arguments for call to add
90309066 stack[base + 18LLU] = stack[base + 5]/*fnargcount*/;
90319067 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -9034,22 +9070,22 @@
90349070 label = 18446744073709551605LLU; // add
90359071 break;
90369072 }
9037- case 708LLU: // copy-back deleter (add to newvarraw)
9073+ case 714LLU: // copy-back deleter (add to newvarraw)
90389074 {
90399075 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
90409076 // copy mutable arguments back from call to add
9041- label = 704LLU; // continue to roll stack
9077+ label = 710LLU; // continue to roll stack
90429078 break;
90439079 }
9044- case 709LLU: // return from add to newvarraw
9080+ case 715LLU: // return from add to newvarraw
90459081 {
90469082 // copy mutable arguments back from call to add
90479083 // copy back results provided by call to add
90489084 stack[base + 13] = stack[base + 17LLU];
90499085 // call add from newvarraw
9050- stack[base + 14LLU] = 710LLU/*throw to this address*/;
9086+ stack[base + 14LLU] = 716LLU/*throw to this address*/;
90519087 stack[base + 15LLU] = base;
9052- stack[base + 16LLU] = 711LLU;
9088+ stack[base + 16LLU] = 717LLU;
90539089 // arguments for call to add
90549090 stack[base + 18LLU] = stack[base + 7]/*varcount*/;
90559091 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -9058,14 +9094,14 @@
90589094 label = 18446744073709551605LLU; // add
90599095 break;
90609096 }
9061- case 710LLU: // copy-back deleter (add to newvarraw)
9097+ case 716LLU: // copy-back deleter (add to newvarraw)
90629098 {
90639099 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
90649100 // copy mutable arguments back from call to add
9065- label = 704LLU; // continue to roll stack
9101+ label = 710LLU; // continue to roll stack
90669102 break;
90679103 }
9068- case 711LLU: // return from add to newvarraw
9104+ case 717LLU: // return from add to newvarraw
90699105 {
90709106 // copy mutable arguments back from call to add
90719107 // copy back results provided by call to add
@@ -9074,7 +9110,7 @@
90749110 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
90759111 if(!newstack)
90769112 {
9077- label = 704LLU; // throw: begin to unroll stack
9113+ label = 710LLU; // throw: begin to unroll stack
90789114 break;
90799115 }
90809116
@@ -9081,18 +9117,18 @@
90819117 newstack[15LLU] = 9876543210LLU; // overflow-marker
90829118 // call copytype from newvarraw
90839119 newstack[0] = (uint64_t)stack; // backup stack location
9084- newstack[1] = 712LLU;
9120+ newstack[1] = 718LLU;
90859121 newstack[2] = base;
9086- newstack[3] = 713LLU;
9122+ newstack[3] = 719LLU;
90879123 // arguments for call to copytype
90889124 newstack[5LLU] = stack[base + 1]/*type*/;
90899125 stack = newstack;
90909126 // set stack-base & callee-address
90919127 base = 4/*deloffset*/;
9092- label = 326LLU; // copytype
9128+ label = 327LLU; // copytype
90939129 break;
90949130 }
9095- case 712LLU: // copy-back deleter (copytype to newvarraw)
9131+ case 718LLU: // copy-back deleter (copytype to newvarraw)
90969132 {
90979133 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (copytype to newvarraw)\n");
90989134 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -9104,10 +9140,10 @@
91049140 }
91059141 Free(15LLU + 1, sizeof(uint64_t), stack);
91069142 stack = oldstack;
9107- label = 704LLU; // continue to unroll stack
9143+ label = 710LLU; // continue to unroll stack
91089144 break;
91099145 }
9110- case 713LLU: // return from copytype to newvarraw
9146+ case 719LLU: // return from copytype to newvarraw
91119147 {
91129148 uint64_t *oldstack = (uint64_t *)stack[0];
91139149 // copy mutable arguments back from call to copytype
@@ -9120,16 +9156,16 @@
91209156 }
91219157 Free(15LLU + 1, sizeof(uint64_t), stack);
91229158 stack = oldstack;
9123- label = 715LLU; // skip deleter
9159+ label = 721LLU; // skip deleter
91249160 break;
91259161 }
9126- case 714LLU: // deleter
9162+ case 720LLU: // deleter
91279163 {
91289164 // throw from newvarraw
91299165 if(!stack[base + 15])
91309166 {
91319167 fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable letdef \n");
9132- label = 704LLU; // skip, variable already deleted/unscoped
9168+ label = 710LLU; // skip, variable already deleted/unscoped
91339169 break;
91349170 }
91359171 fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef \n");
@@ -9139,28 +9175,28 @@
91399175 newstack[0] = (uint64_t)stack; // backup stack location
91409176 newstack[1] = 1234567890;
91419177 newstack[2] = base;
9142- newstack[3] = 716LLU;
9178+ newstack[3] = 722LLU;
91439179 stack = newstack;
91449180 // set stack-base & callee-address
91459181 base = 4/*deloffset*/;
9146- label = 455LLU; // ~letdef
9182+ label = 457LLU; // ~letdef
91479183 break;
91489184 }
9149- case 716LLU: // return from ~letdef to newvarraw
9185+ case 722LLU: // return from ~letdef to newvarraw
91509186 {
91519187 stack = (uint64_t *)stack[0];
91529188 // releasing toplevel container
91539189 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4));
91549190
9155- label = 704LLU; // continue unrolling stack, delete next variable
9191+ label = 710LLU; // continue unrolling stack, delete next variable
91569192 break;
91579193 }
9158- case 715LLU: // skipped deleter
9194+ case 721LLU: // skipped deleter
91599195 {
91609196 // construct letdef.letdef
91619197 if(!(stack[base + 15] = construct(5)))
91629198 {
9163- label = 704LLU; // throw: begin to unroll stack
9199+ label = 710LLU; // throw: begin to unroll stack
91649200 break;
91659201 }
91669202
@@ -9184,27 +9220,27 @@
91849220 }
91859221 ((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
91869222 ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
9187- label = 701LLU; // case complete
9223+ label = 707LLU; // case complete
91889224 break;
91899225 }
9190- case 703LLU: // copy-back deleter (switch)
9226+ case 709LLU: // copy-back deleter (switch)
91919227 {
91929228 ((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
91939229 ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
9194- label = 699LLU; // continue to unroll stack
9230+ label = 705LLU; // continue to unroll stack
91959231 break;
91969232 }
9197- case 702LLU: // try next case
9233+ case 708LLU: // try next case
91989234 {
91999235 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
92009236 exit(-1);
92019237 }
9202- case 701LLU: // completed switch
9238+ case 707LLU: // completed switch
92039239 {
92049240 // call add from newvarraw
9205- stack[base + 11LLU] = 717LLU/*throw to this address*/;
9241+ stack[base + 11LLU] = 723LLU/*throw to this address*/;
92069242 stack[base + 12LLU] = base;
9207- stack[base + 13LLU] = 718LLU;
9243+ stack[base + 13LLU] = 724LLU;
92089244 // arguments for call to add
92099245 stack[base + 15LLU] = 1LLU;
92109246 stack[base + 16LLU] = stack[base + 7]/*varcount*/;
@@ -9213,22 +9249,22 @@
92139249 label = 18446744073709551605LLU; // add
92149250 break;
92159251 }
9216- case 717LLU: // copy-back deleter (add to newvarraw)
9252+ case 723LLU: // copy-back deleter (add to newvarraw)
92179253 {
92189254 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
92199255 // copy mutable arguments back from call to add
9220- label = 699LLU; // continue to roll stack
9256+ label = 705LLU; // continue to roll stack
92219257 break;
92229258 }
9223- case 718LLU: // return from add to newvarraw
9259+ case 724LLU: // return from add to newvarraw
92249260 {
92259261 // copy mutable arguments back from call to add
92269262 // copy back results provided by call to add
92279263 stack[base + 7] = stack[base + 14LLU];
92289264 // call max from newvarraw
9229- stack[base + 11LLU] = 719LLU/*throw to this address*/;
9265+ stack[base + 11LLU] = 725LLU/*throw to this address*/;
92309266 stack[base + 12LLU] = base;
9231- stack[base + 13LLU] = 720LLU;
9267+ stack[base + 13LLU] = 726LLU;
92329268 // arguments for call to max
92339269 stack[base + 15LLU] = stack[base + 7]/*varcount*/;
92349270 stack[base + 16LLU] = stack[base + 6]/*fnmaxcount*/;
@@ -9237,35 +9273,35 @@
92379273 label = 18446744073709551606LLU; // max
92389274 break;
92399275 }
9240- case 719LLU: // copy-back deleter (max to newvarraw)
9276+ case 725LLU: // copy-back deleter (max to newvarraw)
92419277 {
92429278 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (max to newvarraw)\n");
92439279 // copy mutable arguments back from call to max
9244- label = 699LLU; // continue to roll stack
9280+ label = 705LLU; // continue to roll stack
92459281 break;
92469282 }
9247- case 720LLU: // return from max to newvarraw
9283+ case 726LLU: // return from max to newvarraw
92489284 {
92499285 // copy mutable arguments back from call to max
92509286 // copy back results provided by call to max
92519287 stack[base + 6] = stack[base + 14LLU];
9252- label = 722LLU; // skip deleter
9288+ label = 728LLU; // skip deleter
92539289 break;
92549290 }
9255- case 721LLU: // deleter
9291+ case 727LLU: // deleter
92569292 {
92579293 // throw from newvarraw
92589294 if(!stack[base + 0])
92599295 {
92609296 fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9261- label = 699LLU; // skip, variable already deleted/unscoped
9297+ label = 705LLU; // skip, variable already deleted/unscoped
92629298 break;
92639299 }
92649300 fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
9265- label = 699LLU; // continue unrolling stack, delete next variable
9301+ label = 705LLU; // continue unrolling stack, delete next variable
92669302 break;
92679303 }
9268- case 722LLU: // skipped deleter
9304+ case 728LLU: // skipped deleter
92699305 {
92709306 stack[base + 0] = stack[base + 10]/*index*/;
92719307 // return from newvarraw
@@ -9273,7 +9309,7 @@
92739309 base = stack[base - 2];
92749310 break;
92759311 }
9276- case 724LLU: // function newvar failed
9312+ case 730LLU: // function newvar failed
92779313 {
92789314 fprintf(stderr, "function newvar failed\n");
92799315 label = stack[base - 3];
@@ -9280,7 +9316,7 @@
92809316 base = stack[base - 2];
92819317 break;
92829318 }
9283- case 723LLU: // newvar
9319+ case 729LLU: // newvar
92849320 {
92859321 //#define arg0 0
92869322 //#define arg1 1
@@ -9292,9 +9328,9 @@
92929328 //#define arg7 7
92939329 printf("%s", "\n//#define ");
92949330 // call printid from newvar
9295- stack[base + 8LLU] = 725LLU/*throw to this address*/;
9331+ stack[base + 8LLU] = 731LLU/*throw to this address*/;
92969332 stack[base + 9LLU] = base;
9297- stack[base + 10LLU] = 726LLU;
9333+ stack[base + 10LLU] = 732LLU;
92989334 // arguments for call to printid
92999335 stack[base + 11LLU] = stack[base + 1]/*id*/;
93009336 // set stack-base & callee-address
@@ -9302,19 +9338,19 @@
93029338 label = 18446744073709551587LLU; // printid
93039339 break;
93049340 }
9305- case 725LLU: // copy-back deleter (printid to newvar)
9341+ case 731LLU: // copy-back deleter (printid to newvar)
93069342 {
93079343 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
93089344 // copy mutable arguments back from call to printid
9309- label = 724LLU; // continue to roll stack
9345+ label = 730LLU; // continue to roll stack
93109346 break;
93119347 }
9312- case 726LLU: // return from printid to newvar
9348+ case 732LLU: // return from printid to newvar
93139349 {
93149350 // copy mutable arguments back from call to printid
93159351 if(/*scope*/0 != ((uint64_t *)(stack[base + 7]/*scope*/))[0])
93169352 {
9317- label = 728LLU; // jump to alternative
9353+ label = 734LLU; // jump to alternative
93189354 break;
93199355 }
93209356
@@ -9322,29 +9358,29 @@
93229358 /*letdefs*/stack[base + 9] = ((uint64_t **)(stack[base + 7]/*scope*/))[1][1]/*letdefs*/;
93239359
93249360 // case
9325- label = 731LLU; // skip deleter
9361+ label = 737LLU; // skip deleter
93269362 break;
93279363 }
9328- case 730LLU: // deleter
9364+ case 736LLU: // deleter
93299365 {
93309366 // throw from newvar
93319367 if(!stack[base + 10])
93329368 {
93339369 fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9334- label = 729LLU; // skip, variable already deleted/unscoped
9370+ label = 735LLU; // skip, variable already deleted/unscoped
93359371 break;
93369372 }
93379373 fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9338- label = 729LLU; // continue unrolling stack, delete next variable
9374+ label = 735LLU; // continue unrolling stack, delete next variable
93399375 break;
93409376 }
9341- case 731LLU: // skipped deleter
9377+ case 737LLU: // skipped deleter
93429378 {
93439379 stack[base + 10] = 0;
93449380 // call add from newvar
9345- stack[base + 11LLU] = 732LLU/*throw to this address*/;
9381+ stack[base + 11LLU] = 738LLU/*throw to this address*/;
93469382 stack[base + 12LLU] = base;
9347- stack[base + 13LLU] = 733LLU;
9383+ stack[base + 13LLU] = 739LLU;
93489384 // arguments for call to add
93499385 stack[base + 15LLU] = stack[base + 3]/*fnrescount*/;
93509386 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9353,22 +9389,22 @@
93539389 label = 18446744073709551605LLU; // add
93549390 break;
93559391 }
9356- case 732LLU: // copy-back deleter (add to newvar)
9392+ case 738LLU: // copy-back deleter (add to newvar)
93579393 {
93589394 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
93599395 // copy mutable arguments back from call to add
9360- label = 730LLU; // continue to roll stack
9396+ label = 736LLU; // continue to roll stack
93619397 break;
93629398 }
9363- case 733LLU: // return from add to newvar
9399+ case 739LLU: // return from add to newvar
93649400 {
93659401 // copy mutable arguments back from call to add
93669402 // copy back results provided by call to add
93679403 stack[base + 10] = stack[base + 14LLU];
93689404 // call add from newvar
9369- stack[base + 11LLU] = 734LLU/*throw to this address*/;
9405+ stack[base + 11LLU] = 740LLU/*throw to this address*/;
93709406 stack[base + 12LLU] = base;
9371- stack[base + 13LLU] = 735LLU;
9407+ stack[base + 13LLU] = 741LLU;
93729408 // arguments for call to add
93739409 stack[base + 15LLU] = stack[base + 4]/*fnargcount*/;
93749410 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9377,22 +9413,22 @@
93779413 label = 18446744073709551605LLU; // add
93789414 break;
93799415 }
9380- case 734LLU: // copy-back deleter (add to newvar)
9416+ case 740LLU: // copy-back deleter (add to newvar)
93819417 {
93829418 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
93839419 // copy mutable arguments back from call to add
9384- label = 730LLU; // continue to roll stack
9420+ label = 736LLU; // continue to roll stack
93859421 break;
93869422 }
9387- case 735LLU: // return from add to newvar
9423+ case 741LLU: // return from add to newvar
93889424 {
93899425 // copy mutable arguments back from call to add
93909426 // copy back results provided by call to add
93919427 stack[base + 10] = stack[base + 14LLU];
93929428 // call add from newvar
9393- stack[base + 11LLU] = 736LLU/*throw to this address*/;
9429+ stack[base + 11LLU] = 742LLU/*throw to this address*/;
93949430 stack[base + 12LLU] = base;
9395- stack[base + 13LLU] = 737LLU;
9431+ stack[base + 13LLU] = 743LLU;
93969432 // arguments for call to add
93979433 stack[base + 15LLU] = stack[base + 6]/*varcount*/;
93989434 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9401,14 +9437,14 @@
94019437 label = 18446744073709551605LLU; // add
94029438 break;
94039439 }
9404- case 736LLU: // copy-back deleter (add to newvar)
9440+ case 742LLU: // copy-back deleter (add to newvar)
94059441 {
94069442 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
94079443 // copy mutable arguments back from call to add
9408- label = 730LLU; // continue to roll stack
9444+ label = 736LLU; // continue to roll stack
94099445 break;
94109446 }
9411- case 737LLU: // return from add to newvar
9447+ case 743LLU: // return from add to newvar
94129448 {
94139449 // copy mutable arguments back from call to add
94149450 // copy back results provided by call to add
@@ -9415,9 +9451,9 @@
94159451 stack[base + 10] = stack[base + 14LLU];
94169452 printf("%s", " ");
94179453 // call printnr from newvar
9418- stack[base + 11LLU] = 738LLU/*throw to this address*/;
9454+ stack[base + 11LLU] = 744LLU/*throw to this address*/;
94199455 stack[base + 12LLU] = base;
9420- stack[base + 13LLU] = 739LLU;
9456+ stack[base + 13LLU] = 745LLU;
94219457 // arguments for call to printnr
94229458 stack[base + 14LLU] = stack[base + 10]/*sum*/;
94239459 // set stack-base & callee-address
@@ -9425,20 +9461,20 @@
94259461 label = 18446744073709551590LLU; // printnr
94269462 break;
94279463 }
9428- case 738LLU: // copy-back deleter (printnr to newvar)
9464+ case 744LLU: // copy-back deleter (printnr to newvar)
94299465 {
94309466 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
94319467 // copy mutable arguments back from call to printnr
9432- label = 730LLU; // continue to roll stack
9468+ label = 736LLU; // continue to roll stack
94339469 break;
94349470 }
9435- case 739LLU: // return from printnr to newvar
9471+ case 745LLU: // return from printnr to newvar
94369472 {
94379473 // copy mutable arguments back from call to printnr
94389474 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
94399475 if(!newstack)
94409476 {
9441- label = 730LLU; // throw: begin to unroll stack
9477+ label = 736LLU; // throw: begin to unroll stack
94429478 break;
94439479 }
94449480
@@ -9445,18 +9481,18 @@
94459481 newstack[15LLU] = 9876543210LLU; // overflow-marker
94469482 // call copytype from newvar
94479483 newstack[0] = (uint64_t)stack; // backup stack location
9448- newstack[1] = 740LLU;
9484+ newstack[1] = 746LLU;
94499485 newstack[2] = base;
9450- newstack[3] = 741LLU;
9486+ newstack[3] = 747LLU;
94519487 // arguments for call to copytype
94529488 newstack[5LLU] = stack[base + 0]/*type*/;
94539489 stack = newstack;
94549490 // set stack-base & callee-address
94559491 base = 4/*deloffset*/;
9456- label = 326LLU; // copytype
9492+ label = 327LLU; // copytype
94579493 break;
94589494 }
9459- case 740LLU: // copy-back deleter (copytype to newvar)
9495+ case 746LLU: // copy-back deleter (copytype to newvar)
94609496 {
94619497 fprintf(stderr, "in function newvar: unrolling stack, copy-back (copytype to newvar)\n");
94629498 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -9468,10 +9504,10 @@
94689504 }
94699505 Free(15LLU + 1, sizeof(uint64_t), stack);
94709506 stack = oldstack;
9471- label = 730LLU; // continue to unroll stack
9507+ label = 736LLU; // continue to unroll stack
94729508 break;
94739509 }
9474- case 741LLU: // return from copytype to newvar
9510+ case 747LLU: // return from copytype to newvar
94759511 {
94769512 uint64_t *oldstack = (uint64_t *)stack[0];
94779513 // copy mutable arguments back from call to copytype
@@ -9484,35 +9520,35 @@
94849520 }
94859521 Free(15LLU + 1, sizeof(uint64_t), stack);
94869522 stack = oldstack;
9487- label = 743LLU; // skip deleter
9523+ label = 749LLU; // skip deleter
94889524 break;
94899525 }
9490- case 742LLU: // deleter
9526+ case 748LLU: // deleter
94919527 {
94929528 // throw from newvar
94939529 if(!stack[base + 12])
94949530 {
94959531 fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9496- label = 730LLU; // skip, variable already deleted/unscoped
9532+ label = 736LLU; // skip, variable already deleted/unscoped
94979533 break;
94989534 }
94999535 fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9500- label = 730LLU; // continue unrolling stack, delete next variable
9536+ label = 736LLU; // continue unrolling stack, delete next variable
95019537 break;
95029538 }
9503- case 743LLU: // skipped deleter
9539+ case 749LLU: // skipped deleter
95049540 {
95059541 stack[base + 12] = 0;
9506- label = 745LLU; // skip deleter
9542+ label = 751LLU; // skip deleter
95079543 break;
95089544 }
9509- case 744LLU: // deleter
9545+ case 750LLU: // deleter
95109546 {
95119547 // throw from newvar
95129548 if(!stack[base + 13])
95139549 {
95149550 fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable letdef \n");
9515- label = 742LLU; // skip, variable already deleted/unscoped
9551+ label = 748LLU; // skip, variable already deleted/unscoped
95169552 break;
95179553 }
95189554 fprintf(stderr, "in function newvar: unrolling stack, variable letdef \n");
@@ -9522,28 +9558,28 @@
95229558 newstack[0] = (uint64_t)stack; // backup stack location
95239559 newstack[1] = 1234567890;
95249560 newstack[2] = base;
9525- newstack[3] = 746LLU;
9561+ newstack[3] = 752LLU;
95269562 stack = newstack;
95279563 // set stack-base & callee-address
95289564 base = 4/*deloffset*/;
9529- label = 455LLU; // ~letdef
9565+ label = 457LLU; // ~letdef
95309566 break;
95319567 }
9532- case 746LLU: // return from ~letdef to newvar
9568+ case 752LLU: // return from ~letdef to newvar
95339569 {
95349570 stack = (uint64_t *)stack[0];
95359571 // releasing toplevel container
953695