OSDN > Find Software > Software Development > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	1168 (tree)
Time	2021-02-24 04:57:52
Author	jakobthomsen

Log Message

fix copy-back on exception in while-next

Change Summary

modified: trunk/jpl_compiler_pragmatic/compiler.compiled.c (diff)
modified: trunk/jpl_compiler_pragmatic/compiler.source.c (diff)

Incremental Difference

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1167)

+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1168)

		@@ -2612,20 +2612,20 @@
2612	2612	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
2613	2613	if(!stack[base + 3]/found/)
2614	2614	{
2615		- label = 151LLU; // jump to alternative
	2615	+ label = 152LLU; // jump to alternative
2616	2616	break;
2617	2617	}
2618	2618
2619	2619	// consequent
2620		- label = 152LLU; // consequent complete
	2620	+ label = 153LLU; // consequent complete
2621	2621	break;
2622	2622	}
2623		- case 151LLU: // alternative
	2623	+ case 152LLU: // alternative
2624	2624	{
2625	2625	// call equ from existsid
2626		- stack[base + 7LLU] = 153LLU/throw to this address/;
	2626	+ stack[base + 7LLU] = 154LLU/throw to this address/;
2627	2627	stack[base + 8LLU] = base;
2628		- stack[base + 9LLU] = 154LLU;
	2628	+ stack[base + 9LLU] = 155LLU;
2629	2629	// arguments for call to equ
2630	2630	stack[base + 11LLU] = stack[base + 5]/current/;
2631	2631	stack[base + 12LLU] = stack[base + 2]/wanted/;

		@@ -2634,33 +2634,39 @@
2634	2634	label = 18446744073709551600LLU; // equ
2635	2635	break;
2636	2636	}
2637		- case 153LLU: // copy-back deleter (equ to existsid)
	2637	+ case 154LLU: // copy-back deleter (equ to existsid)
2638	2638	{
2639	2639	fprintf(stderr, "in function existsid: unrolling stack, copy-back (equ to existsid)\n");
2640	2640	// copy mutable arguments back from call to equ
2641		- label = 147LLU; // continue to roll stack
	2641	+ label = 151LLU; // continue to roll stack
2642	2642	break;
2643	2643	}
2644		- case 154LLU: // return from equ to existsid
	2644	+ case 155LLU: // return from equ to existsid
2645	2645	{
2646	2646	// copy mutable arguments back from call to equ
2647	2647	// copy back results provided by call to equ
2648	2648	stack[base + 3] = stack[base + 10LLU];
2649		- label = 152LLU; // alternative complete
	2649	+ label = 153LLU; // alternative complete
2650	2650	break;
2651	2651	}
2652		- case 152LLU: // completed if-then-else
	2652	+ case 153LLU: // completed if-then-else
2653	2653	{
2654	2654	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
2655	2655	label = 149LLU; // repeat
2656	2656	break;
2657	2657	}
	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	+ }
2658	2664	case 150LLU: // loop finished
2659	2665	{
2660		- label = 156LLU; // skip deleter
	2666	+ label = 157LLU; // skip deleter
2661	2667	break;
2662	2668	}
2663		- case 155LLU: // deleter
	2669	+ case 156LLU: // deleter
2664	2670	{
2665	2671	// throw from existsid
2666	2672	if(!stack[base + 0])

		@@ -2673,7 +2679,7 @@
2673	2679	label = 147LLU; // continue unrolling stack, delete next variable
2674	2680	break;
2675	2681	}
2676		- case 156LLU: // skipped deleter
	2682	+ case 157LLU: // skipped deleter
2677	2683	{
2678	2684	stack[base + 0] = stack[base + 3]/found/;
2679	2685	// return from existsid

		@@ -2681,7 +2687,7 @@
2681	2687	base = stack[base - 2];
2682	2688	break;
2683	2689	}
2684		- case 158LLU: // function issimple failed
	2690	+ case 159LLU: // function issimple failed
2685	2691	{
2686	2692	fprintf(stderr, "function issimple failed\n");
2687	2693	label = stack[base - 3];

		@@ -2688,35 +2694,35 @@
2688	2694	base = stack[base - 2];
2689	2695	break;
2690	2696	}
2691		- case 157LLU: // issimple
	2697	+ case 158LLU: // issimple
2692	2698	{
2693	2699	//#define res0 0
2694	2700	//#define arg0 1
2695	2701	//#define arg1 2
2696	2702	//#define arg2 3
2697		- label = 160LLU; // skip deleter
	2703	+ label = 161LLU; // skip deleter
2698	2704	break;
2699	2705	}
2700		- case 159LLU: // deleter
	2706	+ case 160LLU: // deleter
2701	2707	{
2702	2708	// throw from issimple
2703	2709	if(!stack[base + 4])
2704	2710	{
2705	2711	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
2707	2713	break;
2708	2714	}
2709	2715	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
2711	2717	break;
2712	2718	}
2713		- case 160LLU: // skipped deleter
	2719	+ case 161LLU: // skipped deleter
2714	2720	{
2715	2721	stack[base + 4] = 0;
2716	2722	// call equ from issimple
2717		- stack[base + 5LLU] = 161LLU/throw to this address/;
	2723	+ stack[base + 5LLU] = 162LLU/throw to this address/;
2718	2724	stack[base + 6LLU] = base;
2719		- stack[base + 7LLU] = 162LLU;
	2725	+ stack[base + 7LLU] = 163LLU;
2720	2726	// arguments for call to equ
2721	2727	stack[base + 9LLU] = stack[base + 1]/variant/;
2722	2728	stack[base + 10LLU] = 0LLU;

		@@ -2725,14 +2731,14 @@
2725	2731	label = 18446744073709551600LLU; // equ
2726	2732	break;
2727	2733	}
2728		- case 161LLU: // copy-back deleter (equ to issimple)
	2734	+ case 162LLU: // copy-back deleter (equ to issimple)
2729	2735	{
2730	2736	fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
2731	2737	// copy mutable arguments back from call to equ
2732		- label = 159LLU; // continue to roll stack
	2738	+ label = 160LLU; // continue to roll stack
2733	2739	break;
2734	2740	}
2735		- case 162LLU: // return from equ to issimple
	2741	+ case 163LLU: // return from equ to issimple
2736	2742	{
2737	2743	// copy mutable arguments back from call to equ
2738	2744	// copy back results provided by call to equ

		@@ -2739,15 +2745,15 @@
2739	2745	stack[base + 4] = stack[base + 8LLU];
2740	2746	if(!stack[base + 4]/isequal/)
2741	2747	{
2742		- label = 163LLU; // jump to alternative
	2748	+ label = 164LLU; // jump to alternative
2743	2749	break;
2744	2750	}
2745	2751
2746	2752	// consequent
2747	2753	// call equ from issimple
2748		- stack[base + 5LLU] = 165LLU/throw to this address/;
	2754	+ stack[base + 5LLU] = 166LLU/throw to this address/;
2749	2755	stack[base + 6LLU] = base;
2750		- stack[base + 7LLU] = 166LLU;
	2756	+ stack[base + 7LLU] = 167LLU;
2751	2757	// arguments for call to equ
2752	2758	stack[base + 9LLU] = stack[base + 3]/sym/;
2753	2759	stack[base + 10LLU] = stack[base + 2]/content/;

		@@ -2756,14 +2762,14 @@
2756	2762	label = 18446744073709551600LLU; // equ
2757	2763	break;
2758	2764	}
2759		- case 165LLU: // copy-back deleter (equ to issimple)
	2765	+ case 166LLU: // copy-back deleter (equ to issimple)
2760	2766	{
2761	2767	fprintf(stderr, "in function issimple: unrolling stack, copy-back (equ to issimple)\n");
2762	2768	// copy mutable arguments back from call to equ
2763		- label = 159LLU; // continue to roll stack
	2769	+ label = 160LLU; // continue to roll stack
2764	2770	break;
2765	2771	}
2766		- case 166LLU: // return from equ to issimple
	2772	+ case 167LLU: // return from equ to issimple
2767	2773	{
2768	2774	// copy mutable arguments back from call to equ
2769	2775	// copy back results provided by call to equ

		@@ -2770,87 +2776,87 @@
2770	2776	stack[base + 4] = stack[base + 8LLU];
2771	2777	if(!stack[base + 4]/isequal/)
2772	2778	{
2773		- label = 167LLU; // jump to alternative
	2779	+ label = 168LLU; // jump to alternative
2774	2780	break;
2775	2781	}
2776	2782
2777	2783	// consequent
2778		- label = 170LLU; // skip deleter
	2784	+ label = 171LLU; // skip deleter
2779	2785	break;
2780	2786	}
2781		- case 169LLU: // deleter
	2787	+ case 170LLU: // deleter
2782	2788	{
2783	2789	// throw from issimple
2784	2790	if(!stack[base + 0])
2785	2791	{
2786	2792	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
2788	2794	break;
2789	2795	}
2790	2796	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
2792	2798	break;
2793	2799	}
2794		- case 170LLU: // skipped deleter
	2800	+ case 171LLU: // skipped deleter
2795	2801	{
2796	2802	stack[base + 0] = 1;
2797		- label = 168LLU; // consequent complete
	2803	+ label = 169LLU; // consequent complete
2798	2804	break;
2799	2805	}
2800		- case 167LLU: // alternative
	2806	+ case 168LLU: // alternative
2801	2807	{
2802		- label = 172LLU; // skip deleter
	2808	+ label = 173LLU; // skip deleter
2803	2809	break;
2804	2810	}
2805		- case 171LLU: // deleter
	2811	+ case 172LLU: // deleter
2806	2812	{
2807	2813	// throw from issimple
2808	2814	if(!stack[base + 0])
2809	2815	{
2810	2816	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
2812	2818	break;
2813	2819	}
2814	2820	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
2816	2822	break;
2817	2823	}
2818		- case 172LLU: // skipped deleter
	2824	+ case 173LLU: // skipped deleter
2819	2825	{
2820	2826	stack[base + 0] = 0;
2821		- label = 168LLU; // alternative complete
	2827	+ label = 169LLU; // alternative complete
2822	2828	break;
2823	2829	}
2824		- case 168LLU: // completed if-then-else
	2830	+ case 169LLU: // completed if-then-else
2825	2831	{
2826		- label = 164LLU; // consequent complete
	2832	+ label = 165LLU; // consequent complete
2827	2833	break;
2828	2834	}
2829		- case 163LLU: // alternative
	2835	+ case 164LLU: // alternative
2830	2836	{
2831		- label = 174LLU; // skip deleter
	2837	+ label = 175LLU; // skip deleter
2832	2838	break;
2833	2839	}
2834		- case 173LLU: // deleter
	2840	+ case 174LLU: // deleter
2835	2841	{
2836	2842	// throw from issimple
2837	2843	if(!stack[base + 0])
2838	2844	{
2839	2845	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
2841	2847	break;
2842	2848	}
2843	2849	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
2845	2851	break;
2846	2852	}
2847		- case 174LLU: // skipped deleter
	2853	+ case 175LLU: // skipped deleter
2848	2854	{
2849	2855	stack[base + 0] = 0;
2850		- label = 164LLU; // alternative complete
	2856	+ label = 165LLU; // alternative complete
2851	2857	break;
2852	2858	}
2853		- case 164LLU: // completed if-then-else
	2859	+ case 165LLU: // completed if-then-else
2854	2860	{
2855	2861	// return from issimple
2856	2862	label = stack[base - 1];

		@@ -2857,7 +2863,7 @@
2857	2863	base = stack[base - 2];
2858	2864	break;
2859	2865	}
2860		- case 176LLU: // function isident failed
	2866	+ case 177LLU: // function isident failed
2861	2867	{
2862	2868	fprintf(stderr, "function isident failed\n");
2863	2869	label = stack[base - 3];

		@@ -2864,35 +2870,35 @@
2864	2870	base = stack[base - 2];
2865	2871	break;
2866	2872	}
2867		- case 175LLU: // isident
	2873	+ case 176LLU: // isident
2868	2874	{
2869	2875	//#define res0 0
2870	2876	//#define arg0 1
2871	2877	//#define arg1 2
2872	2878	//#define arg2 3
2873		- label = 178LLU; // skip deleter
	2879	+ label = 179LLU; // skip deleter
2874	2880	break;
2875	2881	}
2876		- case 177LLU: // deleter
	2882	+ case 178LLU: // deleter
2877	2883	{
2878	2884	// throw from isident
2879	2885	if(!stack[base + 4])
2880	2886	{
2881	2887	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
2883	2889	break;
2884	2890	}
2885	2891	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
2887	2893	break;
2888	2894	}
2889		- case 178LLU: // skipped deleter
	2895	+ case 179LLU: // skipped deleter
2890	2896	{
2891	2897	stack[base + 4] = 0;
2892	2898	// call equ from isident
2893		- stack[base + 5LLU] = 179LLU/throw to this address/;
	2899	+ stack[base + 5LLU] = 180LLU/throw to this address/;
2894	2900	stack[base + 6LLU] = base;
2895		- stack[base + 7LLU] = 180LLU;
	2901	+ stack[base + 7LLU] = 181LLU;
2896	2902	// arguments for call to equ
2897	2903	stack[base + 9LLU] = stack[base + 1]/variant/;
2898	2904	stack[base + 10LLU] = 4LLU;

		@@ -2901,14 +2907,14 @@
2901	2907	label = 18446744073709551600LLU; // equ
2902	2908	break;
2903	2909	}
2904		- case 179LLU: // copy-back deleter (equ to isident)
	2910	+ case 180LLU: // copy-back deleter (equ to isident)
2905	2911	{
2906	2912	fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
2907	2913	// copy mutable arguments back from call to equ
2908		- label = 177LLU; // continue to roll stack
	2914	+ label = 178LLU; // continue to roll stack
2909	2915	break;
2910	2916	}
2911		- case 180LLU: // return from equ to isident
	2917	+ case 181LLU: // return from equ to isident
2912	2918	{
2913	2919	// copy mutable arguments back from call to equ
2914	2920	// copy back results provided by call to equ

		@@ -2915,15 +2921,15 @@
2915	2921	stack[base + 4] = stack[base + 8LLU];
2916	2922	if(!stack[base + 4]/isequal/)
2917	2923	{
2918		- label = 181LLU; // jump to alternative
	2924	+ label = 182LLU; // jump to alternative
2919	2925	break;
2920	2926	}
2921	2927
2922	2928	// consequent
2923	2929	// call equ from isident
2924		- stack[base + 5LLU] = 183LLU/throw to this address/;
	2930	+ stack[base + 5LLU] = 184LLU/throw to this address/;
2925	2931	stack[base + 6LLU] = base;
2926		- stack[base + 7LLU] = 184LLU;
	2932	+ stack[base + 7LLU] = 185LLU;
2927	2933	// arguments for call to equ
2928	2934	stack[base + 9LLU] = stack[base + 3]/ident/;
2929	2935	stack[base + 10LLU] = stack[base + 2]/content/;

		@@ -2932,14 +2938,14 @@
2932	2938	label = 18446744073709551600LLU; // equ
2933	2939	break;
2934	2940	}
2935		- case 183LLU: // copy-back deleter (equ to isident)
	2941	+ case 184LLU: // copy-back deleter (equ to isident)
2936	2942	{
2937	2943	fprintf(stderr, "in function isident: unrolling stack, copy-back (equ to isident)\n");
2938	2944	// copy mutable arguments back from call to equ
2939		- label = 177LLU; // continue to roll stack
	2945	+ label = 178LLU; // continue to roll stack
2940	2946	break;
2941	2947	}
2942		- case 184LLU: // return from equ to isident
	2948	+ case 185LLU: // return from equ to isident
2943	2949	{
2944	2950	// copy mutable arguments back from call to equ
2945	2951	// copy back results provided by call to equ

		@@ -2946,87 +2952,87 @@
2946	2952	stack[base + 4] = stack[base + 8LLU];
2947	2953	if(!stack[base + 4]/isequal/)
2948	2954	{
2949		- label = 185LLU; // jump to alternative
	2955	+ label = 186LLU; // jump to alternative
2950	2956	break;
2951	2957	}
2952	2958
2953	2959	// consequent
2954		- label = 188LLU; // skip deleter
	2960	+ label = 189LLU; // skip deleter
2955	2961	break;
2956	2962	}
2957		- case 187LLU: // deleter
	2963	+ case 188LLU: // deleter
2958	2964	{
2959	2965	// throw from isident
2960	2966	if(!stack[base + 0])
2961	2967	{
2962	2968	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
2964	2970	break;
2965	2971	}
2966	2972	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
2968	2974	break;
2969	2975	}
2970		- case 188LLU: // skipped deleter
	2976	+ case 189LLU: // skipped deleter
2971	2977	{
2972	2978	stack[base + 0] = 1;
2973		- label = 186LLU; // consequent complete
	2979	+ label = 187LLU; // consequent complete
2974	2980	break;
2975	2981	}
2976		- case 185LLU: // alternative
	2982	+ case 186LLU: // alternative
2977	2983	{
2978		- label = 190LLU; // skip deleter
	2984	+ label = 191LLU; // skip deleter
2979	2985	break;
2980	2986	}
2981		- case 189LLU: // deleter
	2987	+ case 190LLU: // deleter
2982	2988	{
2983	2989	// throw from isident
2984	2990	if(!stack[base + 0])
2985	2991	{
2986	2992	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
2988	2994	break;
2989	2995	}
2990	2996	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
2992	2998	break;
2993	2999	}
2994		- case 190LLU: // skipped deleter
	3000	+ case 191LLU: // skipped deleter
2995	3001	{
2996	3002	stack[base + 0] = 0;
2997		- label = 186LLU; // alternative complete
	3003	+ label = 187LLU; // alternative complete
2998	3004	break;
2999	3005	}
3000		- case 186LLU: // completed if-then-else
	3006	+ case 187LLU: // completed if-then-else
3001	3007	{
3002		- label = 182LLU; // consequent complete
	3008	+ label = 183LLU; // consequent complete
3003	3009	break;
3004	3010	}
3005		- case 181LLU: // alternative
	3011	+ case 182LLU: // alternative
3006	3012	{
3007		- label = 192LLU; // skip deleter
	3013	+ label = 193LLU; // skip deleter
3008	3014	break;
3009	3015	}
3010		- case 191LLU: // deleter
	3016	+ case 192LLU: // deleter
3011	3017	{
3012	3018	// throw from isident
3013	3019	if(!stack[base + 0])
3014	3020	{
3015	3021	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
3017	3023	break;
3018	3024	}
3019	3025	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
3021	3027	break;
3022	3028	}
3023		- case 192LLU: // skipped deleter
	3029	+ case 193LLU: // skipped deleter
3024	3030	{
3025	3031	stack[base + 0] = 0;
3026		- label = 182LLU; // alternative complete
	3032	+ label = 183LLU; // alternative complete
3027	3033	break;
3028	3034	}
3029		- case 182LLU: // completed if-then-else
	3035	+ case 183LLU: // completed if-then-else
3030	3036	{
3031	3037	// return from isident
3032	3038	label = stack[base - 1];

		@@ -3033,7 +3039,7 @@
3033	3039	base = stack[base - 2];
3034	3040	break;
3035	3041	}
3036		- case 194LLU: // function iseos failed
	3042	+ case 195LLU: // function iseos failed
3037	3043	{
3038	3044	fprintf(stderr, "function iseos failed\n");
3039	3045	label = stack[base - 3];

		@@ -3040,14 +3046,14 @@
3040	3046	base = stack[base - 2];
3041	3047	break;
3042	3048	}
3043		- case 193LLU: // iseos
	3049	+ case 194LLU: // iseos
3044	3050	{
3045	3051	//#define res0 0
3046	3052	//#define arg0 1
3047	3053	// call equ from iseos
3048		- stack[base + 2LLU] = 195LLU/throw to this address/;
	3054	+ stack[base + 2LLU] = 196LLU/throw to this address/;
3049	3055	stack[base + 3LLU] = base;
3050		- stack[base + 4LLU] = 196LLU;
	3056	+ stack[base + 4LLU] = 197LLU;
3051	3057	// arguments for call to equ
3052	3058	stack[base + 6LLU] = stack[base + 1]/variantnr/;
3053	3059	stack[base + 7LLU] = 5LLU;

		@@ -3056,14 +3062,14 @@
3056	3062	label = 18446744073709551600LLU; // equ
3057	3063	break;
3058	3064	}
3059		- case 195LLU: // copy-back deleter (equ to iseos)
	3065	+ case 196LLU: // copy-back deleter (equ to iseos)
3060	3066	{
3061	3067	fprintf(stderr, "in function iseos: unrolling stack, copy-back (equ to iseos)\n");
3062	3068	// copy mutable arguments back from call to equ
3063		- label = 194LLU; // continue to roll stack
	3069	+ label = 195LLU; // continue to roll stack
3064	3070	break;
3065	3071	}
3066		- case 196LLU: // return from equ to iseos
	3072	+ case 197LLU: // return from equ to iseos
3067	3073	{
3068	3074	// copy mutable arguments back from call to equ
3069	3075	// copy back results provided by call to equ

		@@ -3073,7 +3079,7 @@
3073	3079	base = stack[base - 2];
3074	3080	break;
3075	3081	}
3076		- case 198LLU: // function MATCHPEEK failed
	3082	+ case 199LLU: // function MATCHPEEK failed
3077	3083	{
3078	3084	fprintf(stderr, "function MATCHPEEK failed\n");
3079	3085	label = stack[base - 3];

		@@ -3080,15 +3086,15 @@
3080	3086	base = stack[base - 2];
3081	3087	break;
3082	3088	}
3083		- case 197LLU: // MATCHPEEK
	3089	+ case 198LLU: // MATCHPEEK
3084	3090	{
3085	3091	//#define arg0 0
3086	3092	//#define arg1 1
3087	3093	//#define arg2 2
3088	3094	// call skipwscmnt from MATCHPEEK
3089		- stack[base + 3LLU] = 199LLU/throw to this address/;
	3095	+ stack[base + 3LLU] = 200LLU/throw to this address/;
3090	3096	stack[base + 4LLU] = base;
3091		- stack[base + 5LLU] = 200LLU;
	3097	+ stack[base + 5LLU] = 201LLU;
3092	3098	// arguments for call to skipwscmnt
3093	3099	stack[base + 7LLU] = stack[base + 2]/lookahead/;
3094	3100	// set stack-base & callee-address

		@@ -3096,22 +3102,22 @@
3096	3102	label = 18446744073709551580LLU; // skipwscmnt
3097	3103	break;
3098	3104	}
3099		- case 199LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
	3105	+ case 200LLU: // copy-back deleter (skipwscmnt to MATCHPEEK)
3100	3106	{
3101	3107	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (skipwscmnt to MATCHPEEK)\n");
3102	3108	// copy mutable arguments back from call to skipwscmnt
3103		- label = 198LLU; // continue to roll stack
	3109	+ label = 199LLU; // continue to roll stack
3104	3110	break;
3105	3111	}
3106		- case 200LLU: // return from skipwscmnt to MATCHPEEK
	3112	+ case 201LLU: // return from skipwscmnt to MATCHPEEK
3107	3113	{
3108	3114	// copy mutable arguments back from call to skipwscmnt
3109	3115	// copy back results provided by call to skipwscmnt
3110	3116	stack[base + 2] = stack[base + 6LLU];
3111	3117	// call equ from MATCHPEEK
3112		- stack[base + 4LLU] = 201LLU/throw to this address/;
	3118	+ stack[base + 4LLU] = 202LLU/throw to this address/;
3113	3119	stack[base + 5LLU] = base;
3114		- stack[base + 6LLU] = 202LLU;
	3120	+ stack[base + 6LLU] = 203LLU;
3115	3121	// arguments for call to equ
3116	3122	stack[base + 8LLU] = stack[base + 2]/lookahead/;
3117	3123	stack[base + 9LLU] = stack[base + 1]/sym/;

		@@ -3120,14 +3126,14 @@
3120	3126	label = 18446744073709551600LLU; // equ
3121	3127	break;
3122	3128	}
3123		- case 201LLU: // copy-back deleter (equ to MATCHPEEK)
	3129	+ case 202LLU: // copy-back deleter (equ to MATCHPEEK)
3124	3130	{
3125	3131	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (equ to MATCHPEEK)\n");
3126	3132	// copy mutable arguments back from call to equ
3127		- label = 198LLU; // continue to roll stack
	3133	+ label = 199LLU; // continue to roll stack
3128	3134	break;
3129	3135	}
3130		- case 202LLU: // return from equ to MATCHPEEK
	3136	+ case 203LLU: // return from equ to MATCHPEEK
3131	3137	{
3132	3138	// copy mutable arguments back from call to equ
3133	3139	// copy back results provided by call to equ

		@@ -3134,21 +3140,21 @@
3134	3140	stack[base + 3] = stack[base + 7LLU];
3135	3141	if(!stack[base + 3]/isqual/)
3136	3142	{
3137		- label = 203LLU; // jump to alternative
	3143	+ label = 204LLU; // jump to alternative
3138	3144	break;
3139	3145	}
3140	3146
3141	3147	// consequent
3142		- label = 204LLU; // consequent complete
	3148	+ label = 205LLU; // consequent complete
3143	3149	break;
3144	3150	}
3145		- case 203LLU: // alternative
	3151	+ case 204LLU: // alternative
3146	3152	{
3147	3153	fprintf(stderr, "%s", "in function ");
3148	3154	// call reportid from MATCHPEEK
3149		- stack[base + 4LLU] = 205LLU/throw to this address/;
	3155	+ stack[base + 4LLU] = 206LLU/throw to this address/;
3150	3156	stack[base + 5LLU] = base;
3151		- stack[base + 6LLU] = 206LLU;
	3157	+ stack[base + 6LLU] = 207LLU;
3152	3158	// arguments for call to reportid
3153	3159	stack[base + 7LLU] = stack[base + 0]/fnid/;
3154	3160	// set stack-base & callee-address

		@@ -3156,22 +3162,22 @@
3156	3162	label = 18446744073709551586LLU; // reportid
3157	3163	break;
3158	3164	}
3159		- case 205LLU: // copy-back deleter (reportid to MATCHPEEK)
	3165	+ case 206LLU: // copy-back deleter (reportid to MATCHPEEK)
3160	3166	{
3161	3167	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportid to MATCHPEEK)\n");
3162	3168	// copy mutable arguments back from call to reportid
3163		- label = 198LLU; // continue to roll stack
	3169	+ label = 199LLU; // continue to roll stack
3164	3170	break;
3165	3171	}
3166		- case 206LLU: // return from reportid to MATCHPEEK
	3172	+ case 207LLU: // return from reportid to MATCHPEEK
3167	3173	{
3168	3174	// copy mutable arguments back from call to reportid
3169	3175	fprintf(stderr, "%s", ": ");
3170	3176	fprintf(stderr, "%s", "expected '");
3171	3177	// call reportbyte from MATCHPEEK
3172		- stack[base + 4LLU] = 207LLU/throw to this address/;
	3178	+ stack[base + 4LLU] = 208LLU/throw to this address/;
3173	3179	stack[base + 5LLU] = base;
3174		- stack[base + 6LLU] = 208LLU;
	3180	+ stack[base + 6LLU] = 209LLU;
3175	3181	// arguments for call to reportbyte
3176	3182	stack[base + 7LLU] = stack[base + 1]/sym/;
3177	3183	// set stack-base & callee-address

		@@ -3179,21 +3185,21 @@
3179	3185	label = 18446744073709551591LLU; // reportbyte
3180	3186	break;
3181	3187	}
3182		- case 207LLU: // copy-back deleter (reportbyte to MATCHPEEK)
	3188	+ case 208LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3183	3189	{
3184	3190	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
3185	3191	// copy mutable arguments back from call to reportbyte
3186		- label = 198LLU; // continue to roll stack
	3192	+ label = 199LLU; // continue to roll stack
3187	3193	break;
3188	3194	}
3189		- case 208LLU: // return from reportbyte to MATCHPEEK
	3195	+ case 209LLU: // return from reportbyte to MATCHPEEK
3190	3196	{
3191	3197	// copy mutable arguments back from call to reportbyte
3192	3198	fprintf(stderr, "%s", "' but found token ");
3193	3199	// call reportbyte from MATCHPEEK
3194		- stack[base + 4LLU] = 209LLU/throw to this address/;
	3200	+ stack[base + 4LLU] = 210LLU/throw to this address/;
3195	3201	stack[base + 5LLU] = base;
3196		- stack[base + 6LLU] = 210LLU;
	3202	+ stack[base + 6LLU] = 211LLU;
3197	3203	// arguments for call to reportbyte
3198	3204	stack[base + 7LLU] = stack[base + 2]/lookahead/;
3199	3205	// set stack-base & callee-address

		@@ -3201,22 +3207,22 @@
3201	3207	label = 18446744073709551591LLU; // reportbyte
3202	3208	break;
3203	3209	}
3204		- case 209LLU: // copy-back deleter (reportbyte to MATCHPEEK)
	3210	+ case 210LLU: // copy-back deleter (reportbyte to MATCHPEEK)
3205	3211	{
3206	3212	fprintf(stderr, "in function MATCHPEEK: unrolling stack, copy-back (reportbyte to MATCHPEEK)\n");
3207	3213	// copy mutable arguments back from call to reportbyte
3208		- label = 198LLU; // continue to roll stack
	3214	+ label = 199LLU; // continue to roll stack
3209	3215	break;
3210	3216	}
3211		- case 210LLU: // return from reportbyte to MATCHPEEK
	3217	+ case 211LLU: // return from reportbyte to MATCHPEEK
3212	3218	{
3213	3219	// copy mutable arguments back from call to reportbyte
3214	3220	fprintf(stderr, "%s", "\n");
3215	3221	exit(-1);
3216		- label = 204LLU; // alternative complete
	3222	+ label = 205LLU; // alternative complete
3217	3223	break;
3218	3224	}
3219		- case 204LLU: // completed if-then-else
	3225	+ case 205LLU: // completed if-then-else
3220	3226	{
3221	3227	// return from MATCHPEEK
3222	3228	label = stack[base - 1];

		@@ -3223,7 +3229,7 @@
3223	3229	base = stack[base - 2];
3224	3230	break;
3225	3231	}
3226		- case 212LLU: // function matchsym failed
	3232	+ case 213LLU: // function matchsym failed
3227	3233	{
3228	3234	fprintf(stderr, "function matchsym failed\n");
3229	3235	label = stack[base - 3];

		@@ -3230,53 +3236,53 @@
3230	3236	base = stack[base - 2];
3231	3237	break;
3232	3238	}
3233		- case 211LLU: // matchsym
	3239	+ case 212LLU: // matchsym
3234	3240	{
3235	3241	//#define arg0 0
3236	3242	//#define arg1 1
3237	3243	//#define arg2 2
3238		- label = 214LLU; // skip deleter
	3244	+ label = 215LLU; // skip deleter
3239	3245	break;
3240	3246	}
3241		- case 213LLU: // deleter
	3247	+ case 214LLU: // deleter
3242	3248	{
3243	3249	// throw from matchsym
3244	3250	if(!stack[base + 3])
3245	3251	{
3246	3252	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
3248	3254	break;
3249	3255	}
3250	3256	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
3252	3258	break;
3253	3259	}
3254		- case 214LLU: // skipped deleter
	3260	+ case 215LLU: // skipped deleter
3255	3261	{
3256	3262	stack[base + 3] = 0;
3257		- label = 216LLU; // skip deleter
	3263	+ label = 217LLU; // skip deleter
3258	3264	break;
3259	3265	}
3260		- case 215LLU: // deleter
	3266	+ case 216LLU: // deleter
3261	3267	{
3262	3268	// throw from matchsym
3263	3269	if(!stack[base + 4])
3264	3270	{
3265	3271	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
3267	3273	break;
3268	3274	}
3269	3275	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
3271	3277	break;
3272	3278	}
3273		- case 216LLU: // skipped deleter
	3279	+ case 217LLU: // skipped deleter
3274	3280	{
3275	3281	stack[base + 4] = 0;
3276	3282	// call ParseToken from matchsym
3277		- stack[base + 5LLU] = 217LLU/throw to this address/;
	3283	+ stack[base + 5LLU] = 218LLU/throw to this address/;
3278	3284	stack[base + 6LLU] = base;
3279		- stack[base + 7LLU] = 218LLU;
	3285	+ stack[base + 7LLU] = 219LLU;
3280	3286	// arguments for call to ParseToken
3281	3287	stack[base + 10LLU] = stack[base + 2]/lookahead/;
3282	3288	// set stack-base & callee-address

		@@ -3284,15 +3290,15 @@
3284	3290	label = 3LLU; // ParseToken
3285	3291	break;
3286	3292	}
3287		- case 217LLU: // copy-back deleter (ParseToken to matchsym)
	3293	+ case 218LLU: // copy-back deleter (ParseToken to matchsym)
3288	3294	{
3289	3295	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (ParseToken to matchsym)\n");
3290	3296	// copy mutable arguments back from call to ParseToken
3291	3297	stack[base + 2]/lookahead/ = stack[base + 10LLU];
3292		- label = 215LLU; // continue to roll stack
	3298	+ label = 216LLU; // continue to roll stack
3293	3299	break;
3294	3300	}
3295		- case 218LLU: // return from ParseToken to matchsym
	3301	+ case 219LLU: // return from ParseToken to matchsym
3296	3302	{
3297	3303	// copy mutable arguments back from call to ParseToken
3298	3304	stack[base + 2]/lookahead/ = stack[base + 10LLU];

		@@ -3299,29 +3305,29 @@
3299	3305	// copy back results provided by call to ParseToken
3300	3306	stack[base + 3] = stack[base + 8LLU];
3301	3307	stack[base + 4] = stack[base + 9LLU];
3302		- label = 220LLU; // skip deleter
	3308	+ label = 221LLU; // skip deleter
3303	3309	break;
3304	3310	}
3305		- case 219LLU: // deleter
	3311	+ case 220LLU: // deleter
3306	3312	{
3307	3313	// throw from matchsym
3308	3314	if(!stack[base + 5])
3309	3315	{
3310	3316	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
3312	3318	break;
3313	3319	}
3314	3320	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
3316	3322	break;
3317	3323	}
3318		- case 220LLU: // skipped deleter
	3324	+ case 221LLU: // skipped deleter
3319	3325	{
3320	3326	stack[base + 5] = 0;
3321	3327	// call equ from matchsym
3322		- stack[base + 6LLU] = 221LLU/throw to this address/;
	3328	+ stack[base + 6LLU] = 222LLU/throw to this address/;
3323	3329	stack[base + 7LLU] = base;
3324		- stack[base + 8LLU] = 222LLU;
	3330	+ stack[base + 8LLU] = 223LLU;
3325	3331	// arguments for call to equ
3326	3332	stack[base + 10LLU] = stack[base + 3]/variant/;
3327	3333	stack[base + 11LLU] = 0LLU;

		@@ -3330,14 +3336,14 @@
3330	3336	label = 18446744073709551600LLU; // equ
3331	3337	break;
3332	3338	}
3333		- case 221LLU: // copy-back deleter (equ to matchsym)
	3339	+ case 222LLU: // copy-back deleter (equ to matchsym)
3334	3340	{
3335	3341	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
3336	3342	// copy mutable arguments back from call to equ
3337		- label = 219LLU; // continue to roll stack
	3343	+ label = 220LLU; // continue to roll stack
3338	3344	break;
3339	3345	}
3340		- case 222LLU: // return from equ to matchsym
	3346	+ case 223LLU: // return from equ to matchsym
3341	3347	{
3342	3348	// copy mutable arguments back from call to equ
3343	3349	// copy back results provided by call to equ

		@@ -3344,15 +3350,15 @@
3344	3350	stack[base + 5] = stack[base + 9LLU];
3345	3351	if(!stack[base + 5]/isqual/)
3346	3352	{
3347		- label = 223LLU; // jump to alternative
	3353	+ label = 224LLU; // jump to alternative
3348	3354	break;
3349	3355	}
3350	3356
3351	3357	// consequent
3352	3358	// call equ from matchsym
3353		- stack[base + 6LLU] = 225LLU/throw to this address/;
	3359	+ stack[base + 6LLU] = 226LLU/throw to this address/;
3354	3360	stack[base + 7LLU] = base;
3355		- stack[base + 8LLU] = 226LLU;
	3361	+ stack[base + 8LLU] = 227LLU;
3356	3362	// arguments for call to equ
3357	3363	stack[base + 10LLU] = stack[base + 1]/sym/;
3358	3364	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -3361,14 +3367,14 @@
3361	3367	label = 18446744073709551600LLU; // equ
3362	3368	break;
3363	3369	}
3364		- case 225LLU: // copy-back deleter (equ to matchsym)
	3370	+ case 226LLU: // copy-back deleter (equ to matchsym)
3365	3371	{
3366	3372	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (equ to matchsym)\n");
3367	3373	// copy mutable arguments back from call to equ
3368		- label = 219LLU; // continue to roll stack
	3374	+ label = 220LLU; // continue to roll stack
3369	3375	break;
3370	3376	}
3371		- case 226LLU: // return from equ to matchsym
	3377	+ case 227LLU: // return from equ to matchsym
3372	3378	{
3373	3379	// copy mutable arguments back from call to equ
3374	3380	// copy back results provided by call to equ

		@@ -3375,21 +3381,21 @@
3375	3381	stack[base + 5] = stack[base + 9LLU];
3376	3382	if(!stack[base + 5]/isqual/)
3377	3383	{
3378		- label = 227LLU; // jump to alternative
	3384	+ label = 228LLU; // jump to alternative
3379	3385	break;
3380	3386	}
3381	3387
3382	3388	// consequent
3383		- label = 228LLU; // consequent complete
	3389	+ label = 229LLU; // consequent complete
3384	3390	break;
3385	3391	}
3386		- case 227LLU: // alternative
	3392	+ case 228LLU: // alternative
3387	3393	{
3388	3394	fprintf(stderr, "%s", "in function ");
3389	3395	// call reportid from matchsym
3390		- stack[base + 6LLU] = 229LLU/throw to this address/;
	3396	+ stack[base + 6LLU] = 230LLU/throw to this address/;
3391	3397	stack[base + 7LLU] = base;
3392		- stack[base + 8LLU] = 230LLU;
	3398	+ stack[base + 8LLU] = 231LLU;
3393	3399	// arguments for call to reportid
3394	3400	stack[base + 9LLU] = stack[base + 0]/fnid/;
3395	3401	// set stack-base & callee-address

		@@ -3397,22 +3403,22 @@
3397	3403	label = 18446744073709551586LLU; // reportid
3398	3404	break;
3399	3405	}
3400		- case 229LLU: // copy-back deleter (reportid to matchsym)
	3406	+ case 230LLU: // copy-back deleter (reportid to matchsym)
3401	3407	{
3402	3408	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
3403	3409	// copy mutable arguments back from call to reportid
3404		- label = 219LLU; // continue to roll stack
	3410	+ label = 220LLU; // continue to roll stack
3405	3411	break;
3406	3412	}
3407		- case 230LLU: // return from reportid to matchsym
	3413	+ case 231LLU: // return from reportid to matchsym
3408	3414	{
3409	3415	// copy mutable arguments back from call to reportid
3410	3416	fprintf(stderr, "%s", ": ");
3411	3417	fprintf(stderr, "%s", "expected '");
3412	3418	// call reportbyte from matchsym
3413		- stack[base + 6LLU] = 231LLU/throw to this address/;
	3419	+ stack[base + 6LLU] = 232LLU/throw to this address/;
3414	3420	stack[base + 7LLU] = base;
3415		- stack[base + 8LLU] = 232LLU;
	3421	+ stack[base + 8LLU] = 233LLU;
3416	3422	// arguments for call to reportbyte
3417	3423	stack[base + 9LLU] = stack[base + 1]/sym/;
3418	3424	// set stack-base & callee-address

		@@ -3420,21 +3426,21 @@
3420	3426	label = 18446744073709551591LLU; // reportbyte
3421	3427	break;
3422	3428	}
3423		- case 231LLU: // copy-back deleter (reportbyte to matchsym)
	3429	+ case 232LLU: // copy-back deleter (reportbyte to matchsym)
3424	3430	{
3425	3431	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
3426	3432	// copy mutable arguments back from call to reportbyte
3427		- label = 219LLU; // continue to roll stack
	3433	+ label = 220LLU; // continue to roll stack
3428	3434	break;
3429	3435	}
3430		- case 232LLU: // return from reportbyte to matchsym
	3436	+ case 233LLU: // return from reportbyte to matchsym
3431	3437	{
3432	3438	// copy mutable arguments back from call to reportbyte
3433	3439	fprintf(stderr, "%s", "' but found token ");
3434	3440	// call reporttok from matchsym
3435		- stack[base + 6LLU] = 233LLU/throw to this address/;
	3441	+ stack[base + 6LLU] = 234LLU/throw to this address/;
3436	3442	stack[base + 7LLU] = base;
3437		- stack[base + 8LLU] = 234LLU;
	3443	+ stack[base + 8LLU] = 235LLU;
3438	3444	// arguments for call to reporttok
3439	3445	stack[base + 9LLU] = stack[base + 3]/variant/;
3440	3446	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3443,33 +3449,33 @@
3443	3449	label = 18446744073709551582LLU; // reporttok
3444	3450	break;
3445	3451	}
3446		- case 233LLU: // copy-back deleter (reporttok to matchsym)
	3452	+ case 234LLU: // copy-back deleter (reporttok to matchsym)
3447	3453	{
3448	3454	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
3449	3455	// copy mutable arguments back from call to reporttok
3450		- label = 219LLU; // continue to roll stack
	3456	+ label = 220LLU; // continue to roll stack
3451	3457	break;
3452	3458	}
3453		- case 234LLU: // return from reporttok to matchsym
	3459	+ case 235LLU: // return from reporttok to matchsym
3454	3460	{
3455	3461	// copy mutable arguments back from call to reporttok
3456	3462	fprintf(stderr, "%s", "\n");
3457	3463	exit(-1);
3458		- label = 228LLU; // alternative complete
	3464	+ label = 229LLU; // alternative complete
3459	3465	break;
3460	3466	}
3461		- case 228LLU: // completed if-then-else
	3467	+ case 229LLU: // completed if-then-else
3462	3468	{
3463		- label = 224LLU; // consequent complete
	3469	+ label = 225LLU; // consequent complete
3464	3470	break;
3465	3471	}
3466		- case 223LLU: // alternative
	3472	+ case 224LLU: // alternative
3467	3473	{
3468	3474	fprintf(stderr, "%s", "in function ");
3469	3475	// call reportid from matchsym
3470		- stack[base + 6LLU] = 235LLU/throw to this address/;
	3476	+ stack[base + 6LLU] = 236LLU/throw to this address/;
3471	3477	stack[base + 7LLU] = base;
3472		- stack[base + 8LLU] = 236LLU;
	3478	+ stack[base + 8LLU] = 237LLU;
3473	3479	// arguments for call to reportid
3474	3480	stack[base + 9LLU] = stack[base + 0]/fnid/;
3475	3481	// set stack-base & callee-address

		@@ -3477,22 +3483,22 @@
3477	3483	label = 18446744073709551586LLU; // reportid
3478	3484	break;
3479	3485	}
3480		- case 235LLU: // copy-back deleter (reportid to matchsym)
	3486	+ case 236LLU: // copy-back deleter (reportid to matchsym)
3481	3487	{
3482	3488	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportid to matchsym)\n");
3483	3489	// copy mutable arguments back from call to reportid
3484		- label = 219LLU; // continue to roll stack
	3490	+ label = 220LLU; // continue to roll stack
3485	3491	break;
3486	3492	}
3487		- case 236LLU: // return from reportid to matchsym
	3493	+ case 237LLU: // return from reportid to matchsym
3488	3494	{
3489	3495	// copy mutable arguments back from call to reportid
3490	3496	fprintf(stderr, "%s", ": ");
3491	3497	fprintf(stderr, "%s", "expected '");
3492	3498	// call reportbyte from matchsym
3493		- stack[base + 6LLU] = 237LLU/throw to this address/;
	3499	+ stack[base + 6LLU] = 238LLU/throw to this address/;
3494	3500	stack[base + 7LLU] = base;
3495		- stack[base + 8LLU] = 238LLU;
	3501	+ stack[base + 8LLU] = 239LLU;
3496	3502	// arguments for call to reportbyte
3497	3503	stack[base + 9LLU] = stack[base + 1]/sym/;
3498	3504	// set stack-base & callee-address

		@@ -3500,21 +3506,21 @@
3500	3506	label = 18446744073709551591LLU; // reportbyte
3501	3507	break;
3502	3508	}
3503		- case 237LLU: // copy-back deleter (reportbyte to matchsym)
	3509	+ case 238LLU: // copy-back deleter (reportbyte to matchsym)
3504	3510	{
3505	3511	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reportbyte to matchsym)\n");
3506	3512	// copy mutable arguments back from call to reportbyte
3507		- label = 219LLU; // continue to roll stack
	3513	+ label = 220LLU; // continue to roll stack
3508	3514	break;
3509	3515	}
3510		- case 238LLU: // return from reportbyte to matchsym
	3516	+ case 239LLU: // return from reportbyte to matchsym
3511	3517	{
3512	3518	// copy mutable arguments back from call to reportbyte
3513	3519	fprintf(stderr, "%s", "' but found token ");
3514	3520	// call reporttok from matchsym
3515		- stack[base + 6LLU] = 239LLU/throw to this address/;
	3521	+ stack[base + 6LLU] = 240LLU/throw to this address/;
3516	3522	stack[base + 7LLU] = base;
3517		- stack[base + 8LLU] = 240LLU;
	3523	+ stack[base + 8LLU] = 241LLU;
3518	3524	// arguments for call to reporttok
3519	3525	stack[base + 9LLU] = stack[base + 3]/variant/;
3520	3526	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3523,22 +3529,22 @@
3523	3529	label = 18446744073709551582LLU; // reporttok
3524	3530	break;
3525	3531	}
3526		- case 239LLU: // copy-back deleter (reporttok to matchsym)
	3532	+ case 240LLU: // copy-back deleter (reporttok to matchsym)
3527	3533	{
3528	3534	fprintf(stderr, "in function matchsym: unrolling stack, copy-back (reporttok to matchsym)\n");
3529	3535	// copy mutable arguments back from call to reporttok
3530		- label = 219LLU; // continue to roll stack
	3536	+ label = 220LLU; // continue to roll stack
3531	3537	break;
3532	3538	}
3533		- case 240LLU: // return from reporttok to matchsym
	3539	+ case 241LLU: // return from reporttok to matchsym
3534	3540	{
3535	3541	// copy mutable arguments back from call to reporttok
3536	3542	fprintf(stderr, "%s", "\n");
3537	3543	exit(-1);
3538		- label = 224LLU; // alternative complete
	3544	+ label = 225LLU; // alternative complete
3539	3545	break;
3540	3546	}
3541		- case 224LLU: // completed if-then-else
	3547	+ case 225LLU: // completed if-then-else
3542	3548	{
3543	3549	// return from matchsym
3544	3550	label = stack[base - 1];

		@@ -3545,7 +3551,7 @@
3545	3551	base = stack[base - 2];
3546	3552	break;
3547	3553	}
3548		- case 242LLU: // function matchid failed
	3554	+ case 243LLU: // function matchid failed
3549	3555	{
3550	3556	fprintf(stderr, "function matchid failed\n");
3551	3557	label = stack[base - 3];

		@@ -3552,53 +3558,53 @@
3552	3558	base = stack[base - 2];
3553	3559	break;
3554	3560	}
3555		- case 241LLU: // matchid
	3561	+ case 242LLU: // matchid
3556	3562	{
3557	3563	//#define arg0 0
3558	3564	//#define arg1 1
3559	3565	//#define arg2 2
3560		- label = 244LLU; // skip deleter
	3566	+ label = 245LLU; // skip deleter
3561	3567	break;
3562	3568	}
3563		- case 243LLU: // deleter
	3569	+ case 244LLU: // deleter
3564	3570	{
3565	3571	// throw from matchid
3566	3572	if(!stack[base + 3])
3567	3573	{
3568	3574	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
3570	3576	break;
3571	3577	}
3572	3578	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
3574	3580	break;
3575	3581	}
3576		- case 244LLU: // skipped deleter
	3582	+ case 245LLU: // skipped deleter
3577	3583	{
3578	3584	stack[base + 3] = 0;
3579		- label = 246LLU; // skip deleter
	3585	+ label = 247LLU; // skip deleter
3580	3586	break;
3581	3587	}
3582		- case 245LLU: // deleter
	3588	+ case 246LLU: // deleter
3583	3589	{
3584	3590	// throw from matchid
3585	3591	if(!stack[base + 4])
3586	3592	{
3587	3593	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
3589	3595	break;
3590	3596	}
3591	3597	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
3593	3599	break;
3594	3600	}
3595		- case 246LLU: // skipped deleter
	3601	+ case 247LLU: // skipped deleter
3596	3602	{
3597	3603	stack[base + 4] = 0;
3598	3604	// call ParseToken from matchid
3599		- stack[base + 5LLU] = 247LLU/throw to this address/;
	3605	+ stack[base + 5LLU] = 248LLU/throw to this address/;
3600	3606	stack[base + 6LLU] = base;
3601		- stack[base + 7LLU] = 248LLU;
	3607	+ stack[base + 7LLU] = 249LLU;
3602	3608	// arguments for call to ParseToken
3603	3609	stack[base + 10LLU] = stack[base + 2]/lookahead/;
3604	3610	// set stack-base & callee-address

		@@ -3606,15 +3612,15 @@
3606	3612	label = 3LLU; // ParseToken
3607	3613	break;
3608	3614	}
3609		- case 247LLU: // copy-back deleter (ParseToken to matchid)
	3615	+ case 248LLU: // copy-back deleter (ParseToken to matchid)
3610	3616	{
3611	3617	fprintf(stderr, "in function matchid: unrolling stack, copy-back (ParseToken to matchid)\n");
3612	3618	// copy mutable arguments back from call to ParseToken
3613	3619	stack[base + 2]/lookahead/ = stack[base + 10LLU];
3614		- label = 245LLU; // continue to roll stack
	3620	+ label = 246LLU; // continue to roll stack
3615	3621	break;
3616	3622	}
3617		- case 248LLU: // return from ParseToken to matchid
	3623	+ case 249LLU: // return from ParseToken to matchid
3618	3624	{
3619	3625	// copy mutable arguments back from call to ParseToken
3620	3626	stack[base + 2]/lookahead/ = stack[base + 10LLU];

		@@ -3621,29 +3627,29 @@
3621	3627	// copy back results provided by call to ParseToken
3622	3628	stack[base + 3] = stack[base + 8LLU];
3623	3629	stack[base + 4] = stack[base + 9LLU];
3624		- label = 250LLU; // skip deleter
	3630	+ label = 251LLU; // skip deleter
3625	3631	break;
3626	3632	}
3627		- case 249LLU: // deleter
	3633	+ case 250LLU: // deleter
3628	3634	{
3629	3635	// throw from matchid
3630	3636	if(!stack[base + 5])
3631	3637	{
3632	3638	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
3634	3640	break;
3635	3641	}
3636	3642	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
3638	3644	break;
3639	3645	}
3640		- case 250LLU: // skipped deleter
	3646	+ case 251LLU: // skipped deleter
3641	3647	{
3642	3648	stack[base + 5] = 0;
3643	3649	// call equ from matchid
3644		- stack[base + 6LLU] = 251LLU/throw to this address/;
	3650	+ stack[base + 6LLU] = 252LLU/throw to this address/;
3645	3651	stack[base + 7LLU] = base;
3646		- stack[base + 8LLU] = 252LLU;
	3652	+ stack[base + 8LLU] = 253LLU;
3647	3653	// arguments for call to equ
3648	3654	stack[base + 10LLU] = stack[base + 3]/variant/;
3649	3655	stack[base + 11LLU] = 4LLU;

		@@ -3652,14 +3658,14 @@
3652	3658	label = 18446744073709551600LLU; // equ
3653	3659	break;
3654	3660	}
3655		- case 251LLU: // copy-back deleter (equ to matchid)
	3661	+ case 252LLU: // copy-back deleter (equ to matchid)
3656	3662	{
3657	3663	fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
3658	3664	// copy mutable arguments back from call to equ
3659		- label = 249LLU; // continue to roll stack
	3665	+ label = 250LLU; // continue to roll stack
3660	3666	break;
3661	3667	}
3662		- case 252LLU: // return from equ to matchid
	3668	+ case 253LLU: // return from equ to matchid
3663	3669	{
3664	3670	// copy mutable arguments back from call to equ
3665	3671	// copy back results provided by call to equ

		@@ -3666,15 +3672,15 @@
3666	3672	stack[base + 5] = stack[base + 9LLU];
3667	3673	if(!stack[base + 5]/isqual/)
3668	3674	{
3669		- label = 253LLU; // jump to alternative
	3675	+ label = 254LLU; // jump to alternative
3670	3676	break;
3671	3677	}
3672	3678
3673	3679	// consequent
3674	3680	// call equ from matchid
3675		- stack[base + 6LLU] = 255LLU/throw to this address/;
	3681	+ stack[base + 6LLU] = 256LLU/throw to this address/;
3676	3682	stack[base + 7LLU] = base;
3677		- stack[base + 8LLU] = 256LLU;
	3683	+ stack[base + 8LLU] = 257LLU;
3678	3684	// arguments for call to equ
3679	3685	stack[base + 10LLU] = stack[base + 1]/id/;
3680	3686	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -3683,14 +3689,14 @@
3683	3689	label = 18446744073709551600LLU; // equ
3684	3690	break;
3685	3691	}
3686		- case 255LLU: // copy-back deleter (equ to matchid)
	3692	+ case 256LLU: // copy-back deleter (equ to matchid)
3687	3693	{
3688	3694	fprintf(stderr, "in function matchid: unrolling stack, copy-back (equ to matchid)\n");
3689	3695	// copy mutable arguments back from call to equ
3690		- label = 249LLU; // continue to roll stack
	3696	+ label = 250LLU; // continue to roll stack
3691	3697	break;
3692	3698	}
3693		- case 256LLU: // return from equ to matchid
	3699	+ case 257LLU: // return from equ to matchid
3694	3700	{
3695	3701	// copy mutable arguments back from call to equ
3696	3702	// copy back results provided by call to equ

		@@ -3697,21 +3703,21 @@
3697	3703	stack[base + 5] = stack[base + 9LLU];
3698	3704	if(!stack[base + 5]/isqual/)
3699	3705	{
3700		- label = 257LLU; // jump to alternative
	3706	+ label = 258LLU; // jump to alternative
3701	3707	break;
3702	3708	}
3703	3709
3704	3710	// consequent
3705		- label = 258LLU; // consequent complete
	3711	+ label = 259LLU; // consequent complete
3706	3712	break;
3707	3713	}
3708		- case 257LLU: // alternative
	3714	+ case 258LLU: // alternative
3709	3715	{
3710	3716	fprintf(stderr, "%s", "in function ");
3711	3717	// call reportid from matchid
3712		- stack[base + 6LLU] = 259LLU/throw to this address/;
	3718	+ stack[base + 6LLU] = 260LLU/throw to this address/;
3713	3719	stack[base + 7LLU] = base;
3714		- stack[base + 8LLU] = 260LLU;
	3720	+ stack[base + 8LLU] = 261LLU;
3715	3721	// arguments for call to reportid
3716	3722	stack[base + 9LLU] = stack[base + 0]/fnid/;
3717	3723	// set stack-base & callee-address

		@@ -3719,22 +3725,22 @@
3719	3725	label = 18446744073709551586LLU; // reportid
3720	3726	break;
3721	3727	}
3722		- case 259LLU: // copy-back deleter (reportid to matchid)
	3728	+ case 260LLU: // copy-back deleter (reportid to matchid)
3723	3729	{
3724	3730	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3725	3731	// copy mutable arguments back from call to reportid
3726		- label = 249LLU; // continue to roll stack
	3732	+ label = 250LLU; // continue to roll stack
3727	3733	break;
3728	3734	}
3729		- case 260LLU: // return from reportid to matchid
	3735	+ case 261LLU: // return from reportid to matchid
3730	3736	{
3731	3737	// copy mutable arguments back from call to reportid
3732	3738	fprintf(stderr, "%s", ": ");
3733	3739	fprintf(stderr, "%s", "expected ");
3734	3740	// call reportid from matchid
3735		- stack[base + 6LLU] = 261LLU/throw to this address/;
	3741	+ stack[base + 6LLU] = 262LLU/throw to this address/;
3736	3742	stack[base + 7LLU] = base;
3737		- stack[base + 8LLU] = 262LLU;
	3743	+ stack[base + 8LLU] = 263LLU;
3738	3744	// arguments for call to reportid
3739	3745	stack[base + 9LLU] = stack[base + 1]/id/;
3740	3746	// set stack-base & callee-address

		@@ -3742,21 +3748,21 @@
3742	3748	label = 18446744073709551586LLU; // reportid
3743	3749	break;
3744	3750	}
3745		- case 261LLU: // copy-back deleter (reportid to matchid)
	3751	+ case 262LLU: // copy-back deleter (reportid to matchid)
3746	3752	{
3747	3753	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3748	3754	// copy mutable arguments back from call to reportid
3749		- label = 249LLU; // continue to roll stack
	3755	+ label = 250LLU; // continue to roll stack
3750	3756	break;
3751	3757	}
3752		- case 262LLU: // return from reportid to matchid
	3758	+ case 263LLU: // return from reportid to matchid
3753	3759	{
3754	3760	// copy mutable arguments back from call to reportid
3755	3761	fprintf(stderr, "%s", " but found token ");
3756	3762	// call reporttok from matchid
3757		- stack[base + 6LLU] = 263LLU/throw to this address/;
	3763	+ stack[base + 6LLU] = 264LLU/throw to this address/;
3758	3764	stack[base + 7LLU] = base;
3759		- stack[base + 8LLU] = 264LLU;
	3765	+ stack[base + 8LLU] = 265LLU;
3760	3766	// arguments for call to reporttok
3761	3767	stack[base + 9LLU] = stack[base + 3]/variant/;
3762	3768	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3765,33 +3771,33 @@
3765	3771	label = 18446744073709551582LLU; // reporttok
3766	3772	break;
3767	3773	}
3768		- case 263LLU: // copy-back deleter (reporttok to matchid)
	3774	+ case 264LLU: // copy-back deleter (reporttok to matchid)
3769	3775	{
3770	3776	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
3771	3777	// copy mutable arguments back from call to reporttok
3772		- label = 249LLU; // continue to roll stack
	3778	+ label = 250LLU; // continue to roll stack
3773	3779	break;
3774	3780	}
3775		- case 264LLU: // return from reporttok to matchid
	3781	+ case 265LLU: // return from reporttok to matchid
3776	3782	{
3777	3783	// copy mutable arguments back from call to reporttok
3778	3784	fprintf(stderr, "%s", "\n");
3779	3785	exit(-1);
3780		- label = 258LLU; // alternative complete
	3786	+ label = 259LLU; // alternative complete
3781	3787	break;
3782	3788	}
3783		- case 258LLU: // completed if-then-else
	3789	+ case 259LLU: // completed if-then-else
3784	3790	{
3785		- label = 254LLU; // consequent complete
	3791	+ label = 255LLU; // consequent complete
3786	3792	break;
3787	3793	}
3788		- case 253LLU: // alternative
	3794	+ case 254LLU: // alternative
3789	3795	{
3790	3796	fprintf(stderr, "%s", "in function ");
3791	3797	// call reportid from matchid
3792		- stack[base + 6LLU] = 265LLU/throw to this address/;
	3798	+ stack[base + 6LLU] = 266LLU/throw to this address/;
3793	3799	stack[base + 7LLU] = base;
3794		- stack[base + 8LLU] = 266LLU;
	3800	+ stack[base + 8LLU] = 267LLU;
3795	3801	// arguments for call to reportid
3796	3802	stack[base + 9LLU] = stack[base + 0]/fnid/;
3797	3803	// set stack-base & callee-address

		@@ -3799,22 +3805,22 @@
3799	3805	label = 18446744073709551586LLU; // reportid
3800	3806	break;
3801	3807	}
3802		- case 265LLU: // copy-back deleter (reportid to matchid)
	3808	+ case 266LLU: // copy-back deleter (reportid to matchid)
3803	3809	{
3804	3810	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3805	3811	// copy mutable arguments back from call to reportid
3806		- label = 249LLU; // continue to roll stack
	3812	+ label = 250LLU; // continue to roll stack
3807	3813	break;
3808	3814	}
3809		- case 266LLU: // return from reportid to matchid
	3815	+ case 267LLU: // return from reportid to matchid
3810	3816	{
3811	3817	// copy mutable arguments back from call to reportid
3812	3818	fprintf(stderr, "%s", ": ");
3813	3819	fprintf(stderr, "%s", "expected ");
3814	3820	// call reportid from matchid
3815		- stack[base + 6LLU] = 267LLU/throw to this address/;
	3821	+ stack[base + 6LLU] = 268LLU/throw to this address/;
3816	3822	stack[base + 7LLU] = base;
3817		- stack[base + 8LLU] = 268LLU;
	3823	+ stack[base + 8LLU] = 269LLU;
3818	3824	// arguments for call to reportid
3819	3825	stack[base + 9LLU] = stack[base + 1]/id/;
3820	3826	// set stack-base & callee-address

		@@ -3822,21 +3828,21 @@
3822	3828	label = 18446744073709551586LLU; // reportid
3823	3829	break;
3824	3830	}
3825		- case 267LLU: // copy-back deleter (reportid to matchid)
	3831	+ case 268LLU: // copy-back deleter (reportid to matchid)
3826	3832	{
3827	3833	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reportid to matchid)\n");
3828	3834	// copy mutable arguments back from call to reportid
3829		- label = 249LLU; // continue to roll stack
	3835	+ label = 250LLU; // continue to roll stack
3830	3836	break;
3831	3837	}
3832		- case 268LLU: // return from reportid to matchid
	3838	+ case 269LLU: // return from reportid to matchid
3833	3839	{
3834	3840	// copy mutable arguments back from call to reportid
3835	3841	fprintf(stderr, "%s", " but found token ");
3836	3842	// call reporttok from matchid
3837		- stack[base + 6LLU] = 269LLU/throw to this address/;
	3843	+ stack[base + 6LLU] = 270LLU/throw to this address/;
3838	3844	stack[base + 7LLU] = base;
3839		- stack[base + 8LLU] = 270LLU;
	3845	+ stack[base + 8LLU] = 271LLU;
3840	3846	// arguments for call to reporttok
3841	3847	stack[base + 9LLU] = stack[base + 3]/variant/;
3842	3848	stack[base + 10LLU] = stack[base + 4]/content/;

		@@ -3845,22 +3851,22 @@
3845	3851	label = 18446744073709551582LLU; // reporttok
3846	3852	break;
3847	3853	}
3848		- case 269LLU: // copy-back deleter (reporttok to matchid)
	3854	+ case 270LLU: // copy-back deleter (reporttok to matchid)
3849	3855	{
3850	3856	fprintf(stderr, "in function matchid: unrolling stack, copy-back (reporttok to matchid)\n");
3851	3857	// copy mutable arguments back from call to reporttok
3852		- label = 249LLU; // continue to roll stack
	3858	+ label = 250LLU; // continue to roll stack
3853	3859	break;
3854	3860	}
3855		- case 270LLU: // return from reporttok to matchid
	3861	+ case 271LLU: // return from reporttok to matchid
3856	3862	{
3857	3863	// copy mutable arguments back from call to reporttok
3858	3864	fprintf(stderr, "%s", "\n");
3859	3865	exit(-1);
3860		- label = 254LLU; // alternative complete
	3866	+ label = 255LLU; // alternative complete
3861	3867	break;
3862	3868	}
3863		- case 254LLU: // completed if-then-else
	3869	+ case 255LLU: // completed if-then-else
3864	3870	{
3865	3871	// return from matchid
3866	3872	label = stack[base - 1];

		@@ -3867,7 +3873,7 @@
3867	3873	base = stack[base - 2];
3868	3874	break;
3869	3875	}
3870		- case 272LLU: // function isncs failed
	3876	+ case 273LLU: // function isncs failed
3871	3877	{
3872	3878	fprintf(stderr, "function isncs failed\n");
3873	3879	label = stack[base - 3];

		@@ -3874,33 +3880,33 @@
3874	3880	base = stack[base - 2];
3875	3881	break;
3876	3882	}
3877		- case 271LLU: // isncs
	3883	+ case 272LLU: // isncs
3878	3884	{
3879	3885	//#define res0 0
3880	3886	//#define arg0 1
3881		- label = 274LLU; // skip deleter
	3887	+ label = 275LLU; // skip deleter
3882	3888	break;
3883	3889	}
3884		- case 273LLU: // deleter
	3890	+ case 274LLU: // deleter
3885	3891	{
3886	3892	// throw from isncs
3887	3893	if(!stack[base + 2])
3888	3894	{
3889	3895	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
3891	3897	break;
3892	3898	}
3893	3899	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
3895	3901	break;
3896	3902	}
3897		- case 274LLU: // skipped deleter
	3903	+ case 275LLU: // skipped deleter
3898	3904	{
3899	3905	stack[base + 2] = 0;
3900	3906	// call equ from isncs
3901		- stack[base + 3LLU] = 275LLU/throw to this address/;
	3907	+ stack[base + 3LLU] = 276LLU/throw to this address/;
3902	3908	stack[base + 4LLU] = base;
3903		- stack[base + 5LLU] = 276LLU;
	3909	+ stack[base + 5LLU] = 277LLU;
3904	3910	// arguments for call to equ
3905	3911	stack[base + 7LLU] = stack[base + 1]/tokvar/;
3906	3912	stack[base + 8LLU] = 1LLU;

		@@ -3909,14 +3915,14 @@
3909	3915	label = 18446744073709551600LLU; // equ
3910	3916	break;
3911	3917	}
3912		- case 275LLU: // copy-back deleter (equ to isncs)
	3918	+ case 276LLU: // copy-back deleter (equ to isncs)
3913	3919	{
3914	3920	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
3915	3921	// copy mutable arguments back from call to equ
3916		- label = 273LLU; // continue to roll stack
	3922	+ label = 274LLU; // continue to roll stack
3917	3923	break;
3918	3924	}
3919		- case 276LLU: // return from equ to isncs
	3925	+ case 277LLU: // return from equ to isncs
3920	3926	{
3921	3927	// copy mutable arguments back from call to equ
3922	3928	// copy back results provided by call to equ

		@@ -3923,39 +3929,39 @@
3923	3929	stack[base + 2] = stack[base + 6LLU];
3924	3930	if(!stack[base + 2]/isequal/)
3925	3931	{
3926		- label = 277LLU; // jump to alternative
	3932	+ label = 278LLU; // jump to alternative
3927	3933	break;
3928	3934	}
3929	3935
3930	3936	// consequent
3931		- label = 280LLU; // skip deleter
	3937	+ label = 281LLU; // skip deleter
3932	3938	break;
3933	3939	}
3934		- case 279LLU: // deleter
	3940	+ case 280LLU: // deleter
3935	3941	{
3936	3942	// throw from isncs
3937	3943	if(!stack[base + 0])
3938	3944	{
3939	3945	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
3941	3947	break;
3942	3948	}
3943	3949	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
3945	3951	break;
3946	3952	}
3947		- case 280LLU: // skipped deleter
	3953	+ case 281LLU: // skipped deleter
3948	3954	{
3949	3955	stack[base + 0] = 1;
3950		- label = 278LLU; // consequent complete
	3956	+ label = 279LLU; // consequent complete
3951	3957	break;
3952	3958	}
3953		- case 277LLU: // alternative
	3959	+ case 278LLU: // alternative
3954	3960	{
3955	3961	// call equ from isncs
3956		- stack[base + 3LLU] = 281LLU/throw to this address/;
	3962	+ stack[base + 3LLU] = 282LLU/throw to this address/;
3957	3963	stack[base + 4LLU] = base;
3958		- stack[base + 5LLU] = 282LLU;
	3964	+ stack[base + 5LLU] = 283LLU;
3959	3965	// arguments for call to equ
3960	3966	stack[base + 7LLU] = stack[base + 1]/tokvar/;
3961	3967	stack[base + 8LLU] = 2LLU;

		@@ -3964,14 +3970,14 @@
3964	3970	label = 18446744073709551600LLU; // equ
3965	3971	break;
3966	3972	}
3967		- case 281LLU: // copy-back deleter (equ to isncs)
	3973	+ case 282LLU: // copy-back deleter (equ to isncs)
3968	3974	{
3969	3975	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
3970	3976	// copy mutable arguments back from call to equ
3971		- label = 273LLU; // continue to roll stack
	3977	+ label = 274LLU; // continue to roll stack
3972	3978	break;
3973	3979	}
3974		- case 282LLU: // return from equ to isncs
	3980	+ case 283LLU: // return from equ to isncs
3975	3981	{
3976	3982	// copy mutable arguments back from call to equ
3977	3983	// copy back results provided by call to equ

		@@ -3978,39 +3984,39 @@
3978	3984	stack[base + 2] = stack[base + 6LLU];
3979	3985	if(!stack[base + 2]/isequal/)
3980	3986	{
3981		- label = 283LLU; // jump to alternative
	3987	+ label = 284LLU; // jump to alternative
3982	3988	break;
3983	3989	}
3984	3990
3985	3991	// consequent
3986		- label = 286LLU; // skip deleter
	3992	+ label = 287LLU; // skip deleter
3987	3993	break;
3988	3994	}
3989		- case 285LLU: // deleter
	3995	+ case 286LLU: // deleter
3990	3996	{
3991	3997	// throw from isncs
3992	3998	if(!stack[base + 0])
3993	3999	{
3994	4000	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
3996	4002	break;
3997	4003	}
3998	4004	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
4000	4006	break;
4001	4007	}
4002		- case 286LLU: // skipped deleter
	4008	+ case 287LLU: // skipped deleter
4003	4009	{
4004	4010	stack[base + 0] = 1;
4005		- label = 284LLU; // consequent complete
	4011	+ label = 285LLU; // consequent complete
4006	4012	break;
4007	4013	}
4008		- case 283LLU: // alternative
	4014	+ case 284LLU: // alternative
4009	4015	{
4010	4016	// call equ from isncs
4011		- stack[base + 3LLU] = 287LLU/throw to this address/;
	4017	+ stack[base + 3LLU] = 288LLU/throw to this address/;
4012	4018	stack[base + 4LLU] = base;
4013		- stack[base + 5LLU] = 288LLU;
	4019	+ stack[base + 5LLU] = 289LLU;
4014	4020	// arguments for call to equ
4015	4021	stack[base + 7LLU] = stack[base + 1]/tokvar/;
4016	4022	stack[base + 8LLU] = 3LLU;

		@@ -4019,14 +4025,14 @@
4019	4025	label = 18446744073709551600LLU; // equ
4020	4026	break;
4021	4027	}
4022		- case 287LLU: // copy-back deleter (equ to isncs)
	4028	+ case 288LLU: // copy-back deleter (equ to isncs)
4023	4029	{
4024	4030	fprintf(stderr, "in function isncs: unrolling stack, copy-back (equ to isncs)\n");
4025	4031	// copy mutable arguments back from call to equ
4026		- label = 273LLU; // continue to roll stack
	4032	+ label = 274LLU; // continue to roll stack
4027	4033	break;
4028	4034	}
4029		- case 288LLU: // return from equ to isncs
	4035	+ case 289LLU: // return from equ to isncs
4030	4036	{
4031	4037	// copy mutable arguments back from call to equ
4032	4038	// copy back results provided by call to equ

		@@ -4033,68 +4039,68 @@
4033	4039	stack[base + 2] = stack[base + 6LLU];
4034	4040	if(!stack[base + 2]/isequal/)
4035	4041	{
4036		- label = 289LLU; // jump to alternative
	4042	+ label = 290LLU; // jump to alternative
4037	4043	break;
4038	4044	}
4039	4045
4040	4046	// consequent
4041		- label = 292LLU; // skip deleter
	4047	+ label = 293LLU; // skip deleter
4042	4048	break;
4043	4049	}
4044		- case 291LLU: // deleter
	4050	+ case 292LLU: // deleter
4045	4051	{
4046	4052	// throw from isncs
4047	4053	if(!stack[base + 0])
4048	4054	{
4049	4055	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
4051	4057	break;
4052	4058	}
4053	4059	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
4055	4061	break;
4056	4062	}
4057		- case 292LLU: // skipped deleter
	4063	+ case 293LLU: // skipped deleter
4058	4064	{
4059	4065	stack[base + 0] = 1;
4060		- label = 290LLU; // consequent complete
	4066	+ label = 291LLU; // consequent complete
4061	4067	break;
4062	4068	}
4063		- case 289LLU: // alternative
	4069	+ case 290LLU: // alternative
4064	4070	{
4065		- label = 294LLU; // skip deleter
	4071	+ label = 295LLU; // skip deleter
4066	4072	break;
4067	4073	}
4068		- case 293LLU: // deleter
	4074	+ case 294LLU: // deleter
4069	4075	{
4070	4076	// throw from isncs
4071	4077	if(!stack[base + 0])
4072	4078	{
4073	4079	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
4075	4081	break;
4076	4082	}
4077	4083	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
4079	4085	break;
4080	4086	}
4081		- case 294LLU: // skipped deleter
	4087	+ case 295LLU: // skipped deleter
4082	4088	{
4083	4089	stack[base + 0] = 0;
4084		- label = 290LLU; // alternative complete
	4090	+ label = 291LLU; // alternative complete
4085	4091	break;
4086	4092	}
4087		- case 290LLU: // completed if-then-else
	4093	+ case 291LLU: // completed if-then-else
4088	4094	{
4089		- label = 284LLU; // alternative complete
	4095	+ label = 285LLU; // alternative complete
4090	4096	break;
4091	4097	}
4092		- case 284LLU: // completed if-then-else
	4098	+ case 285LLU: // completed if-then-else
4093	4099	{
4094		- label = 278LLU; // alternative complete
	4100	+ label = 279LLU; // alternative complete
4095	4101	break;
4096	4102	}
4097		- case 278LLU: // completed if-then-else
	4103	+ case 279LLU: // completed if-then-else
4098	4104	{
4099	4105	// return from isncs
4100	4106	label = stack[base - 1];

		@@ -4101,7 +4107,7 @@
4101	4107	base = stack[base - 2];
4102	4108	break;
4103	4109	}
4104		- case 295LLU: // ~type
	4110	+ case 296LLU: // ~type
4105	4111	{
4106	4112	if(stack[base + 0]/variant-nr/ >= 2)
4107	4113	{

		@@ -4108,10 +4114,10 @@
4108	4114	fprintf(stderr, "in ~type: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
4109	4115	exit(-1);
4110	4116	}
4111		- label = 295LLU + 1LLU + stack[base + 0]/variant-nr/;
	4117	+ label = 296LLU + 1LLU + stack[base + 0]/variant-nr/;
4112	4118	break;
4113	4119	}
4114		- case 295LLU + 1LLU + 0LLU: // ~type.typename
	4120	+ case 296LLU + 1LLU + 0LLU: // ~type.typename
4115	4121	{
4116	4122	// release element name
4117	4123	// release variant container

		@@ -4120,7 +4126,7 @@
4120	4126	base = stack[base - 2];
4121	4127	break;
4122	4128	}
4123		- case 295LLU + 1LLU + 1LLU: // ~type.typelist
	4129	+ case 296LLU + 1LLU + 1LLU: // ~type.typelist
4124	4130	{
4125	4131	// release element subtype
4126	4132	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -4130,14 +4136,14 @@
4130	4136	newstack[0] = (uint64_t)stack; // backup stack location
4131	4137	newstack[1] = 1234567890;
4132	4138	newstack[2] = base;
4133		- newstack[3] = 298LLU;
	4139	+ newstack[3] = 299LLU;
4134	4140	stack = newstack;
4135	4141	// set stack-base & callee-address
4136	4142	base = 4/deloffset/;
4137		- label = 295LLU; // ~type
	4143	+ label = 296LLU; // ~type
4138	4144	break;
4139	4145	}
4140		- case 298LLU: // return from ~type to type
	4146	+ case 299LLU: // return from ~type to type
4141	4147	{
4142	4148	stack = (uint64_t *)stack[0];
4143	4149	// releasing toplevel container

		@@ -4149,7 +4155,7 @@
4149	4155	base = stack[base - 2];
4150	4156	break;
4151	4157	}
4152		- case 300LLU: // function mktypename failed
	4158	+ case 301LLU: // function mktypename failed
4153	4159	{
4154	4160	fprintf(stderr, "function mktypename failed\n");
4155	4161	label = stack[base - 3];

		@@ -4156,20 +4162,20 @@
4156	4162	base = stack[base - 2];
4157	4163	break;
4158	4164	}
4159		- case 299LLU: // mktypename
	4165	+ case 300LLU: // mktypename
4160	4166	{
4161	4167	//#define res0 0
4162	4168	//#define arg0 1
4163		- label = 302LLU; // skip deleter
	4169	+ label = 303LLU; // skip deleter
4164	4170	break;
4165	4171	}
4166		- case 301LLU: // deleter
	4172	+ case 302LLU: // deleter
4167	4173	{
4168	4174	// throw from mktypename
4169	4175	if(!stack[base + 0])
4170	4176	{
4171	4177	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
4173	4179	break;
4174	4180	}
4175	4181	fprintf(stderr, "in function mktypename: unrolling stack, variable type \n");

		@@ -4179,28 +4185,28 @@
4179	4185	newstack[0] = (uint64_t)stack; // backup stack location
4180	4186	newstack[1] = 1234567890;
4181	4187	newstack[2] = base;
4182		- newstack[3] = 303LLU;
	4188	+ newstack[3] = 304LLU;
4183	4189	stack = newstack;
4184	4190	// set stack-base & callee-address
4185	4191	base = 4/deloffset/;
4186		- label = 295LLU; // ~type
	4192	+ label = 296LLU; // ~type
4187	4193	break;
4188	4194	}
4189		- case 303LLU: // return from ~type to mktypename
	4195	+ case 304LLU: // return from ~type to mktypename
4190	4196	{
4191	4197	stack = (uint64_t *)stack[0];
4192	4198	// releasing toplevel container
4193	4199	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4194	4200
4195		- label = 300LLU; // continue unrolling stack, delete next variable
	4201	+ label = 301LLU; // continue unrolling stack, delete next variable
4196	4202	break;
4197	4203	}
4198		- case 302LLU: // skipped deleter
	4204	+ case 303LLU: // skipped deleter
4199	4205	{
4200	4206	// construct type.typename
4201	4207	if(!(stack[base + 0] = construct(1)))
4202	4208	{
4203		- label = 300LLU; // throw: begin to unroll stack
	4209	+ label = 301LLU; // throw: begin to unroll stack
4204	4210	break;
4205	4211	}
4206	4212

		@@ -4212,7 +4218,7 @@
4212	4218	base = stack[base - 2];
4213	4219	break;
4214	4220	}
4215		- case 305LLU: // function printtype failed
	4221	+ case 306LLU: // function printtype failed
4216	4222	{
4217	4223	fprintf(stderr, "function printtype failed\n");
4218	4224	label = stack[base - 3];

		@@ -4219,12 +4225,12 @@
4219	4225	base = stack[base - 2];
4220	4226	break;
4221	4227	}
4222		- case 304LLU: // printtype
	4228	+ case 305LLU: // printtype
4223	4229	{
4224	4230	//#define arg0 0
4225	4231	if(/typename/0 != ((uint64_t )(stack[base + 0]/type*/))[0])
4226	4232	{
4227		- label = 307LLU; // jump to alternative
	4233	+ label = 308LLU; // jump to alternative
4228	4234	break;
4229	4235	}
4230	4236

		@@ -4232,9 +4238,9 @@
4232	4238
4233	4239	// case
4234	4240	// call printid from printtype
4235		- stack[base + 2LLU] = 309LLU/throw to this address/;
	4241	+ stack[base + 2LLU] = 310LLU/throw to this address/;
4236	4242	stack[base + 3LLU] = base;
4237		- stack[base + 4LLU] = 310LLU;
	4243	+ stack[base + 4LLU] = 311LLU;
4238	4244	// arguments for call to printid
4239	4245	stack[base + 5LLU] = stack[base + 1]/name/;
4240	4246	// set stack-base & callee-address

		@@ -4242,31 +4248,31 @@
4242	4248	label = 18446744073709551587LLU; // printid
4243	4249	break;
4244	4250	}
4245		- case 309LLU: // copy-back deleter (printid to printtype)
	4251	+ case 310LLU: // copy-back deleter (printid to printtype)
4246	4252	{
4247	4253	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
4248	4254	// copy mutable arguments back from call to printid
4249		- label = 308LLU; // continue to roll stack
	4255	+ label = 309LLU; // continue to roll stack
4250	4256	break;
4251	4257	}
4252		- case 310LLU: // return from printid to printtype
	4258	+ case 311LLU: // return from printid to printtype
4253	4259	{
4254	4260	// copy mutable arguments back from call to printid
4255	4261	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4256		- label = 306LLU; // case complete
	4262	+ label = 307LLU; // case complete
4257	4263	break;
4258	4264	}
4259		- case 308LLU: // copy-back deleter (switch)
	4265	+ case 309LLU: // copy-back deleter (switch)
4260	4266	{
4261	4267	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4262		- label = 305LLU; // continue to unroll stack
	4268	+ label = 306LLU; // continue to unroll stack
4263	4269	break;
4264	4270	}
4265		- case 307LLU: // try next case
	4271	+ case 308LLU: // try next case
4266	4272	{
4267	4273	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4268	4274	{
4269		- label = 311LLU; // jump to alternative
	4275	+ label = 312LLU; // jump to alternative
4270	4276	break;
4271	4277	}
4272	4278

		@@ -4277,7 +4283,7 @@
4277	4283	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4278	4284	if(!newstack)
4279	4285	{
4280		- label = 312LLU; // throw: begin to unroll stack
	4286	+ label = 313LLU; // throw: begin to unroll stack
4281	4287	break;
4282	4288	}
4283	4289

		@@ -4284,18 +4290,18 @@
4284	4290	newstack[10LLU] = 9876543210LLU; // overflow-marker
4285	4291	// call printtype from printtype
4286	4292	newstack[0] = (uint64_t)stack; // backup stack location
4287		- newstack[1] = 313LLU;
	4293	+ newstack[1] = 314LLU;
4288	4294	newstack[2] = base;
4289		- newstack[3] = 314LLU;
	4295	+ newstack[3] = 315LLU;
4290	4296	// arguments for call to printtype
4291	4297	newstack[4LLU] = stack[base + 1]/subtype/;
4292	4298	stack = newstack;
4293	4299	// set stack-base & callee-address
4294	4300	base = 4/deloffset/;
4295		- label = 304LLU; // printtype
	4301	+ label = 305LLU; // printtype
4296	4302	break;
4297	4303	}
4298		- case 313LLU: // copy-back deleter (printtype to printtype)
	4304	+ case 314LLU: // copy-back deleter (printtype to printtype)
4299	4305	{
4300	4306	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
4301	4307	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4307,10 +4313,10 @@
4307	4313	}
4308	4314	Free(10LLU + 1, sizeof(uint64_t), stack);
4309	4315	stack = oldstack;
4310		- label = 312LLU; // continue to unroll stack
	4316	+ label = 313LLU; // continue to unroll stack
4311	4317	break;
4312	4318	}
4313		- case 314LLU: // return from printtype to printtype
	4319	+ case 315LLU: // return from printtype to printtype
4314	4320	{
4315	4321	uint64_t oldstack = (uint64_t )stack[0];
4316	4322	// copy mutable arguments back from call to printtype

		@@ -4323,21 +4329,21 @@
4323	4329	stack = oldstack;
4324	4330	printf("%s", "]");
4325	4331	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4326		- label = 306LLU; // case complete
	4332	+ label = 307LLU; // case complete
4327	4333	break;
4328	4334	}
4329		- case 312LLU: // copy-back deleter (switch)
	4335	+ case 313LLU: // copy-back deleter (switch)
4330	4336	{
4331	4337	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4332		- label = 305LLU; // continue to unroll stack
	4338	+ label = 306LLU; // continue to unroll stack
4333	4339	break;
4334	4340	}
4335		- case 311LLU: // try next case
	4341	+ case 312LLU: // try next case
4336	4342	{
4337	4343	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4338	4344	exit(-1);
4339	4345	}
4340		- case 306LLU: // completed switch
	4346	+ case 307LLU: // completed switch
4341	4347	{
4342	4348	// return from printtype
4343	4349	label = stack[base - 1];

		@@ -4344,7 +4350,7 @@
4344	4350	base = stack[base - 2];
4345	4351	break;
4346	4352	}
4347		- case 316LLU: // function reporttype failed
	4353	+ case 317LLU: // function reporttype failed
4348	4354	{
4349	4355	fprintf(stderr, "function reporttype failed\n");
4350	4356	label = stack[base - 3];

		@@ -4351,12 +4357,12 @@
4351	4357	base = stack[base - 2];
4352	4358	break;
4353	4359	}
4354		- case 315LLU: // reporttype
	4360	+ case 316LLU: // reporttype
4355	4361	{
4356	4362	//#define arg0 0
4357	4363	if(/typename/0 != ((uint64_t )(stack[base + 0]/type*/))[0])
4358	4364	{
4359		- label = 318LLU; // jump to alternative
	4365	+ label = 319LLU; // jump to alternative
4360	4366	break;
4361	4367	}
4362	4368

		@@ -4364,9 +4370,9 @@
4364	4370
4365	4371	// case
4366	4372	// call reportid from reporttype
4367		- stack[base + 2LLU] = 320LLU/throw to this address/;
	4373	+ stack[base + 2LLU] = 321LLU/throw to this address/;
4368	4374	stack[base + 3LLU] = base;
4369		- stack[base + 4LLU] = 321LLU;
	4375	+ stack[base + 4LLU] = 322LLU;
4370	4376	// arguments for call to reportid
4371	4377	stack[base + 5LLU] = stack[base + 1]/name/;
4372	4378	// set stack-base & callee-address

		@@ -4374,31 +4380,31 @@
4374	4380	label = 18446744073709551586LLU; // reportid
4375	4381	break;
4376	4382	}
4377		- case 320LLU: // copy-back deleter (reportid to reporttype)
	4383	+ case 321LLU: // copy-back deleter (reportid to reporttype)
4378	4384	{
4379	4385	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
4380	4386	// copy mutable arguments back from call to reportid
4381		- label = 319LLU; // continue to roll stack
	4387	+ label = 320LLU; // continue to roll stack
4382	4388	break;
4383	4389	}
4384		- case 321LLU: // return from reportid to reporttype
	4390	+ case 322LLU: // return from reportid to reporttype
4385	4391	{
4386	4392	// copy mutable arguments back from call to reportid
4387	4393	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4388		- label = 317LLU; // case complete
	4394	+ label = 318LLU; // case complete
4389	4395	break;
4390	4396	}
4391		- case 319LLU: // copy-back deleter (switch)
	4397	+ case 320LLU: // copy-back deleter (switch)
4392	4398	{
4393	4399	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4394		- label = 316LLU; // continue to unroll stack
	4400	+ label = 317LLU; // continue to unroll stack
4395	4401	break;
4396	4402	}
4397		- case 318LLU: // try next case
	4403	+ case 319LLU: // try next case
4398	4404	{
4399	4405	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4400	4406	{
4401		- label = 322LLU; // jump to alternative
	4407	+ label = 323LLU; // jump to alternative
4402	4408	break;
4403	4409	}
4404	4410

		@@ -4409,7 +4415,7 @@
4409	4415	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4410	4416	if(!newstack)
4411	4417	{
4412		- label = 323LLU; // throw: begin to unroll stack
	4418	+ label = 324LLU; // throw: begin to unroll stack
4413	4419	break;
4414	4420	}
4415	4421

		@@ -4416,18 +4422,18 @@
4416	4422	newstack[10LLU] = 9876543210LLU; // overflow-marker
4417	4423	// call reporttype from reporttype
4418	4424	newstack[0] = (uint64_t)stack; // backup stack location
4419		- newstack[1] = 324LLU;
	4425	+ newstack[1] = 325LLU;
4420	4426	newstack[2] = base;
4421		- newstack[3] = 325LLU;
	4427	+ newstack[3] = 326LLU;
4422	4428	// arguments for call to reporttype
4423	4429	newstack[4LLU] = stack[base + 1]/subtype/;
4424	4430	stack = newstack;
4425	4431	// set stack-base & callee-address
4426	4432	base = 4/deloffset/;
4427		- label = 315LLU; // reporttype
	4433	+ label = 316LLU; // reporttype
4428	4434	break;
4429	4435	}
4430		- case 324LLU: // copy-back deleter (reporttype to reporttype)
	4436	+ case 325LLU: // copy-back deleter (reporttype to reporttype)
4431	4437	{
4432	4438	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
4433	4439	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4439,10 +4445,10 @@
4439	4445	}
4440	4446	Free(10LLU + 1, sizeof(uint64_t), stack);
4441	4447	stack = oldstack;
4442		- label = 323LLU; // continue to unroll stack
	4448	+ label = 324LLU; // continue to unroll stack
4443	4449	break;
4444	4450	}
4445		- case 325LLU: // return from reporttype to reporttype
	4451	+ case 326LLU: // return from reporttype to reporttype
4446	4452	{
4447	4453	uint64_t oldstack = (uint64_t )stack[0];
4448	4454	// copy mutable arguments back from call to reporttype

		@@ -4455,21 +4461,21 @@
4455	4461	stack = oldstack;
4456	4462	fprintf(stderr, "%s", "]");
4457	4463	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4458		- label = 317LLU; // case complete
	4464	+ label = 318LLU; // case complete
4459	4465	break;
4460	4466	}
4461		- case 323LLU: // copy-back deleter (switch)
	4467	+ case 324LLU: // copy-back deleter (switch)
4462	4468	{
4463	4469	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4464		- label = 316LLU; // continue to unroll stack
	4470	+ label = 317LLU; // continue to unroll stack
4465	4471	break;
4466	4472	}
4467		- case 322LLU: // try next case
	4473	+ case 323LLU: // try next case
4468	4474	{
4469	4475	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4470	4476	exit(-1);
4471	4477	}
4472		- case 317LLU: // completed switch
	4478	+ case 318LLU: // completed switch
4473	4479	{
4474	4480	// return from reporttype
4475	4481	label = stack[base - 1];

		@@ -4476,7 +4482,7 @@
4476	4482	base = stack[base - 2];
4477	4483	break;
4478	4484	}
4479		- case 327LLU: // function copytype failed
	4485	+ case 328LLU: // function copytype failed
4480	4486	{
4481	4487	fprintf(stderr, "function copytype failed\n");
4482	4488	label = stack[base - 3];

		@@ -4483,13 +4489,13 @@
4483	4489	base = stack[base - 2];
4484	4490	break;
4485	4491	}
4486		- case 326LLU: // copytype
	4492	+ case 327LLU: // copytype
4487	4493	{
4488	4494	//#define res0 0
4489	4495	//#define arg0 1
4490	4496	if(/typename/0 != ((uint64_t )(stack[base + 1]/type*/))[0])
4491	4497	{
4492		- label = 329LLU; // jump to alternative
	4498	+ label = 330LLU; // jump to alternative
4493	4499	break;
4494	4500	}
4495	4501

		@@ -4496,16 +4502,16 @@
4496	4502	/name/stack[base + 2] = ((uint64_t *)(stack[base + 1]/type/))[1][0]/name*/;
4497	4503
4498	4504	// case
4499		- label = 332LLU; // skip deleter
	4505	+ label = 333LLU; // skip deleter
4500	4506	break;
4501	4507	}
4502		- case 331LLU: // deleter
	4508	+ case 332LLU: // deleter
4503	4509	{
4504	4510	// throw from copytype
4505	4511	if(!stack[base + 0])
4506	4512	{
4507	4513	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
4509	4515	break;
4510	4516	}
4511	4517	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4515,28 +4521,28 @@
4515	4521	newstack[0] = (uint64_t)stack; // backup stack location
4516	4522	newstack[1] = 1234567890;
4517	4523	newstack[2] = base;
4518		- newstack[3] = 333LLU;
	4524	+ newstack[3] = 334LLU;
4519	4525	stack = newstack;
4520	4526	// set stack-base & callee-address
4521	4527	base = 4/deloffset/;
4522		- label = 295LLU; // ~type
	4528	+ label = 296LLU; // ~type
4523	4529	break;
4524	4530	}
4525		- case 333LLU: // return from ~type to copytype
	4531	+ case 334LLU: // return from ~type to copytype
4526	4532	{
4527	4533	stack = (uint64_t *)stack[0];
4528	4534	// releasing toplevel container
4529	4535	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4530	4536
4531		- label = 330LLU; // continue unrolling stack, delete next variable
	4537	+ label = 331LLU; // continue unrolling stack, delete next variable
4532	4538	break;
4533	4539	}
4534		- case 332LLU: // skipped deleter
	4540	+ case 333LLU: // skipped deleter
4535	4541	{
4536	4542	// construct type.typename
4537	4543	if(!(stack[base + 0] = construct(1)))
4538	4544	{
4539		- label = 330LLU; // throw: begin to unroll stack
	4545	+ label = 331LLU; // throw: begin to unroll stack
4540	4546	break;
4541	4547	}
4542	4548

		@@ -4544,20 +4550,20 @@
4544	4550	((uint64_t *)stack[base + 0])[0] = 0;
4545	4551	(((uint64_t *)(stack[base + 0]))[1][0]) = stack[base + 2]/name*/;
4546	4552	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4547		- label = 328LLU; // case complete
	4553	+ label = 329LLU; // case complete
4548	4554	break;
4549	4555	}
4550		- case 330LLU: // copy-back deleter (switch)
	4556	+ case 331LLU: // copy-back deleter (switch)
4551	4557	{
4552	4558	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4553		- label = 327LLU; // continue to unroll stack
	4559	+ label = 328LLU; // continue to unroll stack
4554	4560	break;
4555	4561	}
4556		- case 329LLU: // try next case
	4562	+ case 330LLU: // try next case
4557	4563	{
4558	4564	if(/typelist/1 != ((uint64_t )(stack[base + 1]/type*/))[0])
4559	4565	{
4560		- label = 334LLU; // jump to alternative
	4566	+ label = 335LLU; // jump to alternative
4561	4567	break;
4562	4568	}
4563	4569

		@@ -4567,7 +4573,7 @@
4567	4573	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4568	4574	if(!newstack)
4569	4575	{
4570		- label = 335LLU; // throw: begin to unroll stack
	4576	+ label = 336LLU; // throw: begin to unroll stack
4571	4577	break;
4572	4578	}
4573	4579

		@@ -4574,18 +4580,18 @@
4574	4580	newstack[15LLU] = 9876543210LLU; // overflow-marker
4575	4581	// call copytype from copytype
4576	4582	newstack[0] = (uint64_t)stack; // backup stack location
4577		- newstack[1] = 336LLU;
	4583	+ newstack[1] = 337LLU;
4578	4584	newstack[2] = base;
4579		- newstack[3] = 337LLU;
	4585	+ newstack[3] = 338LLU;
4580	4586	// arguments for call to copytype
4581	4587	newstack[5LLU] = stack[base + 2]/original/;
4582	4588	stack = newstack;
4583	4589	// set stack-base & callee-address
4584	4590	base = 4/deloffset/;
4585		- label = 326LLU; // copytype
	4591	+ label = 327LLU; // copytype
4586	4592	break;
4587	4593	}
4588		- case 336LLU: // copy-back deleter (copytype to copytype)
	4594	+ case 337LLU: // copy-back deleter (copytype to copytype)
4589	4595	{
4590	4596	fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
4591	4597	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4597,10 +4603,10 @@
4597	4603	}
4598	4604	Free(15LLU + 1, sizeof(uint64_t), stack);
4599	4605	stack = oldstack;
4600		- label = 335LLU; // continue to unroll stack
	4606	+ label = 336LLU; // continue to unroll stack
4601	4607	break;
4602	4608	}
4603		- case 337LLU: // return from copytype to copytype
	4609	+ case 338LLU: // return from copytype to copytype
4604	4610	{
4605	4611	uint64_t oldstack = (uint64_t )stack[0];
4606	4612	// copy mutable arguments back from call to copytype

		@@ -4613,16 +4619,16 @@
4613	4619	}
4614	4620	Free(15LLU + 1, sizeof(uint64_t), stack);
4615	4621	stack = oldstack;
4616		- label = 339LLU; // skip deleter
	4622	+ label = 340LLU; // skip deleter
4617	4623	break;
4618	4624	}
4619		- case 338LLU: // deleter
	4625	+ case 339LLU: // deleter
4620	4626	{
4621	4627	// throw from copytype
4622	4628	if(!stack[base + 0])
4623	4629	{
4624	4630	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
4626	4632	break;
4627	4633	}
4628	4634	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4632,28 +4638,28 @@
4632	4638	newstack[0] = (uint64_t)stack; // backup stack location
4633	4639	newstack[1] = 1234567890;
4634	4640	newstack[2] = base;
4635		- newstack[3] = 340LLU;
	4641	+ newstack[3] = 341LLU;
4636	4642	stack = newstack;
4637	4643	// set stack-base & callee-address
4638	4644	base = 4/deloffset/;
4639		- label = 295LLU; // ~type
	4645	+ label = 296LLU; // ~type
4640	4646	break;
4641	4647	}
4642		- case 340LLU: // return from ~type to copytype
	4648	+ case 341LLU: // return from ~type to copytype
4643	4649	{
4644	4650	stack = (uint64_t *)stack[0];
4645	4651	// releasing toplevel container
4646	4652	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4647	4653
4648		- label = 335LLU; // continue unrolling stack, delete next variable
	4654	+ label = 336LLU; // continue unrolling stack, delete next variable
4649	4655	break;
4650	4656	}
4651		- case 339LLU: // skipped deleter
	4657	+ case 340LLU: // skipped deleter
4652	4658	{
4653	4659	// construct type.typelist
4654	4660	if(!(stack[base + 0] = construct(1)))
4655	4661	{
4656		- label = 335LLU; // throw: begin to unroll stack
	4662	+ label = 336LLU; // throw: begin to unroll stack
4657	4663	break;
4658	4664	}
4659	4665

		@@ -4661,21 +4667,21 @@
4661	4667	((uint64_t *)stack[base + 0])[0] = 1;
4662	4668	INIT(&(((uint64_t *)(stack[base + 0]))[1][0]), &stack[base + 3]/copy*/);
4663	4669	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4664		- label = 328LLU; // case complete
	4670	+ label = 329LLU; // case complete
4665	4671	break;
4666	4672	}
4667		- case 335LLU: // copy-back deleter (switch)
	4673	+ case 336LLU: // copy-back deleter (switch)
4668	4674	{
4669	4675	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4670		- label = 327LLU; // continue to unroll stack
	4676	+ label = 328LLU; // continue to unroll stack
4671	4677	break;
4672	4678	}
4673		- case 334LLU: // try next case
	4679	+ case 335LLU: // try next case
4674	4680	{
4675	4681	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4676	4682	exit(-1);
4677	4683	}
4678		- case 328LLU: // completed switch
	4684	+ case 329LLU: // completed switch
4679	4685	{
4680	4686	// return from copytype
4681	4687	label = stack[base - 1];

		@@ -4682,7 +4688,7 @@
4682	4688	base = stack[base - 2];
4683	4689	break;
4684	4690	}
4685		- case 342LLU: // function equtype failed
	4691	+ case 343LLU: // function equtype failed
4686	4692	{
4687	4693	fprintf(stderr, "function equtype failed\n");
4688	4694	label = stack[base - 3];

		@@ -4689,7 +4695,7 @@
4689	4695	base = stack[base - 2];
4690	4696	break;
4691	4697	}
4692		- case 341LLU: // equtype
	4698	+ case 342LLU: // equtype
4693	4699	{
4694	4700	//#define res0 0
4695	4701	//#define arg0 1

		@@ -4696,7 +4702,7 @@
4696	4702	//#define arg1 2
4697	4703	if(/typename/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
4698	4704	{
4699		- label = 344LLU; // jump to alternative
	4705	+ label = 345LLU; // jump to alternative
4700	4706	break;
4701	4707	}
4702	4708

		@@ -4704,7 +4710,7 @@
4704	4710
4705	4711	if(/typename/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
4706	4712	{
4707		- label = 344LLU; // jump to alternative
	4713	+ label = 345LLU; // jump to alternative
4708	4714	break;
4709	4715	}
4710	4716

		@@ -4712,9 +4718,9 @@
4712	4718
4713	4719	// case
4714	4720	// call equ from equtype
4715		- stack[base + 5LLU] = 346LLU/throw to this address/;
	4721	+ stack[base + 5LLU] = 347LLU/throw to this address/;
4716	4722	stack[base + 6LLU] = base;
4717		- stack[base + 7LLU] = 347LLU;
	4723	+ stack[base + 7LLU] = 348LLU;
4718	4724	// arguments for call to equ
4719	4725	stack[base + 9LLU] = stack[base + 3]/xname/;
4720	4726	stack[base + 10LLU] = stack[base + 4]/yname/;

		@@ -4723,14 +4729,14 @@
4723	4729	label = 18446744073709551600LLU; // equ
4724	4730	break;
4725	4731	}
4726		- case 346LLU: // copy-back deleter (equ to equtype)
	4732	+ case 347LLU: // copy-back deleter (equ to equtype)
4727	4733	{
4728	4734	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
4729	4735	// copy mutable arguments back from call to equ
4730		- label = 345LLU; // continue to roll stack
	4736	+ label = 346LLU; // continue to roll stack
4731	4737	break;
4732	4738	}
4733		- case 347LLU: // return from equ to equtype
	4739	+ case 348LLU: // return from equ to equtype
4734	4740	{
4735	4741	// copy mutable arguments back from call to equ
4736	4742	// copy back results provided by call to equ

		@@ -4737,21 +4743,21 @@
4737	4743	stack[base + 0] = stack[base + 8LLU];
4738	4744	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4739	4745	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4740		- label = 343LLU; // case complete
	4746	+ label = 344LLU; // case complete
4741	4747	break;
4742	4748	}
4743		- case 345LLU: // copy-back deleter (switch)
	4749	+ case 346LLU: // copy-back deleter (switch)
4744	4750	{
4745	4751	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4746	4752	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4747		- label = 342LLU; // continue to unroll stack
	4753	+ label = 343LLU; // continue to unroll stack
4748	4754	break;
4749	4755	}
4750		- case 344LLU: // try next case
	4756	+ case 345LLU: // try next case
4751	4757	{
4752	4758	if(/typelist/1 != ((uint64_t )(stack[base + 1]/x*/))[0])
4753	4759	{
4754		- label = 348LLU; // jump to alternative
	4760	+ label = 349LLU; // jump to alternative
4755	4761	break;
4756	4762	}
4757	4763

		@@ -4759,7 +4765,7 @@
4759	4765
4760	4766	if(/typelist/1 != ((uint64_t )(stack[base + 2]/y*/))[0])
4761	4767	{
4762		- label = 348LLU; // jump to alternative
	4768	+ label = 349LLU; // jump to alternative
4763	4769	break;
4764	4770	}
4765	4771

		@@ -4769,7 +4775,7 @@
4769	4775	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4770	4776	if(!newstack)
4771	4777	{
4772		- label = 349LLU; // throw: begin to unroll stack
	4778	+ label = 350LLU; // throw: begin to unroll stack
4773	4779	break;
4774	4780	}
4775	4781

		@@ -4776,9 +4782,9 @@
4776	4782	newstack[15LLU] = 9876543210LLU; // overflow-marker
4777	4783	// call equtype from equtype
4778	4784	newstack[0] = (uint64_t)stack; // backup stack location
4779		- newstack[1] = 350LLU;
	4785	+ newstack[1] = 351LLU;
4780	4786	newstack[2] = base;
4781		- newstack[3] = 351LLU;
	4787	+ newstack[3] = 352LLU;
4782	4788	// arguments for call to equtype
4783	4789	newstack[5LLU] = stack[base + 3]/xsubtype/;
4784	4790	newstack[6LLU] = stack[base + 4]/ysubtype/;

		@@ -4785,10 +4791,10 @@
4785	4791	stack = newstack;
4786	4792	// set stack-base & callee-address
4787	4793	base = 4/deloffset/;
4788		- label = 341LLU; // equtype
	4794	+ label = 342LLU; // equtype
4789	4795	break;
4790	4796	}
4791		- case 350LLU: // copy-back deleter (equtype to equtype)
	4797	+ case 351LLU: // copy-back deleter (equtype to equtype)
4792	4798	{
4793	4799	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
4794	4800	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4800,10 +4806,10 @@
4800	4806	}
4801	4807	Free(15LLU + 1, sizeof(uint64_t), stack);
4802	4808	stack = oldstack;
4803		- label = 349LLU; // continue to unroll stack
	4809	+ label = 350LLU; // continue to unroll stack
4804	4810	break;
4805	4811	}
4806		- case 351LLU: // return from equtype to equtype
	4812	+ case 352LLU: // return from equtype to equtype
4807	4813	{
4808	4814	uint64_t oldstack = (uint64_t )stack[0];
4809	4815	// copy mutable arguments back from call to equtype

		@@ -4818,42 +4824,42 @@
4818	4824	stack = oldstack;
4819	4825	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4820	4826	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4821		- label = 343LLU; // case complete
	4827	+ label = 344LLU; // case complete
4822	4828	break;
4823	4829	}
4824		- case 349LLU: // copy-back deleter (switch)
	4830	+ case 350LLU: // copy-back deleter (switch)
4825	4831	{
4826	4832	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4827	4833	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4828		- label = 342LLU; // continue to unroll stack
	4834	+ label = 343LLU; // continue to unroll stack
4829	4835	break;
4830	4836	}
4831		- case 348LLU: // try next case
	4837	+ case 349LLU: // try next case
4832	4838	{
4833	4839	// default
4834		- label = 353LLU; // skip deleter
	4840	+ label = 354LLU; // skip deleter
4835	4841	break;
4836	4842	}
4837		- case 352LLU: // deleter
	4843	+ case 353LLU: // deleter
4838	4844	{
4839	4845	// throw from equtype
4840	4846	if(!stack[base + 0])
4841	4847	{
4842	4848	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
4844	4850	break;
4845	4851	}
4846	4852	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
4848	4854	break;
4849	4855	}
4850		- case 353LLU: // skipped deleter
	4856	+ case 354LLU: // skipped deleter
4851	4857	{
4852	4858	stack[base + 0] = 0;
4853		- label = 343LLU; // default complete
	4859	+ label = 344LLU; // default complete
4854	4860	break;
4855	4861	}
4856		- case 343LLU: // completed switch
	4862	+ case 344LLU: // completed switch
4857	4863	{
4858	4864	// return from equtype
4859	4865	label = stack[base - 1];

		@@ -4860,7 +4866,7 @@
4860	4866	base = stack[base - 2];
4861	4867	break;
4862	4868	}
4863		- case 354LLU: // ~typeid
	4869	+ case 355LLU: // ~typeid
4864	4870	{
4865	4871	if(stack[base + 0]/variant-nr/ >= 1)
4866	4872	{

		@@ -4867,10 +4873,10 @@
4867	4873	fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
4868	4874	exit(-1);
4869	4875	}
4870		- label = 354LLU + 1LLU + stack[base + 0]/variant-nr/;
	4876	+ label = 355LLU + 1LLU + stack[base + 0]/variant-nr/;
4871	4877	break;
4872	4878	}
4873		- case 354LLU + 1LLU + 0LLU: // ~typeid.typeid
	4879	+ case 355LLU + 1LLU + 0LLU: // ~typeid.typeid
4874	4880	{
4875	4881	// release element type
4876	4882	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -4880,14 +4886,14 @@
4880	4886	newstack[0] = (uint64_t)stack; // backup stack location
4881	4887	newstack[1] = 1234567890;
4882	4888	newstack[2] = base;
4883		- newstack[3] = 356LLU;
	4889	+ newstack[3] = 357LLU;
4884	4890	stack = newstack;
4885	4891	// set stack-base & callee-address
4886	4892	base = 4/deloffset/;
4887		- label = 295LLU; // ~type
	4893	+ label = 296LLU; // ~type
4888	4894	break;
4889	4895	}
4890		- case 356LLU: // return from ~type to typeid
	4896	+ case 357LLU: // return from ~type to typeid
4891	4897	{
4892	4898	stack = (uint64_t *)stack[0];
4893	4899	// releasing toplevel container

		@@ -4900,7 +4906,7 @@
4900	4906	base = stack[base - 2];
4901	4907	break;
4902	4908	}
4903		- case 358LLU: // function copytypeid failed
	4909	+ case 359LLU: // function copytypeid failed
4904	4910	{
4905	4911	fprintf(stderr, "function copytypeid failed\n");
4906	4912	label = stack[base - 3];

		@@ -4907,13 +4913,13 @@
4907	4913	base = stack[base - 2];
4908	4914	break;
4909	4915	}
4910		- case 357LLU: // copytypeid
	4916	+ case 358LLU: // copytypeid
4911	4917	{
4912	4918	//#define res0 0
4913	4919	//#define arg0 1
4914	4920	if(/typeid/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
4915	4921	{
4916		- label = 360LLU; // jump to alternative
	4922	+ label = 361LLU; // jump to alternative
4917	4923	break;
4918	4924	}
4919	4925

		@@ -4924,7 +4930,7 @@
4924	4930	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4925	4931	if(!newstack)
4926	4932	{
4927		- label = 361LLU; // throw: begin to unroll stack
	4933	+ label = 362LLU; // throw: begin to unroll stack
4928	4934	break;
4929	4935	}
4930	4936

		@@ -4931,18 +4937,18 @@
4931	4937	newstack[15LLU] = 9876543210LLU; // overflow-marker
4932	4938	// call copytype from copytypeid
4933	4939	newstack[0] = (uint64_t)stack; // backup stack location
4934		- newstack[1] = 362LLU;
	4940	+ newstack[1] = 363LLU;
4935	4941	newstack[2] = base;
4936		- newstack[3] = 363LLU;
	4942	+ newstack[3] = 364LLU;
4937	4943	// arguments for call to copytype
4938	4944	newstack[5LLU] = stack[base + 2]/origtype/;
4939	4945	stack = newstack;
4940	4946	// set stack-base & callee-address
4941	4947	base = 4/deloffset/;
4942		- label = 326LLU; // copytype
	4948	+ label = 327LLU; // copytype
4943	4949	break;
4944	4950	}
4945		- case 362LLU: // copy-back deleter (copytype to copytypeid)
	4951	+ case 363LLU: // copy-back deleter (copytype to copytypeid)
4946	4952	{
4947	4953	fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
4948	4954	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4954,10 +4960,10 @@
4954	4960	}
4955	4961	Free(15LLU + 1, sizeof(uint64_t), stack);
4956	4962	stack = oldstack;
4957		- label = 361LLU; // continue to unroll stack
	4963	+ label = 362LLU; // continue to unroll stack
4958	4964	break;
4959	4965	}
4960		- case 363LLU: // return from copytype to copytypeid
	4966	+ case 364LLU: // return from copytype to copytypeid
4961	4967	{
4962	4968	uint64_t oldstack = (uint64_t )stack[0];
4963	4969	// copy mutable arguments back from call to copytype

		@@ -4970,35 +4976,35 @@
4970	4976	}
4971	4977	Free(15LLU + 1, sizeof(uint64_t), stack);
4972	4978	stack = oldstack;
4973		- label = 365LLU; // skip deleter
	4979	+ label = 366LLU; // skip deleter
4974	4980	break;
4975	4981	}
4976		- case 364LLU: // deleter
	4982	+ case 365LLU: // deleter
4977	4983	{
4978	4984	// throw from copytypeid
4979	4985	if(!stack[base + 5])
4980	4986	{
4981	4987	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
4983	4989	break;
4984	4990	}
4985	4991	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
4987	4993	break;
4988	4994	}
4989		- case 365LLU: // skipped deleter
	4995	+ case 366LLU: // skipped deleter
4990	4996	{
4991	4997	stack[base + 5] = stack[base + 3]/origid/;
4992		- label = 367LLU; // skip deleter
	4998	+ label = 368LLU; // skip deleter
4993	4999	break;
4994	5000	}
4995		- case 366LLU: // deleter
	5001	+ case 367LLU: // deleter
4996	5002	{
4997	5003	// throw from copytypeid
4998	5004	if(!stack[base + 0])
4999	5005	{
5000	5006	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
5002	5008	break;
5003	5009	}
5004	5010	fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");

		@@ -5008,28 +5014,28 @@
5008	5014	newstack[0] = (uint64_t)stack; // backup stack location
5009	5015	newstack[1] = 1234567890;
5010	5016	newstack[2] = base;
5011		- newstack[3] = 368LLU;
	5017	+ newstack[3] = 369LLU;
5012	5018	stack = newstack;
5013	5019	// set stack-base & callee-address
5014	5020	base = 4/deloffset/;
5015		- label = 354LLU; // ~typeid
	5021	+ label = 355LLU; // ~typeid
5016	5022	break;
5017	5023	}
5018		- case 368LLU: // return from ~typeid to copytypeid
	5024	+ case 369LLU: // return from ~typeid to copytypeid
5019	5025	{
5020	5026	stack = (uint64_t *)stack[0];
5021	5027	// releasing toplevel container
5022	5028	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5023	5029
5024		- label = 364LLU; // continue unrolling stack, delete next variable
	5030	+ label = 365LLU; // continue unrolling stack, delete next variable
5025	5031	break;
5026	5032	}
5027		- case 367LLU: // skipped deleter
	5033	+ case 368LLU: // skipped deleter
5028	5034	{
5029	5035	// construct typeid.typeid
5030	5036	if(!(stack[base + 0] = construct(2)))
5031	5037	{
5032		- label = 364LLU; // throw: begin to unroll stack
	5038	+ label = 365LLU; // throw: begin to unroll stack
5033	5039	break;
5034	5040	}
5035	5041

		@@ -5039,22 +5045,22 @@
5039	5045	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copyid*/;
5040	5046	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5041	5047	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5042		- label = 359LLU; // case complete
	5048	+ label = 360LLU; // case complete
5043	5049	break;
5044	5050	}
5045		- case 361LLU: // copy-back deleter (switch)
	5051	+ case 362LLU: // copy-back deleter (switch)
5046	5052	{
5047	5053	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5048	5054	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5049		- label = 358LLU; // continue to unroll stack
	5055	+ label = 359LLU; // continue to unroll stack
5050	5056	break;
5051	5057	}
5052		- case 360LLU: // try next case
	5058	+ case 361LLU: // try next case
5053	5059	{
5054	5060	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5055	5061	exit(-1);
5056	5062	}
5057		- case 359LLU: // completed switch
	5063	+ case 360LLU: // completed switch
5058	5064	{
5059	5065	// return from copytypeid
5060	5066	label = stack[base - 1];

		@@ -5061,7 +5067,7 @@
5061	5067	base = stack[base - 2];
5062	5068	break;
5063	5069	}
5064		- case 370LLU: // function reportti failed
	5070	+ case 371LLU: // function reportti failed
5065	5071	{
5066	5072	fprintf(stderr, "function reportti failed\n");
5067	5073	label = stack[base - 3];

		@@ -5068,12 +5074,12 @@
5068	5074	base = stack[base - 2];
5069	5075	break;
5070	5076	}
5071		- case 369LLU: // reportti
	5077	+ case 370LLU: // reportti
5072	5078	{
5073	5079	//#define arg0 0
5074	5080	if(/typeid/0 != ((uint64_t )(stack[base + 0]/typeid*/))[0])
5075	5081	{
5076		- label = 372LLU; // jump to alternative
	5082	+ label = 373LLU; // jump to alternative
5077	5083	break;
5078	5084	}
5079	5085

		@@ -5084,7 +5090,7 @@
5084	5090	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5085	5091	if(!newstack)
5086	5092	{
5087		- label = 373LLU; // throw: begin to unroll stack
	5093	+ label = 374LLU; // throw: begin to unroll stack
5088	5094	break;
5089	5095	}
5090	5096

		@@ -5091,18 +5097,18 @@
5091	5097	newstack[10LLU] = 9876543210LLU; // overflow-marker
5092	5098	// call reporttype from reportti
5093	5099	newstack[0] = (uint64_t)stack; // backup stack location
5094		- newstack[1] = 374LLU;
	5100	+ newstack[1] = 375LLU;
5095	5101	newstack[2] = base;
5096		- newstack[3] = 375LLU;
	5102	+ newstack[3] = 376LLU;
5097	5103	// arguments for call to reporttype
5098	5104	newstack[4LLU] = stack[base + 1]/type/;
5099	5105	stack = newstack;
5100	5106	// set stack-base & callee-address
5101	5107	base = 4/deloffset/;
5102		- label = 315LLU; // reporttype
	5108	+ label = 316LLU; // reporttype
5103	5109	break;
5104	5110	}
5105		- case 374LLU: // copy-back deleter (reporttype to reportti)
	5111	+ case 375LLU: // copy-back deleter (reporttype to reportti)
5106	5112	{
5107	5113	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
5108	5114	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5114,10 +5120,10 @@
5114	5120	}
5115	5121	Free(10LLU + 1, sizeof(uint64_t), stack);
5116	5122	stack = oldstack;
5117		- label = 373LLU; // continue to unroll stack
	5123	+ label = 374LLU; // continue to unroll stack
5118	5124	break;
5119	5125	}
5120		- case 375LLU: // return from reporttype to reportti
	5126	+ case 376LLU: // return from reporttype to reportti
5121	5127	{
5122	5128	uint64_t oldstack = (uint64_t )stack[0];
5123	5129	// copy mutable arguments back from call to reporttype

		@@ -5130,9 +5136,9 @@
5130	5136	stack = oldstack;
5131	5137	fprintf(stderr, "%s", " ");
5132	5138	// call reportid from reportti
5133		- stack[base + 3LLU] = 376LLU/throw to this address/;
	5139	+ stack[base + 3LLU] = 377LLU/throw to this address/;
5134	5140	stack[base + 4LLU] = base;
5135		- stack[base + 5LLU] = 377LLU;
	5141	+ stack[base + 5LLU] = 378LLU;
5136	5142	// arguments for call to reportid
5137	5143	stack[base + 6LLU] = stack[base + 2]/id/;
5138	5144	// set stack-base & callee-address

		@@ -5140,34 +5146,34 @@
5140	5146	label = 18446744073709551586LLU; // reportid
5141	5147	break;
5142	5148	}
5143		- case 376LLU: // copy-back deleter (reportid to reportti)
	5149	+ case 377LLU: // copy-back deleter (reportid to reportti)
5144	5150	{
5145	5151	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
5146	5152	// copy mutable arguments back from call to reportid
5147		- label = 373LLU; // continue to roll stack
	5153	+ label = 374LLU; // continue to roll stack
5148	5154	break;
5149	5155	}
5150		- case 377LLU: // return from reportid to reportti
	5156	+ case 378LLU: // return from reportid to reportti
5151	5157	{
5152	5158	// copy mutable arguments back from call to reportid
5153	5159	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5154	5160	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5155		- label = 371LLU; // case complete
	5161	+ label = 372LLU; // case complete
5156	5162	break;
5157	5163	}
5158		- case 373LLU: // copy-back deleter (switch)
	5164	+ case 374LLU: // copy-back deleter (switch)
5159	5165	{
5160	5166	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5161	5167	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5162		- label = 370LLU; // continue to unroll stack
	5168	+ label = 371LLU; // continue to unroll stack
5163	5169	break;
5164	5170	}
5165		- case 372LLU: // try next case
	5171	+ case 373LLU: // try next case
5166	5172	{
5167	5173	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5168	5174	exit(-1);
5169	5175	}
5170		- case 371LLU: // completed switch
	5176	+ case 372LLU: // completed switch
5171	5177	{
5172	5178	// return from reportti
5173	5179	label = stack[base - 1];

		@@ -5174,7 +5180,7 @@
5174	5180	base = stack[base - 2];
5175	5181	break;
5176	5182	}
5177		- case 378LLU: // ~typeidx
	5183	+ case 379LLU: // ~typeidx
5178	5184	{
5179	5185	if(stack[base + 0]/variant-nr/ >= 1)
5180	5186	{

		@@ -5181,10 +5187,10 @@
5181	5187	fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5182	5188	exit(-1);
5183	5189	}
5184		- label = 378LLU + 1LLU + stack[base + 0]/variant-nr/;
	5190	+ label = 379LLU + 1LLU + stack[base + 0]/variant-nr/;
5185	5191	break;
5186	5192	}
5187		- case 378LLU + 1LLU + 0LLU: // ~typeidx.typeidx
	5193	+ case 379LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5188	5194	{
5189	5195	// release element type
5190	5196	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5194,14 +5200,14 @@
5194	5200	newstack[0] = (uint64_t)stack; // backup stack location
5195	5201	newstack[1] = 1234567890;
5196	5202	newstack[2] = base;
5197		- newstack[3] = 380LLU;
	5203	+ newstack[3] = 381LLU;
5198	5204	stack = newstack;
5199	5205	// set stack-base & callee-address
5200	5206	base = 4/deloffset/;
5201		- label = 295LLU; // ~type
	5207	+ label = 296LLU; // ~type
5202	5208	break;
5203	5209	}
5204		- case 380LLU: // return from ~type to typeidx
	5210	+ case 381LLU: // return from ~type to typeidx
5205	5211	{
5206	5212	stack = (uint64_t *)stack[0];
5207	5213	// releasing toplevel container

		@@ -5214,7 +5220,7 @@
5214	5220	base = stack[base - 2];
5215	5221	break;
5216	5222	}
5217		- case 382LLU: // function cptypeidx failed
	5223	+ case 383LLU: // function cptypeidx failed
5218	5224	{
5219	5225	fprintf(stderr, "function cptypeidx failed\n");
5220	5226	label = stack[base - 3];

		@@ -5221,13 +5227,13 @@
5221	5227	base = stack[base - 2];
5222	5228	break;
5223	5229	}
5224		- case 381LLU: // cptypeidx
	5230	+ case 382LLU: // cptypeidx
5225	5231	{
5226	5232	//#define res0 0
5227	5233	//#define arg0 1
5228	5234	if(/typeidx/0 != ((uint64_t )(stack[base + 1]/orig*/))[0])
5229	5235	{
5230		- label = 384LLU; // jump to alternative
	5236	+ label = 385LLU; // jump to alternative
5231	5237	break;
5232	5238	}
5233	5239

		@@ -5238,7 +5244,7 @@
5238	5244	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5239	5245	if(!newstack)
5240	5246	{
5241		- label = 385LLU; // throw: begin to unroll stack
	5247	+ label = 386LLU; // throw: begin to unroll stack
5242	5248	break;
5243	5249	}
5244	5250

		@@ -5245,18 +5251,18 @@
5245	5251	newstack[15LLU] = 9876543210LLU; // overflow-marker
5246	5252	// call copytype from cptypeidx
5247	5253	newstack[0] = (uint64_t)stack; // backup stack location
5248		- newstack[1] = 386LLU;
	5254	+ newstack[1] = 387LLU;
5249	5255	newstack[2] = base;
5250		- newstack[3] = 387LLU;
	5256	+ newstack[3] = 388LLU;
5251	5257	// arguments for call to copytype
5252	5258	newstack[5LLU] = stack[base + 2]/otype/;
5253	5259	stack = newstack;
5254	5260	// set stack-base & callee-address
5255	5261	base = 4/deloffset/;
5256		- label = 326LLU; // copytype
	5262	+ label = 327LLU; // copytype
5257	5263	break;
5258	5264	}
5259		- case 386LLU: // copy-back deleter (copytype to cptypeidx)
	5265	+ case 387LLU: // copy-back deleter (copytype to cptypeidx)
5260	5266	{
5261	5267	fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
5262	5268	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5268,10 +5274,10 @@
5268	5274	}
5269	5275	Free(15LLU + 1, sizeof(uint64_t), stack);
5270	5276	stack = oldstack;
5271		- label = 385LLU; // continue to unroll stack
	5277	+ label = 386LLU; // continue to unroll stack
5272	5278	break;
5273	5279	}
5274		- case 387LLU: // return from copytype to cptypeidx
	5280	+ case 388LLU: // return from copytype to cptypeidx
5275	5281	{
5276	5282	uint64_t oldstack = (uint64_t )stack[0];
5277	5283	// copy mutable arguments back from call to copytype

		@@ -5284,35 +5290,35 @@
5284	5290	}
5285	5291	Free(15LLU + 1, sizeof(uint64_t), stack);
5286	5292	stack = oldstack;
5287		- label = 389LLU; // skip deleter
	5293	+ label = 390LLU; // skip deleter
5288	5294	break;
5289	5295	}
5290		- case 388LLU: // deleter
	5296	+ case 389LLU: // deleter
5291	5297	{
5292	5298	// throw from cptypeidx
5293	5299	if(!stack[base + 5])
5294	5300	{
5295	5301	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
5297	5303	break;
5298	5304	}
5299	5305	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
5301	5307	break;
5302	5308	}
5303		- case 389LLU: // skipped deleter
	5309	+ case 390LLU: // skipped deleter
5304	5310	{
5305	5311	stack[base + 5] = stack[base + 3]/oidx/;
5306		- label = 391LLU; // skip deleter
	5312	+ label = 392LLU; // skip deleter
5307	5313	break;
5308	5314	}
5309		- case 390LLU: // deleter
	5315	+ case 391LLU: // deleter
5310	5316	{
5311	5317	// throw from cptypeidx
5312	5318	if(!stack[base + 0])
5313	5319	{
5314	5320	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
5316	5322	break;
5317	5323	}
5318	5324	fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");

		@@ -5322,28 +5328,28 @@
5322	5328	newstack[0] = (uint64_t)stack; // backup stack location
5323	5329	newstack[1] = 1234567890;
5324	5330	newstack[2] = base;
5325		- newstack[3] = 392LLU;
	5331	+ newstack[3] = 393LLU;
5326	5332	stack = newstack;
5327	5333	// set stack-base & callee-address
5328	5334	base = 4/deloffset/;
5329		- label = 378LLU; // ~typeidx
	5335	+ label = 379LLU; // ~typeidx
5330	5336	break;
5331	5337	}
5332		- case 392LLU: // return from ~typeidx to cptypeidx
	5338	+ case 393LLU: // return from ~typeidx to cptypeidx
5333	5339	{
5334	5340	stack = (uint64_t *)stack[0];
5335	5341	// releasing toplevel container
5336	5342	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5337	5343
5338		- label = 388LLU; // continue unrolling stack, delete next variable
	5344	+ label = 389LLU; // continue unrolling stack, delete next variable
5339	5345	break;
5340	5346	}
5341		- case 391LLU: // skipped deleter
	5347	+ case 392LLU: // skipped deleter
5342	5348	{
5343	5349	// construct typeidx.typeidx
5344	5350	if(!(stack[base + 0] = construct(2)))
5345	5351	{
5346		- label = 388LLU; // throw: begin to unroll stack
	5352	+ label = 389LLU; // throw: begin to unroll stack
5347	5353	break;
5348	5354	}
5349	5355

		@@ -5353,22 +5359,22 @@
5353	5359	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/cidx*/;
5354	5360	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5355	5361	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5356		- label = 383LLU; // case complete
	5362	+ label = 384LLU; // case complete
5357	5363	break;
5358	5364	}
5359		- case 385LLU: // copy-back deleter (switch)
	5365	+ case 386LLU: // copy-back deleter (switch)
5360	5366	{
5361	5367	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5362	5368	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5363		- label = 382LLU; // continue to unroll stack
	5369	+ label = 383LLU; // continue to unroll stack
5364	5370	break;
5365	5371	}
5366		- case 384LLU: // try next case
	5372	+ case 385LLU: // try next case
5367	5373	{
5368	5374	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5369	5375	exit(-1);
5370	5376	}
5371		- case 383LLU: // completed switch
	5377	+ case 384LLU: // completed switch
5372	5378	{
5373	5379	// return from cptypeidx
5374	5380	label = stack[base - 1];

		@@ -5375,7 +5381,7 @@
5375	5381	base = stack[base - 2];
5376	5382	break;
5377	5383	}
5378		- case 393LLU: // ~result
	5384	+ case 394LLU: // ~result
5379	5385	{
5380	5386	if(stack[base + 0]/variant-nr/ >= 1)
5381	5387	{

		@@ -5382,10 +5388,10 @@
5382	5388	fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5383	5389	exit(-1);
5384	5390	}
5385		- label = 393LLU + 1LLU + stack[base + 0]/variant-nr/;
	5391	+ label = 394LLU + 1LLU + stack[base + 0]/variant-nr/;
5386	5392	break;
5387	5393	}
5388		- case 393LLU + 1LLU + 0LLU: // ~result.result
	5394	+ case 394LLU + 1LLU + 0LLU: // ~result.result
5389	5395	{
5390	5396	// release element type
5391	5397	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5395,14 +5401,14 @@
5395	5401	newstack[0] = (uint64_t)stack; // backup stack location
5396	5402	newstack[1] = 1234567890;
5397	5403	newstack[2] = base;
5398		- newstack[3] = 395LLU;
	5404	+ newstack[3] = 396LLU;
5399	5405	stack = newstack;
5400	5406	// set stack-base & callee-address
5401	5407	base = 4/deloffset/;
5402		- label = 295LLU; // ~type
	5408	+ label = 296LLU; // ~type
5403	5409	break;
5404	5410	}
5405		- case 395LLU: // return from ~type to result
	5411	+ case 396LLU: // return from ~type to result
5406	5412	{
5407	5413	stack = (uint64_t *)stack[0];
5408	5414	// releasing toplevel container

		@@ -5415,7 +5421,7 @@
5415	5421	base = stack[base - 2];
5416	5422	break;
5417	5423	}
5418		- case 397LLU: // function copyresult failed
	5424	+ case 398LLU: // function copyresult failed
5419	5425	{
5420	5426	fprintf(stderr, "function copyresult failed\n");
5421	5427	label = stack[base - 3];

		@@ -5422,13 +5428,13 @@
5422	5428	base = stack[base - 2];
5423	5429	break;
5424	5430	}
5425		- case 396LLU: // copyresult
	5431	+ case 397LLU: // copyresult
5426	5432	{
5427	5433	//#define res0 0
5428	5434	//#define arg0 1
5429	5435	if(/result/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5430	5436	{
5431		- label = 399LLU; // jump to alternative
	5437	+ label = 400LLU; // jump to alternative
5432	5438	break;
5433	5439	}
5434	5440

		@@ -5439,7 +5445,7 @@
5439	5445	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5440	5446	if(!newstack)
5441	5447	{
5442		- label = 400LLU; // throw: begin to unroll stack
	5448	+ label = 401LLU; // throw: begin to unroll stack
5443	5449	break;
5444	5450	}
5445	5451

		@@ -5446,18 +5452,18 @@
5446	5452	newstack[15LLU] = 9876543210LLU; // overflow-marker
5447	5453	// call copytype from copyresult
5448	5454	newstack[0] = (uint64_t)stack; // backup stack location
5449		- newstack[1] = 401LLU;
	5455	+ newstack[1] = 402LLU;
5450	5456	newstack[2] = base;
5451		- newstack[3] = 402LLU;
	5457	+ newstack[3] = 403LLU;
5452	5458	// arguments for call to copytype
5453	5459	newstack[5LLU] = stack[base + 2]/origtype/;
5454	5460	stack = newstack;
5455	5461	// set stack-base & callee-address
5456	5462	base = 4/deloffset/;
5457		- label = 326LLU; // copytype
	5463	+ label = 327LLU; // copytype
5458	5464	break;
5459	5465	}
5460		- case 401LLU: // copy-back deleter (copytype to copyresult)
	5466	+ case 402LLU: // copy-back deleter (copytype to copyresult)
5461	5467	{
5462	5468	fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
5463	5469	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5469,10 +5475,10 @@
5469	5475	}
5470	5476	Free(15LLU + 1, sizeof(uint64_t), stack);
5471	5477	stack = oldstack;
5472		- label = 400LLU; // continue to unroll stack
	5478	+ label = 401LLU; // continue to unroll stack
5473	5479	break;
5474	5480	}
5475		- case 402LLU: // return from copytype to copyresult
	5481	+ case 403LLU: // return from copytype to copyresult
5476	5482	{
5477	5483	uint64_t oldstack = (uint64_t )stack[0];
5478	5484	// copy mutable arguments back from call to copytype

		@@ -5485,16 +5491,16 @@
5485	5491	}
5486	5492	Free(15LLU + 1, sizeof(uint64_t), stack);
5487	5493	stack = oldstack;
5488		- label = 404LLU; // skip deleter
	5494	+ label = 405LLU; // skip deleter
5489	5495	break;
5490	5496	}
5491		- case 403LLU: // deleter
	5497	+ case 404LLU: // deleter
5492	5498	{
5493	5499	// throw from copyresult
5494	5500	if(!stack[base + 0])
5495	5501	{
5496	5502	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
5498	5504	break;
5499	5505	}
5500	5506	fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");

		@@ -5504,28 +5510,28 @@
5504	5510	newstack[0] = (uint64_t)stack; // backup stack location
5505	5511	newstack[1] = 1234567890;
5506	5512	newstack[2] = base;
5507		- newstack[3] = 405LLU;
	5513	+ newstack[3] = 406LLU;
5508	5514	stack = newstack;
5509	5515	// set stack-base & callee-address
5510	5516	base = 4/deloffset/;
5511		- label = 393LLU; // ~result
	5517	+ label = 394LLU; // ~result
5512	5518	break;
5513	5519	}
5514		- case 405LLU: // return from ~result to copyresult
	5520	+ case 406LLU: // return from ~result to copyresult
5515	5521	{
5516	5522	stack = (uint64_t *)stack[0];
5517	5523	// releasing toplevel container
5518	5524	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5519	5525
5520		- label = 400LLU; // continue unrolling stack, delete next variable
	5526	+ label = 401LLU; // continue unrolling stack, delete next variable
5521	5527	break;
5522	5528	}
5523		- case 404LLU: // skipped deleter
	5529	+ case 405LLU: // skipped deleter
5524	5530	{
5525	5531	// construct result.result
5526	5532	if(!(stack[base + 0] = construct(2)))
5527	5533	{
5528		- label = 400LLU; // throw: begin to unroll stack
	5534	+ label = 401LLU; // throw: begin to unroll stack
5529	5535	break;
5530	5536	}
5531	5537

		@@ -5535,22 +5541,22 @@
5535	5541	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 3]/RESERVED*/;
5536	5542	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5537	5543	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5538		- label = 398LLU; // case complete
	5544	+ label = 399LLU; // case complete
5539	5545	break;
5540	5546	}
5541		- case 400LLU: // copy-back deleter (switch)
	5547	+ case 401LLU: // copy-back deleter (switch)
5542	5548	{
5543	5549	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5544	5550	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5545		- label = 397LLU; // continue to unroll stack
	5551	+ label = 398LLU; // continue to unroll stack
5546	5552	break;
5547	5553	}
5548		- case 399LLU: // try next case
	5554	+ case 400LLU: // try next case
5549	5555	{
5550	5556	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5551	5557	exit(-1);
5552	5558	}
5553		- case 398LLU: // completed switch
	5559	+ case 399LLU: // completed switch
5554	5560	{
5555	5561	// return from copyresult
5556	5562	label = stack[base - 1];

		@@ -5557,7 +5563,7 @@
5557	5563	base = stack[base - 2];
5558	5564	break;
5559	5565	}
5560		- case 407LLU: // function represult failed
	5566	+ case 408LLU: // function represult failed
5561	5567	{
5562	5568	fprintf(stderr, "function represult failed\n");
5563	5569	label = stack[base - 3];

		@@ -5564,12 +5570,12 @@
5564	5570	base = stack[base - 2];
5565	5571	break;
5566	5572	}
5567		- case 406LLU: // represult
	5573	+ case 407LLU: // represult
5568	5574	{
5569	5575	//#define arg0 0
5570	5576	if(/result/0 != ((uint64_t )(stack[base + 0]/result*/))[0])
5571	5577	{
5572		- label = 409LLU; // jump to alternative
	5578	+ label = 410LLU; // jump to alternative
5573	5579	break;
5574	5580	}
5575	5581

		@@ -5580,7 +5586,7 @@
5580	5586	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5581	5587	if(!newstack)
5582	5588	{
5583		- label = 410LLU; // throw: begin to unroll stack
	5589	+ label = 411LLU; // throw: begin to unroll stack
5584	5590	break;
5585	5591	}
5586	5592

		@@ -5587,18 +5593,18 @@
5587	5593	newstack[10LLU] = 9876543210LLU; // overflow-marker
5588	5594	// call reporttype from represult
5589	5595	newstack[0] = (uint64_t)stack; // backup stack location
5590		- newstack[1] = 411LLU;
	5596	+ newstack[1] = 412LLU;
5591	5597	newstack[2] = base;
5592		- newstack[3] = 412LLU;
	5598	+ newstack[3] = 413LLU;
5593	5599	// arguments for call to reporttype
5594	5600	newstack[4LLU] = stack[base + 1]/type/;
5595	5601	stack = newstack;
5596	5602	// set stack-base & callee-address
5597	5603	base = 4/deloffset/;
5598		- label = 315LLU; // reporttype
	5604	+ label = 316LLU; // reporttype
5599	5605	break;
5600	5606	}
5601		- case 411LLU: // copy-back deleter (reporttype to represult)
	5607	+ case 412LLU: // copy-back deleter (reporttype to represult)
5602	5608	{
5603	5609	fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
5604	5610	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5610,10 +5616,10 @@
5610	5616	}
5611	5617	Free(10LLU + 1, sizeof(uint64_t), stack);
5612	5618	stack = oldstack;
5613		- label = 410LLU; // continue to unroll stack
	5619	+ label = 411LLU; // continue to unroll stack
5614	5620	break;
5615	5621	}
5616		- case 412LLU: // return from reporttype to represult
	5622	+ case 413LLU: // return from reporttype to represult
5617	5623	{
5618	5624	uint64_t oldstack = (uint64_t )stack[0];
5619	5625	// copy mutable arguments back from call to reporttype

		@@ -5626,22 +5632,22 @@
5626	5632	stack = oldstack;
5627	5633	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5628	5634	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5629		- label = 408LLU; // case complete
	5635	+ label = 409LLU; // case complete
5630	5636	break;
5631	5637	}
5632		- case 410LLU: // copy-back deleter (switch)
	5638	+ case 411LLU: // copy-back deleter (switch)
5633	5639	{
5634	5640	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5635	5641	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5636		- label = 407LLU; // continue to unroll stack
	5642	+ label = 408LLU; // continue to unroll stack
5637	5643	break;
5638	5644	}
5639		- case 409LLU: // try next case
	5645	+ case 410LLU: // try next case
5640	5646	{
5641	5647	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5642	5648	exit(-1);
5643	5649	}
5644		- case 408LLU: // completed switch
	5650	+ case 409LLU: // completed switch
5645	5651	{
5646	5652	// return from represult
5647	5653	label = stack[base - 1];

		@@ -5648,7 +5654,7 @@
5648	5654	base = stack[base - 2];
5649	5655	break;
5650	5656	}
5651		- case 413LLU: // ~param
	5657	+ case 414LLU: // ~param
5652	5658	{
5653	5659	if(stack[base + 0]/variant-nr/ >= 1)
5654	5660	{

		@@ -5655,10 +5661,10 @@
5655	5661	fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5656	5662	exit(-1);
5657	5663	}
5658		- label = 413LLU + 1LLU + stack[base + 0]/variant-nr/;
	5664	+ label = 414LLU + 1LLU + stack[base + 0]/variant-nr/;
5659	5665	break;
5660	5666	}
5661		- case 413LLU + 1LLU + 0LLU: // ~param.param
	5667	+ case 414LLU + 1LLU + 0LLU: // ~param.param
5662	5668	{
5663	5669	// release element typeid
5664	5670	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5668,14 +5674,14 @@
5668	5674	newstack[0] = (uint64_t)stack; // backup stack location
5669	5675	newstack[1] = 1234567890;
5670	5676	newstack[2] = base;
5671		- newstack[3] = 415LLU;
	5677	+ newstack[3] = 416LLU;
5672	5678	stack = newstack;
5673	5679	// set stack-base & callee-address
5674	5680	base = 4/deloffset/;
5675		- label = 354LLU; // ~typeid
	5681	+ label = 355LLU; // ~typeid
5676	5682	break;
5677	5683	}
5678		- case 415LLU: // return from ~typeid to param
	5684	+ case 416LLU: // return from ~typeid to param
5679	5685	{
5680	5686	stack = (uint64_t *)stack[0];
5681	5687	// releasing toplevel container

		@@ -5688,7 +5694,7 @@
5688	5694	base = stack[base - 2];
5689	5695	break;
5690	5696	}
5691		- case 417LLU: // function copyparam failed
	5697	+ case 418LLU: // function copyparam failed
5692	5698	{
5693	5699	fprintf(stderr, "function copyparam failed\n");
5694	5700	label = stack[base - 3];

		@@ -5695,13 +5701,13 @@
5695	5701	base = stack[base - 2];
5696	5702	break;
5697	5703	}
5698		- case 416LLU: // copyparam
	5704	+ case 417LLU: // copyparam
5699	5705	{
5700	5706	//#define res0 0
5701	5707	//#define arg0 1
5702	5708	if(/param/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5703	5709	{
5704		- label = 419LLU; // jump to alternative
	5710	+ label = 420LLU; // jump to alternative
5705	5711	break;
5706	5712	}
5707	5713

		@@ -5710,57 +5716,57 @@
5710	5716
5711	5717	// case
5712	5718	// call copytypeid from copyparam
5713		- stack[base + 5LLU] = 421LLU/throw to this address/;
	5719	+ stack[base + 5LLU] = 422LLU/throw to this address/;
5714	5720	stack[base + 6LLU] = base;
5715		- stack[base + 7LLU] = 422LLU;
	5721	+ stack[base + 7LLU] = 423LLU;
5716	5722	// arguments for call to copytypeid
5717	5723	stack[base + 9LLU] = stack[base + 2]/origtypeid/;
5718	5724	// set stack-base & callee-address
5719	5725	base += 8LLU;
5720		- label = 357LLU; // copytypeid
	5726	+ label = 358LLU; // copytypeid
5721	5727	break;
5722	5728	}
5723		- case 421LLU: // copy-back deleter (copytypeid to copyparam)
	5729	+ case 422LLU: // copy-back deleter (copytypeid to copyparam)
5724	5730	{
5725	5731	fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
5726	5732	// copy mutable arguments back from call to copytypeid
5727		- label = 420LLU; // continue to roll stack
	5733	+ label = 421LLU; // continue to roll stack
5728	5734	break;
5729	5735	}
5730		- case 422LLU: // return from copytypeid to copyparam
	5736	+ case 423LLU: // return from copytypeid to copyparam
5731	5737	{
5732	5738	// copy mutable arguments back from call to copytypeid
5733	5739	// copy back results provided by call to copytypeid
5734	5740	stack[base + 4] = stack[base + 8LLU];
5735		- label = 424LLU; // skip deleter
	5741	+ label = 425LLU; // skip deleter
5736	5742	break;
5737	5743	}
5738		- case 423LLU: // deleter
	5744	+ case 424LLU: // deleter
5739	5745	{
5740	5746	// throw from copyparam
5741	5747	if(!stack[base + 5])
5742	5748	{
5743	5749	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
5745	5751	break;
5746	5752	}
5747	5753	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
5749	5755	break;
5750	5756	}
5751		- case 424LLU: // skipped deleter
	5757	+ case 425LLU: // skipped deleter
5752	5758	{
5753	5759	stack[base + 5] = stack[base + 3]/origmut/;
5754		- label = 426LLU; // skip deleter
	5760	+ label = 427LLU; // skip deleter
5755	5761	break;
5756	5762	}
5757		- case 425LLU: // deleter
	5763	+ case 426LLU: // deleter
5758	5764	{
5759	5765	// throw from copyparam
5760	5766	if(!stack[base + 0])
5761	5767	{
5762	5768	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
5764	5770	break;
5765	5771	}
5766	5772	fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");

		@@ -5770,28 +5776,28 @@
5770	5776	newstack[0] = (uint64_t)stack; // backup stack location
5771	5777	newstack[1] = 1234567890;
5772	5778	newstack[2] = base;
5773		- newstack[3] = 427LLU;
	5779	+ newstack[3] = 428LLU;
5774	5780	stack = newstack;
5775	5781	// set stack-base & callee-address
5776	5782	base = 4/deloffset/;
5777		- label = 413LLU; // ~param
	5783	+ label = 414LLU; // ~param
5778	5784	break;
5779	5785	}
5780		- case 427LLU: // return from ~param to copyparam
	5786	+ case 428LLU: // return from ~param to copyparam
5781	5787	{
5782	5788	stack = (uint64_t *)stack[0];
5783	5789	// releasing toplevel container
5784	5790	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5785	5791
5786		- label = 423LLU; // continue unrolling stack, delete next variable
	5792	+ label = 424LLU; // continue unrolling stack, delete next variable
5787	5793	break;
5788	5794	}
5789		- case 426LLU: // skipped deleter
	5795	+ case 427LLU: // skipped deleter
5790	5796	{
5791	5797	// construct param.param
5792	5798	if(!(stack[base + 0] = construct(2)))
5793	5799	{
5794		- label = 423LLU; // throw: begin to unroll stack
	5800	+ label = 424LLU; // throw: begin to unroll stack
5795	5801	break;
5796	5802	}
5797	5803

		@@ -5801,22 +5807,22 @@
5801	5807	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copymut*/;
5802	5808	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5803	5809	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5804		- label = 418LLU; // case complete
	5810	+ label = 419LLU; // case complete
5805	5811	break;
5806	5812	}
5807		- case 420LLU: // copy-back deleter (switch)
	5813	+ case 421LLU: // copy-back deleter (switch)
5808	5814	{
5809	5815	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5810	5816	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5811		- label = 417LLU; // continue to unroll stack
	5817	+ label = 418LLU; // continue to unroll stack
5812	5818	break;
5813	5819	}
5814		- case 419LLU: // try next case
	5820	+ case 420LLU: // try next case
5815	5821	{
5816	5822	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5817	5823	exit(-1);
5818	5824	}
5819		- case 418LLU: // completed switch
	5825	+ case 419LLU: // completed switch
5820	5826	{
5821	5827	// return from copyparam
5822	5828	label = stack[base - 1];

		@@ -5823,7 +5829,7 @@
5823	5829	base = stack[base - 2];
5824	5830	break;
5825	5831	}
5826		- case 429LLU: // function repparam failed
	5832	+ case 430LLU: // function repparam failed
5827	5833	{
5828	5834	fprintf(stderr, "function repparam failed\n");
5829	5835	label = stack[base - 3];

		@@ -5830,12 +5836,12 @@
5830	5836	base = stack[base - 2];
5831	5837	break;
5832	5838	}
5833		- case 428LLU: // repparam
	5839	+ case 429LLU: // repparam
5834	5840	{
5835	5841	//#define arg0 0
5836	5842	if(/param/0 != ((uint64_t )(stack[base + 0]/param*/))[0])
5837	5843	{
5838		- label = 431LLU; // jump to alternative
	5844	+ label = 432LLU; // jump to alternative
5839	5845	break;
5840	5846	}
5841	5847

		@@ -5845,61 +5851,61 @@
5845	5851	// case
5846	5852	if(!stack[base + 2]/mutable/)
5847	5853	{
5848		- label = 433LLU; // jump to alternative
	5854	+ label = 434LLU; // jump to alternative
5849	5855	break;
5850	5856	}
5851	5857
5852	5858	// consequent
5853	5859	fprintf(stderr, "%s", "mut ");
5854		- label = 434LLU; // consequent complete
	5860	+ label = 435LLU; // consequent complete
5855	5861	break;
5856	5862	}
5857		- case 433LLU: // alternative
	5863	+ case 434LLU: // alternative
5858	5864	{
5859		- label = 434LLU; // alternative complete
	5865	+ label = 435LLU; // alternative complete
5860	5866	break;
5861	5867	}
5862		- case 434LLU: // completed if-then-else
	5868	+ case 435LLU: // completed if-then-else
5863	5869	{
5864	5870	// call reportti from repparam
5865		- stack[base + 3LLU] = 435LLU/throw to this address/;
	5871	+ stack[base + 3LLU] = 436LLU/throw to this address/;
5866	5872	stack[base + 4LLU] = base;
5867		- stack[base + 5LLU] = 436LLU;
	5873	+ stack[base + 5LLU] = 437LLU;
5868	5874	// arguments for call to reportti
5869	5875	stack[base + 6LLU] = stack[base + 1]/typeid/;
5870	5876	// set stack-base & callee-address
5871	5877	base += 6LLU;
5872		- label = 369LLU; // reportti
	5878	+ label = 370LLU; // reportti
5873	5879	break;
5874	5880	}
5875		- case 435LLU: // copy-back deleter (reportti to repparam)
	5881	+ case 436LLU: // copy-back deleter (reportti to repparam)
5876	5882	{
5877	5883	fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
5878	5884	// copy mutable arguments back from call to reportti
5879		- label = 432LLU; // continue to roll stack
	5885	+ label = 433LLU; // continue to roll stack
5880	5886	break;
5881	5887	}
5882		- case 436LLU: // return from reportti to repparam
	5888	+ case 437LLU: // return from reportti to repparam
5883	5889	{
5884	5890	// copy mutable arguments back from call to reportti
5885	5891	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5886	5892	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5887		- label = 430LLU; // case complete
	5893	+ label = 431LLU; // case complete
5888	5894	break;
5889	5895	}
5890		- case 432LLU: // copy-back deleter (switch)
	5896	+ case 433LLU: // copy-back deleter (switch)
5891	5897	{
5892	5898	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5893	5899	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5894		- label = 429LLU; // continue to unroll stack
	5900	+ label = 430LLU; // continue to unroll stack
5895	5901	break;
5896	5902	}
5897		- case 431LLU: // try next case
	5903	+ case 432LLU: // try next case
5898	5904	{
5899	5905	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5900	5906	exit(-1);
5901	5907	}
5902		- case 430LLU: // completed switch
	5908	+ case 431LLU: // completed switch
5903	5909	{
5904	5910	// return from repparam
5905	5911	label = stack[base - 1];

		@@ -5906,7 +5912,7 @@
5906	5912	base = stack[base - 2];
5907	5913	break;
5908	5914	}
5909		- case 438LLU: // function lookparam failed
	5915	+ case 439LLU: // function lookparam failed
5910	5916	{
5911	5917	fprintf(stderr, "function lookparam failed\n");
5912	5918	label = stack[base - 3];

		@@ -5913,39 +5919,39 @@
5913	5919	base = stack[base - 2];
5914	5920	break;
5915	5921	}
5916		- case 437LLU: // lookparam
	5922	+ case 438LLU: // lookparam
5917	5923	{
5918	5924	//#define res0 0
5919	5925	//#define arg0 1
5920	5926	//#define arg1 2
5921		- label = 440LLU; // skip deleter
	5927	+ label = 441LLU; // skip deleter
5922	5928	break;
5923	5929	}
5924		- case 439LLU: // deleter
	5930	+ case 440LLU: // deleter
5925	5931	{
5926	5932	// throw from lookparam
5927	5933	if(!stack[base + 3])
5928	5934	{
5929	5935	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
5931	5937	break;
5932	5938	}
5933	5939	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
5935	5941	break;
5936	5942	}
5937		- case 440LLU: // skipped deleter
	5943	+ case 441LLU: // skipped deleter
5938	5944	{
5939	5945	stack[base + 3] = 0;
5940	5946	flippedassign(stack[base + 1]/params/, &stack[base + 4]);
5941		- label = 441LLU; // start to repeat
	5947	+ label = 442LLU; // start to repeat
5942	5948	break;
5943	5949	}
5944		- case 441LLU: // repeat from here
	5950	+ case 442LLU: // repeat from here
5945	5951	{
5946	5952	if(!stack[base + 4])
5947	5953	{
5948		- label = 442LLU; // break loop
	5954	+ label = 443LLU; // break loop
5949	5955	break;
5950	5956	}
5951	5957

		@@ -5955,19 +5961,19 @@
5955	5961	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
5956	5962	if(!stack[base + 3]/found/)
5957	5963	{
5958		- label = 443LLU; // jump to alternative
	5964	+ label = 445LLU; // jump to alternative
5959	5965	break;
5960	5966	}
5961	5967
5962	5968	// consequent
5963		- label = 444LLU; // consequent complete
	5969	+ label = 446LLU; // consequent complete
5964	5970	break;
5965	5971	}
5966		- case 443LLU: // alternative
	5972	+ case 445LLU: // alternative
5967	5973	{
5968	5974	if(/param/0 != ((uint64_t )(stack[base + 5]/param*/))[0])
5969	5975	{
5970		- label = 446LLU; // jump to alternative
	5976	+ label = 448LLU; // jump to alternative
5971	5977	break;
5972	5978	}
5973	5979

		@@ -5977,7 +5983,7 @@
5977	5983	// case
5978	5984	if(/typeid/0 != ((uint64_t )(stack[base + 7]/typeid*/))[0])
5979	5985	{
5980		- label = 449LLU; // jump to alternative
	5986	+ label = 451LLU; // jump to alternative
5981	5987	break;
5982	5988	}
5983	5989

		@@ -5986,9 +5992,9 @@
5986	5992
5987	5993	// case
5988	5994	// call equ from lookparam
5989		- stack[base + 11LLU] = 451LLU/throw to this address/;
	5995	+ stack[base + 11LLU] = 453LLU/throw to this address/;
5990	5996	stack[base + 12LLU] = base;
5991		- stack[base + 13LLU] = 452LLU;
	5997	+ stack[base + 13LLU] = 454LLU;
5992	5998	// arguments for call to equ
5993	5999	stack[base + 15LLU] = stack[base + 10]/id/;
5994	6000	stack[base + 16LLU] = stack[base + 2]/wanted/;

		@@ -5997,14 +6003,14 @@
5997	6003	label = 18446744073709551600LLU; // equ
5998	6004	break;
5999	6005	}
6000		- case 451LLU: // copy-back deleter (equ to lookparam)
	6006	+ case 453LLU: // copy-back deleter (equ to lookparam)
6001	6007	{
6002	6008	fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
6003	6009	// copy mutable arguments back from call to equ
6004		- label = 450LLU; // continue to roll stack
	6010	+ label = 452LLU; // continue to roll stack
6005	6011	break;
6006	6012	}
6007		- case 452LLU: // return from equ to lookparam
	6013	+ case 454LLU: // return from equ to lookparam
6008	6014	{
6009	6015	// copy mutable arguments back from call to equ
6010	6016	// copy back results provided by call to equ

		@@ -6011,70 +6017,76 @@
6011	6017	stack[base + 3] = stack[base + 14LLU];
6012	6018	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
6013	6019	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6014		- label = 448LLU; // case complete
	6020	+ label = 450LLU; // case complete
6015	6021	break;
6016	6022	}
6017		- case 450LLU: // copy-back deleter (switch)
	6023	+ case 452LLU: // copy-back deleter (switch)
6018	6024	{
6019	6025	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
6020	6026	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
6021		- label = 447LLU; // continue to unroll stack
	6027	+ label = 449LLU; // continue to unroll stack
6022	6028	break;
6023	6029	}
6024		- case 449LLU: // try next case
	6030	+ case 451LLU: // try next case
6025	6031	{
6026	6032	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6027	6033	exit(-1);
6028	6034	}
6029		- case 448LLU: // completed switch
	6035	+ case 450LLU: // completed switch
6030	6036	{
6031	6037	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
6032	6038	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6033		- label = 445LLU; // case complete
	6039	+ label = 447LLU; // case complete
6034	6040	break;
6035	6041	}
6036		- case 447LLU: // copy-back deleter (switch)
	6042	+ case 449LLU: // copy-back deleter (switch)
6037	6043	{
6038	6044	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
6039	6045	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
6040		- label = 439LLU; // continue to unroll stack
	6046	+ label = 444LLU; // continue to unroll stack
6041	6047	break;
6042	6048	}
6043		- case 446LLU: // try next case
	6049	+ case 448LLU: // try next case
6044	6050	{
6045	6051	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6046	6052	exit(-1);
6047	6053	}
6048		- case 445LLU: // completed switch
	6054	+ case 447LLU: // completed switch
6049	6055	{
6050		- label = 444LLU; // alternative complete
	6056	+ label = 446LLU; // alternative complete
6051	6057	break;
6052	6058	}
6053		- case 444LLU: // completed if-then-else
	6059	+ case 446LLU: // completed if-then-else
6054	6060	{
6055	6061	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
6056		- label = 441LLU; // repeat
	6062	+ label = 442LLU; // repeat
6057	6063	break;
6058	6064	}
6059		- case 442LLU: // loop finished
	6065	+ case 444LLU: // copy-back deleter for while next
6060	6066	{
6061		- label = 454LLU; // skip deleter
	6067	+ ((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
	6068	+ label = 440LLU; // continue to unroll stack
6062	6069	break;
6063	6070	}
6064		- case 453LLU: // deleter
	6071	+ case 443LLU: // loop finished
6065	6072	{
	6073	+ label = 456LLU; // skip deleter
	6074	+ break;
	6075	+ }
	6076	+ case 455LLU: // deleter
	6077	+ {
6066	6078	// throw from lookparam
6067	6079	if(!stack[base + 0])
6068	6080	{
6069	6081	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
6071	6083	break;
6072	6084	}
6073	6085	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
6075	6087	break;
6076	6088	}
6077		- case 454LLU: // skipped deleter
	6089	+ case 456LLU: // skipped deleter
6078	6090	{
6079	6091	stack[base + 0] = stack[base + 3]/found/;
6080	6092	// return from lookparam

		@@ -6082,7 +6094,7 @@
6082	6094	base = stack[base - 2];
6083	6095	break;
6084	6096	}
6085		- case 455LLU: // ~letdef
	6097	+ case 457LLU: // ~letdef
6086	6098	{
6087	6099	if(stack[base + 0]/variant-nr/ >= 1)
6088	6100	{

		@@ -6089,10 +6101,10 @@
6089	6101	fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
6090	6102	exit(-1);
6091	6103	}
6092		- label = 455LLU + 1LLU + stack[base + 0]/variant-nr/;
	6104	+ label = 457LLU + 1LLU + stack[base + 0]/variant-nr/;
6093	6105	break;
6094	6106	}
6095		- case 455LLU + 1LLU + 0LLU: // ~letdef.letdef
	6107	+ case 457LLU + 1LLU + 0LLU: // ~letdef.letdef
6096	6108	{
6097	6109	// release element type
6098	6110	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -6102,14 +6114,14 @@
6102	6114	newstack[0] = (uint64_t)stack; // backup stack location
6103	6115	newstack[1] = 1234567890;
6104	6116	newstack[2] = base;
6105		- newstack[3] = 457LLU;
	6117	+ newstack[3] = 459LLU;
6106	6118	stack = newstack;
6107	6119	// set stack-base & callee-address
6108	6120	base = 4/deloffset/;
6109		- label = 295LLU; // ~type
	6121	+ label = 296LLU; // ~type
6110	6122	break;
6111	6123	}
6112		- case 457LLU: // return from ~type to letdef
	6124	+ case 459LLU: // return from ~type to letdef
6113	6125	{
6114	6126	stack = (uint64_t *)stack[0];
6115	6127	// releasing toplevel container

		@@ -6125,7 +6137,7 @@
6125	6137	base = stack[base - 2];
6126	6138	break;
6127	6139	}
6128		- case 459LLU: // function mkletdummy failed
	6140	+ case 461LLU: // function mkletdummy failed
6129	6141	{
6130	6142	fprintf(stderr, "function mkletdummy failed\n");
6131	6143	label = stack[base - 3];

		@@ -6132,38 +6144,38 @@
6132	6144	base = stack[base - 2];
6133	6145	break;
6134	6146	}
6135		- case 458LLU: // mkletdummy
	6147	+ case 460LLU: // mkletdummy
6136	6148	{
6137	6149	//#define res0 0
6138		- label = 461LLU; // skip deleter
	6150	+ label = 463LLU; // skip deleter
6139	6151	break;
6140	6152	}
6141		- case 460LLU: // deleter
	6153	+ case 462LLU: // deleter
6142	6154	{
6143	6155	// throw from mkletdummy
6144	6156	if(!stack[base + 1])
6145	6157	{
6146	6158	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
6148	6160	break;
6149	6161	}
6150	6162	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
6152	6164	break;
6153	6165	}
6154		- case 461LLU: // skipped deleter
	6166	+ case 463LLU: // skipped deleter
6155	6167	{
6156	6168	stack[base + 1] = 78026663350239232;
6157		- label = 463LLU; // skip deleter
	6169	+ label = 465LLU; // skip deleter
6158	6170	break;
6159	6171	}
6160		- case 462LLU: // deleter
	6172	+ case 464LLU: // deleter
6161	6173	{
6162	6174	// throw from mkletdummy
6163	6175	if(!stack[base + 2])
6164	6176	{
6165	6177	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
6167	6179	break;
6168	6180	}
6169	6181	fprintf(stderr, "in function mkletdummy: unrolling stack, variable type \n");

		@@ -6173,28 +6185,28 @@
6173	6185	newstack[0] = (uint64_t)stack; // backup stack location
6174	6186	newstack[1] = 1234567890;
6175	6187	newstack[2] = base;
6176		- newstack[3] = 464LLU;
	6188	+ newstack[3] = 466LLU;
6177	6189	stack = newstack;
6178	6190	// set stack-base & callee-address
6179	6191	base = 4/deloffset/;
6180		- label = 295LLU; // ~type
	6192	+ label = 296LLU; // ~type
6181	6193	break;
6182	6194	}
6183		- case 464LLU: // return from ~type to mkletdummy
	6195	+ case 466LLU: // return from ~type to mkletdummy
6184	6196	{
6185	6197	stack = (uint64_t *)stack[0];
6186	6198	// releasing toplevel container
6187	6199	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 2] - sizeof(uint64_t) 4));
6188	6200
6189		- label = 460LLU; // continue unrolling stack, delete next variable
	6201	+ label = 462LLU; // continue unrolling stack, delete next variable
6190	6202	break;
6191	6203	}
6192		- case 463LLU: // skipped deleter
	6204	+ case 465LLU: // skipped deleter
6193	6205	{
6194	6206	// construct type.typename
6195	6207	if(!(stack[base + 2] = construct(1)))
6196	6208	{
6197		- label = 460LLU; // throw: begin to unroll stack
	6209	+ label = 462LLU; // throw: begin to unroll stack
6198	6210	break;
6199	6211	}
6200	6212

		@@ -6201,73 +6213,73 @@
6201	6213	// consequent
6202	6214	((uint64_t *)stack[base + 2])[0] = 0;
6203	6215	(((uint64_t *)(stack[base + 2]))[1][0]) = stack[base + 1]/newid*/;
6204		- label = 466LLU; // skip deleter
	6216	+ label = 468LLU; // skip deleter
6205	6217	break;
6206	6218	}
6207		- case 465LLU: // deleter
	6219	+ case 467LLU: // deleter
6208	6220	{
6209	6221	// throw from mkletdummy
6210	6222	if(!stack[base + 3])
6211	6223	{
6212	6224	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
6214	6226	break;
6215	6227	}
6216	6228	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
6218	6230	break;
6219	6231	}
6220		- case 466LLU: // skipped deleter
	6232	+ case 468LLU: // skipped deleter
6221	6233	{
6222	6234	stack[base + 3] = 0;
6223		- label = 468LLU; // skip deleter
	6235	+ label = 470LLU; // skip deleter
6224	6236	break;
6225	6237	}
6226		- case 467LLU: // deleter
	6238	+ case 469LLU: // deleter
6227	6239	{
6228	6240	// throw from mkletdummy
6229	6241	if(!stack[base + 4])
6230	6242	{
6231	6243	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
6233	6245	break;
6234	6246	}
6235	6247	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
6237	6249	break;
6238	6250	}
6239		- case 468LLU: // skipped deleter
	6251	+ case 470LLU: // skipped deleter
6240	6252	{
6241	6253	stack[base + 4] = 0;
6242		- label = 470LLU; // skip deleter
	6254	+ label = 472LLU; // skip deleter
6243	6255	break;
6244	6256	}
6245		- case 469LLU: // deleter
	6257	+ case 471LLU: // deleter
6246	6258	{
6247	6259	// throw from mkletdummy
6248	6260	if(!stack[base + 5])
6249	6261	{
6250	6262	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
6252	6264	break;
6253	6265	}
6254	6266	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
6256	6268	break;
6257	6269	}
6258		- case 470LLU: // skipped deleter
	6270	+ case 472LLU: // skipped deleter
6259	6271	{
6260	6272	stack[base + 5] = 0;
6261		- label = 472LLU; // skip deleter
	6273	+ label = 474LLU; // skip deleter
6262	6274	break;
6263	6275	}
6264		- case 471LLU: // deleter
	6276	+ case 473LLU: // deleter
6265	6277	{
6266	6278	// throw from mkletdummy
6267	6279	if(!stack[base + 0])
6268	6280	{
6269	6281	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
6271	6283	break;
6272	6284	}
6273	6285	fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");

		@@ -6277,28 +6289,28 @@
6277	6289	newstack[0] = (uint64_t)stack; // backup stack location
6278	6290	newstack[1] = 1234567890;
6279	6291	newstack[2] = base;
6280		- newstack[3] = 473LLU;
	6292	+ newstack[3] = 475LLU;
6281	6293	stack = newstack;
6282	6294	// set stack-base & callee-address
6283	6295	base = 4/deloffset/;
6284		- label = 455LLU; // ~letdef
	6296	+ label = 457LLU; // ~letdef
6285	6297	break;
6286	6298	}
6287		- case 473LLU: // return from ~letdef to mkletdummy
	6299	+ case 475LLU: // return from ~letdef to mkletdummy
6288	6300	{
6289	6301	stack = (uint64_t *)stack[0];
6290	6302	// releasing toplevel container
6291	6303	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6292	6304
6293		- label = 469LLU; // continue unrolling stack, delete next variable
	6305	+ label = 471LLU; // continue unrolling stack, delete next variable
6294	6306	break;
6295	6307	}
6296		- case 472LLU: // skipped deleter
	6308	+ case 474LLU: // skipped deleter
6297	6309	{
6298	6310	// construct letdef.letdef
6299	6311	if(!(stack[base + 0] = construct(5)))
6300	6312	{
6301		- label = 469LLU; // throw: begin to unroll stack
	6313	+ label = 471LLU; // throw: begin to unroll stack
6302	6314	break;
6303	6315	}
6304	6316

		@@ -6314,7 +6326,7 @@
6314	6326	base = stack[base - 2];
6315	6327	break;
6316	6328	}
6317		- case 475LLU: // function reportlet failed
	6329	+ case 477LLU: // function reportlet failed
6318	6330	{
6319	6331	fprintf(stderr, "function reportlet failed\n");
6320	6332	label = stack[base - 3];

		@@ -6321,12 +6333,12 @@
6321	6333	base = stack[base - 2];
6322	6334	break;
6323	6335	}
6324		- case 474LLU: // reportlet
	6336	+ case 476LLU: // reportlet
6325	6337	{
6326	6338	//#define arg0 0
6327	6339	if(/letdef/0 != ((uint64_t )(stack[base + 0]/letdef*/))[0])
6328	6340	{
6329		- label = 477LLU; // jump to alternative
	6341	+ label = 479LLU; // jump to alternative
6330	6342	break;
6331	6343	}
6332	6344

		@@ -6339,26 +6351,26 @@
6339	6351	// case
6340	6352	if(!stack[base + 4]/mutable/)
6341	6353	{
6342		- label = 479LLU; // jump to alternative
	6354	+ label = 481LLU; // jump to alternative
6343	6355	break;
6344	6356	}
6345	6357
6346	6358	// consequent
6347	6359	fprintf(stderr, "%s", "mut ");
6348		- label = 480LLU; // consequent complete
	6360	+ label = 482LLU; // consequent complete
6349	6361	break;
6350	6362	}
6351		- case 479LLU: // alternative
	6363	+ case 481LLU: // alternative
6352	6364	{
6353		- label = 480LLU; // alternative complete
	6365	+ label = 482LLU; // alternative complete
6354	6366	break;
6355	6367	}
6356		- case 480LLU: // completed if-then-else
	6368	+ case 482LLU: // completed if-then-else
6357	6369	{
6358	6370	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
6359	6371	if(!newstack)
6360	6372	{
6361		- label = 478LLU; // throw: begin to unroll stack
	6373	+ label = 480LLU; // throw: begin to unroll stack
6362	6374	break;
6363	6375	}
6364	6376

		@@ -6365,18 +6377,18 @@
6365	6377	newstack[10LLU] = 9876543210LLU; // overflow-marker
6366	6378	// call reporttype from reportlet
6367	6379	newstack[0] = (uint64_t)stack; // backup stack location
6368		- newstack[1] = 481LLU;
	6380	+ newstack[1] = 483LLU;
6369	6381	newstack[2] = base;
6370		- newstack[3] = 482LLU;
	6382	+ newstack[3] = 484LLU;
6371	6383	// arguments for call to reporttype
6372	6384	newstack[4LLU] = stack[base + 1]/type/;
6373	6385	stack = newstack;
6374	6386	// set stack-base & callee-address
6375	6387	base = 4/deloffset/;
6376		- label = 315LLU; // reporttype
	6388	+ label = 316LLU; // reporttype
6377	6389	break;
6378	6390	}
6379		- case 481LLU: // copy-back deleter (reporttype to reportlet)
	6391	+ case 483LLU: // copy-back deleter (reporttype to reportlet)
6380	6392	{
6381	6393	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
6382	6394	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6388,10 +6400,10 @@
6388	6400	}
6389	6401	Free(10LLU + 1, sizeof(uint64_t), stack);
6390	6402	stack = oldstack;
6391		- label = 478LLU; // continue to unroll stack
	6403	+ label = 480LLU; // continue to unroll stack
6392	6404	break;
6393	6405	}
6394		- case 482LLU: // return from reporttype to reportlet
	6406	+ case 484LLU: // return from reporttype to reportlet
6395	6407	{
6396	6408	uint64_t oldstack = (uint64_t )stack[0];
6397	6409	// copy mutable arguments back from call to reporttype

		@@ -6404,9 +6416,9 @@
6404	6416	stack = oldstack;
6405	6417	fprintf(stderr, "%s", " ");
6406	6418	// call reportid from reportlet
6407		- stack[base + 6LLU] = 483LLU/throw to this address/;
	6419	+ stack[base + 6LLU] = 485LLU/throw to this address/;
6408	6420	stack[base + 7LLU] = base;
6409		- stack[base + 8LLU] = 484LLU;
	6421	+ stack[base + 8LLU] = 486LLU;
6410	6422	// arguments for call to reportid
6411	6423	stack[base + 9LLU] = stack[base + 2]/id/;
6412	6424	// set stack-base & callee-address

		@@ -6414,21 +6426,21 @@
6414	6426	label = 18446744073709551586LLU; // reportid
6415	6427	break;
6416	6428	}
6417		- case 483LLU: // copy-back deleter (reportid to reportlet)
	6429	+ case 485LLU: // copy-back deleter (reportid to reportlet)
6418	6430	{
6419	6431	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
6420	6432	// copy mutable arguments back from call to reportid
6421		- label = 478LLU; // continue to roll stack
	6433	+ label = 480LLU; // continue to roll stack
6422	6434	break;
6423	6435	}
6424		- case 484LLU: // return from reportid to reportlet
	6436	+ case 486LLU: // return from reportid to reportlet
6425	6437	{
6426	6438	// copy mutable arguments back from call to reportid
6427	6439	fprintf(stderr, "%s", " ");
6428	6440	// call reportnr from reportlet
6429		- stack[base + 6LLU] = 485LLU/throw to this address/;
	6441	+ stack[base + 6LLU] = 487LLU/throw to this address/;
6430	6442	stack[base + 7LLU] = base;
6431		- stack[base + 8LLU] = 486LLU;
	6443	+ stack[base + 8LLU] = 488LLU;
6432	6444	// arguments for call to reportnr
6433	6445	stack[base + 9LLU] = stack[base + 3]/index/;
6434	6446	// set stack-base & callee-address

		@@ -6436,14 +6448,14 @@
6436	6448	label = 18446744073709551589LLU; // reportnr
6437	6449	break;
6438	6450	}
6439		- case 485LLU: // copy-back deleter (reportnr to reportlet)
	6451	+ case 487LLU: // copy-back deleter (reportnr to reportlet)
6440	6452	{
6441	6453	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
6442	6454	// copy mutable arguments back from call to reportnr
6443		- label = 478LLU; // continue to roll stack
	6455	+ label = 480LLU; // continue to roll stack
6444	6456	break;
6445	6457	}
6446		- case 486LLU: // return from reportnr to reportlet
	6458	+ case 488LLU: // return from reportnr to reportlet
6447	6459	{
6448	6460	// copy mutable arguments back from call to reportnr
6449	6461	((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];

		@@ -6451,10 +6463,10 @@
6451	6463	((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
6452	6464	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
6453	6465	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6454		- label = 476LLU; // case complete
	6466	+ label = 478LLU; // case complete
6455	6467	break;
6456	6468	}
6457		- case 478LLU: // copy-back deleter (switch)
	6469	+ case 480LLU: // copy-back deleter (switch)
6458	6470	{
6459	6471	((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
6460	6472	((uint64_t **)(stack[base + 0]))[1][3] = stack[base + 4];

		@@ -6461,15 +6473,15 @@
6461	6473	((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
6462	6474	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
6463	6475	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6464		- label = 475LLU; // continue to unroll stack
	6476	+ label = 477LLU; // continue to unroll stack
6465	6477	break;
6466	6478	}
6467		- case 477LLU: // try next case
	6479	+ case 479LLU: // try next case
6468	6480	{
6469	6481	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6470	6482	exit(-1);
6471	6483	}
6472		- case 476LLU: // completed switch
	6484	+ case 478LLU: // completed switch
6473	6485	{
6474	6486	// return from reportlet
6475	6487	label = stack[base - 1];

		@@ -6476,7 +6488,7 @@
6476	6488	base = stack[base - 2];
6477	6489	break;
6478	6490	}
6479		- case 488LLU: // function equletdef failed
	6491	+ case 490LLU: // function equletdef failed
6480	6492	{
6481	6493	fprintf(stderr, "function equletdef failed\n");
6482	6494	label = stack[base - 3];

		@@ -6483,7 +6495,7 @@
6483	6495	base = stack[base - 2];
6484	6496	break;
6485	6497	}
6486		- case 487LLU: // equletdef
	6498	+ case 489LLU: // equletdef
6487	6499	{
6488	6500	//#define res0 0
6489	6501	//#define arg0 1

		@@ -6490,7 +6502,7 @@
6490	6502	//#define arg1 2
6491	6503	if(/letdef/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
6492	6504	{
6493		- label = 490LLU; // jump to alternative
	6505	+ label = 492LLU; // jump to alternative
6494	6506	break;
6495	6507	}
6496	6508

		@@ -6502,7 +6514,7 @@
6502	6514
6503	6515	if(/letdef/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
6504	6516	{
6505		- label = 490LLU; // jump to alternative
	6517	+ label = 492LLU; // jump to alternative
6506	6518	break;
6507	6519	}
6508	6520

		@@ -6513,48 +6525,48 @@
6513	6525	/ysubstruct/stack[base + 12] = ((uint64_t *)(stack[base + 2]/y/))[1][4]/substruct*/;
6514	6526
6515	6527	// case
6516		- label = 493LLU; // skip deleter
	6528	+ label = 495LLU; // skip deleter
6517	6529	break;
6518	6530	}
6519		- case 492LLU: // deleter
	6531	+ case 494LLU: // deleter
6520	6532	{
6521	6533	// throw from equletdef
6522	6534	if(!stack[base + 13])
6523	6535	{
6524	6536	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
6526	6538	break;
6527	6539	}
6528	6540	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
6530	6542	break;
6531	6543	}
6532		- case 493LLU: // skipped deleter
	6544	+ case 495LLU: // skipped deleter
6533	6545	{
6534	6546	stack[base + 13] = 1;
6535		- label = 495LLU; // skip deleter
	6547	+ label = 497LLU; // skip deleter
6536	6548	break;
6537	6549	}
6538		- case 494LLU: // deleter
	6550	+ case 496LLU: // deleter
6539	6551	{
6540	6552	// throw from equletdef
6541	6553	if(!stack[base + 14])
6542	6554	{
6543	6555	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
6545	6557	break;
6546	6558	}
6547	6559	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
6549	6561	break;
6550	6562	}
6551		- case 495LLU: // skipped deleter
	6563	+ case 497LLU: // skipped deleter
6552	6564	{
6553	6565	stack[base + 14] = 0;
6554	6566	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6555	6567	if(!newstack)
6556	6568	{
6557		- label = 494LLU; // throw: begin to unroll stack
	6569	+ label = 496LLU; // throw: begin to unroll stack
6558	6570	break;
6559	6571	}
6560	6572

		@@ -6561,9 +6573,9 @@
6561	6573	newstack[15LLU] = 9876543210LLU; // overflow-marker
6562	6574	// call equtype from equletdef
6563	6575	newstack[0] = (uint64_t)stack; // backup stack location
6564		- newstack[1] = 496LLU;
	6576	+ newstack[1] = 498LLU;
6565	6577	newstack[2] = base;
6566		- newstack[3] = 497LLU;
	6578	+ newstack[3] = 499LLU;
6567	6579	// arguments for call to equtype
6568	6580	newstack[5LLU] = stack[base + 3]/xtype/;
6569	6581	newstack[6LLU] = stack[base + 8]/ytype/;

		@@ -6570,10 +6582,10 @@
6570	6582	stack = newstack;
6571	6583	// set stack-base & callee-address
6572	6584	base = 4/deloffset/;
6573		- label = 341LLU; // equtype
	6585	+ label = 342LLU; // equtype
6574	6586	break;
6575	6587	}
6576		- case 496LLU: // copy-back deleter (equtype to equletdef)
	6588	+ case 498LLU: // copy-back deleter (equtype to equletdef)
6577	6589	{
6578	6590	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
6579	6591	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6585,10 +6597,10 @@
6585	6597	}
6586	6598	Free(15LLU + 1, sizeof(uint64_t), stack);
6587	6599	stack = oldstack;
6588		- label = 494LLU; // continue to unroll stack
	6600	+ label = 496LLU; // continue to unroll stack
6589	6601	break;
6590	6602	}
6591		- case 497LLU: // return from equtype to equletdef
	6603	+ case 499LLU: // return from equtype to equletdef
6592	6604	{
6593	6605	uint64_t oldstack = (uint64_t )stack[0];
6594	6606	// copy mutable arguments back from call to equtype

		@@ -6602,9 +6614,9 @@
6602	6614	Free(15LLU + 1, sizeof(uint64_t), stack);
6603	6615	stack = oldstack;
6604	6616	// call and from equletdef
6605		- stack[base + 15LLU] = 498LLU/throw to this address/;
	6617	+ stack[base + 15LLU] = 500LLU/throw to this address/;
6606	6618	stack[base + 16LLU] = base;
6607		- stack[base + 17LLU] = 499LLU;
	6619	+ stack[base + 17LLU] = 501LLU;
6608	6620	// arguments for call to and
6609	6621	stack[base + 19LLU] = stack[base + 13]/result/;
6610	6622	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6613,22 +6625,22 @@
6613	6625	label = 18446744073709551613LLU; // and
6614	6626	break;
6615	6627	}
6616		- case 498LLU: // copy-back deleter (and to equletdef)
	6628	+ case 500LLU: // copy-back deleter (and to equletdef)
6617	6629	{
6618	6630	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6619	6631	// copy mutable arguments back from call to and
6620		- label = 494LLU; // continue to roll stack
	6632	+ label = 496LLU; // continue to roll stack
6621	6633	break;
6622	6634	}
6623		- case 499LLU: // return from and to equletdef
	6635	+ case 501LLU: // return from and to equletdef
6624	6636	{
6625	6637	// copy mutable arguments back from call to and
6626	6638	// copy back results provided by call to and
6627	6639	stack[base + 13] = stack[base + 18LLU];
6628	6640	// call equ from equletdef
6629		- stack[base + 15LLU] = 500LLU/throw to this address/;
	6641	+ stack[base + 15LLU] = 502LLU/throw to this address/;
6630	6642	stack[base + 16LLU] = base;
6631		- stack[base + 17LLU] = 501LLU;
	6643	+ stack[base + 17LLU] = 503LLU;
6632	6644	// arguments for call to equ
6633	6645	stack[base + 19LLU] = stack[base + 4]/xid/;
6634	6646	stack[base + 20LLU] = stack[base + 9]/yid/;

		@@ -6637,22 +6649,22 @@
6637	6649	label = 18446744073709551600LLU; // equ
6638	6650	break;
6639	6651	}
6640		- case 500LLU: // copy-back deleter (equ to equletdef)
	6652	+ case 502LLU: // copy-back deleter (equ to equletdef)
6641	6653	{
6642	6654	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6643	6655	// copy mutable arguments back from call to equ
6644		- label = 494LLU; // continue to roll stack
	6656	+ label = 496LLU; // continue to roll stack
6645	6657	break;
6646	6658	}
6647		- case 501LLU: // return from equ to equletdef
	6659	+ case 503LLU: // return from equ to equletdef
6648	6660	{
6649	6661	// copy mutable arguments back from call to equ
6650	6662	// copy back results provided by call to equ
6651	6663	stack[base + 14] = stack[base + 18LLU];
6652	6664	// call and from equletdef
6653		- stack[base + 15LLU] = 502LLU/throw to this address/;
	6665	+ stack[base + 15LLU] = 504LLU/throw to this address/;
6654	6666	stack[base + 16LLU] = base;
6655		- stack[base + 17LLU] = 503LLU;
	6667	+ stack[base + 17LLU] = 505LLU;
6656	6668	// arguments for call to and
6657	6669	stack[base + 19LLU] = stack[base + 13]/result/;
6658	6670	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6661,22 +6673,22 @@
6661	6673	label = 18446744073709551613LLU; // and
6662	6674	break;
6663	6675	}
6664		- case 502LLU: // copy-back deleter (and to equletdef)
	6676	+ case 504LLU: // copy-back deleter (and to equletdef)
6665	6677	{
6666	6678	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6667	6679	// copy mutable arguments back from call to and
6668		- label = 494LLU; // continue to roll stack
	6680	+ label = 496LLU; // continue to roll stack
6669	6681	break;
6670	6682	}
6671		- case 503LLU: // return from and to equletdef
	6683	+ case 505LLU: // return from and to equletdef
6672	6684	{
6673	6685	// copy mutable arguments back from call to and
6674	6686	// copy back results provided by call to and
6675	6687	stack[base + 13] = stack[base + 18LLU];
6676	6688	// call equ from equletdef
6677		- stack[base + 15LLU] = 504LLU/throw to this address/;
	6689	+ stack[base + 15LLU] = 506LLU/throw to this address/;
6678	6690	stack[base + 16LLU] = base;
6679		- stack[base + 17LLU] = 505LLU;
	6691	+ stack[base + 17LLU] = 507LLU;
6680	6692	// arguments for call to equ
6681	6693	stack[base + 19LLU] = stack[base + 5]/xindex/;
6682	6694	stack[base + 20LLU] = stack[base + 10]/yindex/;

		@@ -6685,22 +6697,22 @@
6685	6697	label = 18446744073709551600LLU; // equ
6686	6698	break;
6687	6699	}
6688		- case 504LLU: // copy-back deleter (equ to equletdef)
	6700	+ case 506LLU: // copy-back deleter (equ to equletdef)
6689	6701	{
6690	6702	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6691	6703	// copy mutable arguments back from call to equ
6692		- label = 494LLU; // continue to roll stack
	6704	+ label = 496LLU; // continue to roll stack
6693	6705	break;
6694	6706	}
6695		- case 505LLU: // return from equ to equletdef
	6707	+ case 507LLU: // return from equ to equletdef
6696	6708	{
6697	6709	// copy mutable arguments back from call to equ
6698	6710	// copy back results provided by call to equ
6699	6711	stack[base + 14] = stack[base + 18LLU];
6700	6712	// call and from equletdef
6701		- stack[base + 15LLU] = 506LLU/throw to this address/;
	6713	+ stack[base + 15LLU] = 508LLU/throw to this address/;
6702	6714	stack[base + 16LLU] = base;
6703		- stack[base + 17LLU] = 507LLU;
	6715	+ stack[base + 17LLU] = 509LLU;
6704	6716	// arguments for call to and
6705	6717	stack[base + 19LLU] = stack[base + 13]/result/;
6706	6718	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6709,22 +6721,22 @@
6709	6721	label = 18446744073709551613LLU; // and
6710	6722	break;
6711	6723	}
6712		- case 506LLU: // copy-back deleter (and to equletdef)
	6724	+ case 508LLU: // copy-back deleter (and to equletdef)
6713	6725	{
6714	6726	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6715	6727	// copy mutable arguments back from call to and
6716		- label = 494LLU; // continue to roll stack
	6728	+ label = 496LLU; // continue to roll stack
6717	6729	break;
6718	6730	}
6719		- case 507LLU: // return from and to equletdef
	6731	+ case 509LLU: // return from and to equletdef
6720	6732	{
6721	6733	// copy mutable arguments back from call to and
6722	6734	// copy back results provided by call to and
6723	6735	stack[base + 13] = stack[base + 18LLU];
6724	6736	// call equ from equletdef
6725		- stack[base + 15LLU] = 508LLU/throw to this address/;
	6737	+ stack[base + 15LLU] = 510LLU/throw to this address/;
6726	6738	stack[base + 16LLU] = base;
6727		- stack[base + 17LLU] = 509LLU;
	6739	+ stack[base + 17LLU] = 511LLU;
6728	6740	// arguments for call to equ
6729	6741	stack[base + 19LLU] = stack[base + 6]/xmutable/;
6730	6742	stack[base + 20LLU] = stack[base + 11]/ymutable/;

		@@ -6733,22 +6745,22 @@
6733	6745	label = 18446744073709551600LLU; // equ
6734	6746	break;
6735	6747	}
6736		- case 508LLU: // copy-back deleter (equ to equletdef)
	6748	+ case 510LLU: // copy-back deleter (equ to equletdef)
6737	6749	{
6738	6750	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6739	6751	// copy mutable arguments back from call to equ
6740		- label = 494LLU; // continue to roll stack
	6752	+ label = 496LLU; // continue to roll stack
6741	6753	break;
6742	6754	}
6743		- case 509LLU: // return from equ to equletdef
	6755	+ case 511LLU: // return from equ to equletdef
6744	6756	{
6745	6757	// copy mutable arguments back from call to equ
6746	6758	// copy back results provided by call to equ
6747	6759	stack[base + 14] = stack[base + 18LLU];
6748	6760	// call and from equletdef
6749		- stack[base + 15LLU] = 510LLU/throw to this address/;
	6761	+ stack[base + 15LLU] = 512LLU/throw to this address/;
6750	6762	stack[base + 16LLU] = base;
6751		- stack[base + 17LLU] = 511LLU;
	6763	+ stack[base + 17LLU] = 513LLU;
6752	6764	// arguments for call to and
6753	6765	stack[base + 19LLU] = stack[base + 13]/result/;
6754	6766	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6757,22 +6769,22 @@
6757	6769	label = 18446744073709551613LLU; // and
6758	6770	break;
6759	6771	}
6760		- case 510LLU: // copy-back deleter (and to equletdef)
	6772	+ case 512LLU: // copy-back deleter (and to equletdef)
6761	6773	{
6762	6774	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6763	6775	// copy mutable arguments back from call to and
6764		- label = 494LLU; // continue to roll stack
	6776	+ label = 496LLU; // continue to roll stack
6765	6777	break;
6766	6778	}
6767		- case 511LLU: // return from and to equletdef
	6779	+ case 513LLU: // return from and to equletdef
6768	6780	{
6769	6781	// copy mutable arguments back from call to and
6770	6782	// copy back results provided by call to and
6771	6783	stack[base + 13] = stack[base + 18LLU];
6772	6784	// call equ from equletdef
6773		- stack[base + 15LLU] = 512LLU/throw to this address/;
	6785	+ stack[base + 15LLU] = 514LLU/throw to this address/;
6774	6786	stack[base + 16LLU] = base;
6775		- stack[base + 17LLU] = 513LLU;
	6787	+ stack[base + 17LLU] = 515LLU;
6776	6788	// arguments for call to equ
6777	6789	stack[base + 19LLU] = stack[base + 7]/xsubstruct/;
6778	6790	stack[base + 20LLU] = stack[base + 12]/ysubstruct/;

		@@ -6781,22 +6793,22 @@
6781	6793	label = 18446744073709551600LLU; // equ
6782	6794	break;
6783	6795	}
6784		- case 512LLU: // copy-back deleter (equ to equletdef)
	6796	+ case 514LLU: // copy-back deleter (equ to equletdef)
6785	6797	{
6786	6798	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6787	6799	// copy mutable arguments back from call to equ
6788		- label = 494LLU; // continue to roll stack
	6800	+ label = 496LLU; // continue to roll stack
6789	6801	break;
6790	6802	}
6791		- case 513LLU: // return from equ to equletdef
	6803	+ case 515LLU: // return from equ to equletdef
6792	6804	{
6793	6805	// copy mutable arguments back from call to equ
6794	6806	// copy back results provided by call to equ
6795	6807	stack[base + 14] = stack[base + 18LLU];
6796	6808	// call and from equletdef
6797		- stack[base + 15LLU] = 514LLU/throw to this address/;
	6809	+ stack[base + 15LLU] = 516LLU/throw to this address/;
6798	6810	stack[base + 16LLU] = base;
6799		- stack[base + 17LLU] = 515LLU;
	6811	+ stack[base + 17LLU] = 517LLU;
6800	6812	// arguments for call to and
6801	6813	stack[base + 19LLU] = stack[base + 13]/result/;
6802	6814	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6805,35 +6817,35 @@
6805	6817	label = 18446744073709551613LLU; // and
6806	6818	break;
6807	6819	}
6808		- case 514LLU: // copy-back deleter (and to equletdef)
	6820	+ case 516LLU: // copy-back deleter (and to equletdef)
6809	6821	{
6810	6822	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6811	6823	// copy mutable arguments back from call to and
6812		- label = 494LLU; // continue to roll stack
	6824	+ label = 496LLU; // continue to roll stack
6813	6825	break;
6814	6826	}
6815		- case 515LLU: // return from and to equletdef
	6827	+ case 517LLU: // return from and to equletdef
6816	6828	{
6817	6829	// copy mutable arguments back from call to and
6818	6830	// copy back results provided by call to and
6819	6831	stack[base + 13] = stack[base + 18LLU];
6820		- label = 517LLU; // skip deleter
	6832	+ label = 519LLU; // skip deleter
6821	6833	break;
6822	6834	}
6823		- case 516LLU: // deleter
	6835	+ case 518LLU: // deleter
6824	6836	{
6825	6837	// throw from equletdef
6826	6838	if(!stack[base + 0])
6827	6839	{
6828	6840	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
6830	6842	break;
6831	6843	}
6832	6844	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
6834	6846	break;
6835	6847	}
6836		- case 517LLU: // skipped deleter
	6848	+ case 519LLU: // skipped deleter
6837	6849	{
6838	6850	stack[base + 0] = stack[base + 13]/result/;
6839	6851	((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];

		@@ -6846,10 +6858,10 @@
6846	6858	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
6847	6859	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
6848	6860	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6849		- label = 489LLU; // case complete
	6861	+ label = 491LLU; // case complete
6850	6862	break;
6851	6863	}
6852		- case 491LLU: // copy-back deleter (switch)
	6864	+ case 493LLU: // copy-back deleter (switch)
6853	6865	{
6854	6866	((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
6855	6867	((uint64_t **)(stack[base + 2]))[1][3] = stack[base + 11];

		@@ -6861,15 +6873,15 @@
6861	6873	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
6862	6874	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
6863	6875	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6864		- label = 488LLU; // continue to unroll stack
	6876	+ label = 490LLU; // continue to unroll stack
6865	6877	break;
6866	6878	}
6867		- case 490LLU: // try next case
	6879	+ case 492LLU: // try next case
6868	6880	{
6869	6881	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6870	6882	exit(-1);
6871	6883	}
6872		- case 489LLU: // completed switch
	6884	+ case 491LLU: // completed switch
6873	6885	{
6874	6886	// return from equletdef
6875	6887	label = stack[base - 1];

		@@ -6876,7 +6888,7 @@
6876	6888	base = stack[base - 2];
6877	6889	break;
6878	6890	}
6879		- case 519LLU: // function copyletdef failed
	6891	+ case 521LLU: // function copyletdef failed
6880	6892	{
6881	6893	fprintf(stderr, "function copyletdef failed\n");
6882	6894	label = stack[base - 3];

		@@ -6883,13 +6895,13 @@
6883	6895	base = stack[base - 2];
6884	6896	break;
6885	6897	}
6886		- case 518LLU: // copyletdef
	6898	+ case 520LLU: // copyletdef
6887	6899	{
6888	6900	//#define res0 0
6889	6901	//#define arg0 1
6890	6902	if(/letdef/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
6891	6903	{
6892		- label = 521LLU; // jump to alternative
	6904	+ label = 523LLU; // jump to alternative
6893	6905	break;
6894	6906	}
6895	6907

		@@ -6903,7 +6915,7 @@
6903	6915	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6904	6916	if(!newstack)
6905	6917	{
6906		- label = 522LLU; // throw: begin to unroll stack
	6918	+ label = 524LLU; // throw: begin to unroll stack
6907	6919	break;
6908	6920	}
6909	6921

		@@ -6910,18 +6922,18 @@
6910	6922	newstack[15LLU] = 9876543210LLU; // overflow-marker
6911	6923	// call copytype from copyletdef
6912	6924	newstack[0] = (uint64_t)stack; // backup stack location
6913		- newstack[1] = 523LLU;
	6925	+ newstack[1] = 525LLU;
6914	6926	newstack[2] = base;
6915		- newstack[3] = 524LLU;
	6927	+ newstack[3] = 526LLU;
6916	6928	// arguments for call to copytype
6917	6929	newstack[5LLU] = stack[base + 2]/type/;
6918	6930	stack = newstack;
6919	6931	// set stack-base & callee-address
6920	6932	base = 4/deloffset/;
6921		- label = 326LLU; // copytype
	6933	+ label = 327LLU; // copytype
6922	6934	break;
6923	6935	}
6924		- case 523LLU: // copy-back deleter (copytype to copyletdef)
	6936	+ case 525LLU: // copy-back deleter (copytype to copyletdef)
6925	6937	{
6926	6938	fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
6927	6939	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6933,10 +6945,10 @@
6933	6945	}
6934	6946	Free(15LLU + 1, sizeof(uint64_t), stack);
6935	6947	stack = oldstack;
6936		- label = 522LLU; // continue to unroll stack
	6948	+ label = 524LLU; // continue to unroll stack
6937	6949	break;
6938	6950	}
6939		- case 524LLU: // return from copytype to copyletdef
	6951	+ case 526LLU: // return from copytype to copyletdef
6940	6952	{
6941	6953	uint64_t oldstack = (uint64_t )stack[0];
6942	6954	// copy mutable arguments back from call to copytype

		@@ -6949,16 +6961,16 @@
6949	6961	}
6950	6962	Free(15LLU + 1, sizeof(uint64_t), stack);
6951	6963	stack = oldstack;
6952		- label = 526LLU; // skip deleter
	6964	+ label = 528LLU; // skip deleter
6953	6965	break;
6954	6966	}
6955		- case 525LLU: // deleter
	6967	+ case 527LLU: // deleter
6956	6968	{
6957	6969	// throw from copyletdef
6958	6970	if(!stack[base + 0])
6959	6971	{
6960	6972	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
6962	6974	break;
6963	6975	}
6964	6976	fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");

		@@ -6968,28 +6980,28 @@
6968	6980	newstack[0] = (uint64_t)stack; // backup stack location
6969	6981	newstack[1] = 1234567890;
6970	6982	newstack[2] = base;
6971		- newstack[3] = 527LLU;
	6983	+ newstack[3] = 529LLU;
6972	6984	stack = newstack;
6973	6985	// set stack-base & callee-address
6974	6986	base = 4/deloffset/;
6975		- label = 455LLU; // ~letdef
	6987	+ label = 457LLU; // ~letdef
6976	6988	break;
6977	6989	}
6978		- case 527LLU: // return from ~letdef to copyletdef
	6990	+ case 529LLU: // return from ~letdef to copyletdef
6979	6991	{
6980	6992	stack = (uint64_t *)stack[0];
6981	6993	// releasing toplevel container
6982	6994	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6983	6995
6984		- label = 522LLU; // continue unrolling stack, delete next variable
	6996	+ label = 524LLU; // continue unrolling stack, delete next variable
6985	6997	break;
6986	6998	}
6987		- case 526LLU: // skipped deleter
	6999	+ case 528LLU: // skipped deleter
6988	7000	{
6989	7001	// construct letdef.letdef
6990	7002	if(!(stack[base + 0] = construct(5)))
6991	7003	{
6992		- label = 522LLU; // throw: begin to unroll stack
	7004	+ label = 524LLU; // throw: begin to unroll stack
6993	7005	break;
6994	7006	}
6995	7007

		@@ -7005,10 +7017,10 @@
7005	7017	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
7006	7018	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7007	7019	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7008		- label = 520LLU; // case complete
	7020	+ label = 522LLU; // case complete
7009	7021	break;
7010	7022	}
7011		- case 522LLU: // copy-back deleter (switch)
	7023	+ case 524LLU: // copy-back deleter (switch)
7012	7024	{
7013	7025	((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
7014	7026	((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 5];

		@@ -7015,15 +7027,15 @@
7015	7027	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
7016	7028	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7017	7029	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7018		- label = 519LLU; // continue to unroll stack
	7030	+ label = 521LLU; // continue to unroll stack
7019	7031	break;
7020	7032	}
7021		- case 521LLU: // try next case
	7033	+ case 523LLU: // try next case
7022	7034	{
7023	7035	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7024	7036	exit(-1);
7025	7037	}
7026		- case 520LLU: // completed switch
	7038	+ case 522LLU: // completed switch
7027	7039	{
7028	7040	// return from copyletdef
7029	7041	label = stack[base - 1];

		@@ -7030,7 +7042,7 @@
7030	7042	base = stack[base - 2];
7031	7043	break;
7032	7044	}
7033		- case 528LLU: // ~scope
	7045	+ case 530LLU: // ~scope
7034	7046	{
7035	7047	if(stack[base + 0]/variant-nr/ >= 1)
7036	7048	{

		@@ -7037,23 +7049,23 @@
7037	7049	fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
7038	7050	exit(-1);
7039	7051	}
7040		- label = 528LLU + 1LLU + stack[base + 0]/variant-nr/;
	7052	+ label = 530LLU + 1LLU + stack[base + 0]/variant-nr/;
7041	7053	break;
7042	7054	}
7043		- case 528LLU + 1LLU + 0LLU: // ~scope.scope
	7055	+ case 530LLU + 1LLU + 0LLU: // ~scope.scope
7044	7056	{
7045	7057	// release element deleteaddr
7046	7058	// release element letdefs
7047	7059	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[1/element-nr*/];
7048	7060	// delete list
7049		- label = 530LLU; // start to repeat
	7061	+ label = 532LLU; // start to repeat
7050	7062	break;
7051	7063	}
7052		- case 530LLU: // repeat from here
	7064	+ case 532LLU: // repeat from here
7053	7065	{
7054	7066	if(!stack[base + 0])
7055	7067	{
7056		- label = 531LLU; // break loop
	7068	+ label = 533LLU; // break loop
7057	7069	break;
7058	7070	}
7059	7071

		@@ -7064,14 +7076,14 @@
7064	7076	newstack[0] = (uint64_t)stack; // backup stack location
7065	7077	newstack[1] = 1234567890;
7066	7078	newstack[2] = base;
7067		- newstack[3] = 532LLU;
	7079	+ newstack[3] = 534LLU;
7068	7080	stack = newstack;
7069	7081	// set stack-base & callee-address
7070	7082	base = 4/deloffset/;
7071		- label = 455LLU; // ~letdef
	7083	+ label = 457LLU; // ~letdef
7072	7084	break;
7073	7085	}
7074		- case 532LLU: // return from ~letdef to scope
	7086	+ case 534LLU: // return from ~letdef to scope
7075	7087	{
7076	7088	stack = (uint64_t *)stack[0];
7077	7089	// releasing toplevel container

		@@ -7082,10 +7094,10 @@
7082	7094	stack[base + 0] = (uint64_t)list->next;
7083	7095	Free(1, sizeof(struct listnode), list);
7084	7096	}
7085		- label = 530LLU; // repeat
	7097	+ label = 532LLU; // repeat
7086	7098	break;
7087	7099	}
7088		- case 531LLU: // loop finished
	7100	+ case 533LLU: // loop finished
7089	7101	{
7090	7102	// release variant container
7091	7103	Free(2, sizeof(uint64_t), ((uint64_t )stack[base + 1]/variant*/));

		@@ -7093,7 +7105,7 @@
7093	7105	base = stack[base - 2];
7094	7106	break;
7095	7107	}
7096		- case 534LLU: // function emptyscope failed
	7108	+ case 536LLU: // function emptyscope failed
7097	7109	{
7098	7110	fprintf(stderr, "function emptyscope failed\n");
7099	7111	label = stack[base - 3];

		@@ -7100,50 +7112,50 @@
7100	7112	base = stack[base - 2];
7101	7113	break;
7102	7114	}
7103		- case 533LLU: // emptyscope
	7115	+ case 535LLU: // emptyscope
7104	7116	{
7105	7117	//#define res0 0
7106		- label = 536LLU; // skip deleter
	7118	+ label = 538LLU; // skip deleter
7107	7119	break;
7108	7120	}
7109		- case 535LLU: // deleter
	7121	+ case 537LLU: // deleter
7110	7122	{
7111	7123	// throw from emptyscope
7112	7124	if(!stack[base + 1])
7113	7125	{
7114	7126	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
7116	7128	break;
7117	7129	}
7118	7130	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
7120	7132	break;
7121	7133	}
7122		- case 536LLU: // skipped deleter
	7134	+ case 538LLU: // skipped deleter
7123	7135	{
7124	7136	stack[base + 1] = 1234567890;
7125		- label = 538LLU; // skip deleter
	7137	+ label = 540LLU; // skip deleter
7126	7138	break;
7127	7139	}
7128		- case 537LLU: // deleter
	7140	+ case 539LLU: // deleter
7129	7141	{
7130	7142	// throw from emptyscope
7131	7143	if(!stack[base + 2])
7132	7144	{
7133	7145	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
7135	7147	break;
7136	7148	}
7137	7149	fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] \n");
7138	7150	// delete list
7139		- label = 539LLU; // start to repeat
	7151	+ label = 541LLU; // start to repeat
7140	7152	break;
7141	7153	}
7142		- case 539LLU: // repeat from here
	7154	+ case 541LLU: // repeat from here
7143	7155	{
7144	7156	if(!stack[base + 2])
7145	7157	{
7146		- label = 540LLU; // break loop
	7158	+ label = 542LLU; // break loop
7147	7159	break;
7148	7160	}
7149	7161

		@@ -7154,14 +7166,14 @@
7154	7166	newstack[0] = (uint64_t)stack; // backup stack location
7155	7167	newstack[1] = 1234567890;
7156	7168	newstack[2] = base;
7157		- newstack[3] = 541LLU;
	7169	+ newstack[3] = 543LLU;
7158	7170	stack = newstack;
7159	7171	// set stack-base & callee-address
7160	7172	base = 4/deloffset/;
7161		- label = 455LLU; // ~letdef
	7173	+ label = 457LLU; // ~letdef
7162	7174	break;
7163	7175	}
7164		- case 541LLU: // return from ~letdef to emptyscope
	7176	+ case 543LLU: // return from ~letdef to emptyscope
7165	7177	{
7166	7178	stack = (uint64_t *)stack[0];
7167	7179	// releasing toplevel container

		@@ -7172,27 +7184,27 @@
7172	7184	stack[base + 2] = (uint64_t)list->next;
7173	7185	Free(1, sizeof(struct listnode), list);
7174	7186	}
7175		- label = 539LLU; // repeat
	7187	+ label = 541LLU; // repeat
7176	7188	break;
7177	7189	}
7178		- case 540LLU: // loop finished
	7190	+ case 542LLU: // loop finished
7179	7191	{
7180		- label = 535LLU; // continue unrolling stack, delete next variable
	7192	+ label = 537LLU; // continue unrolling stack, delete next variable
7181	7193	break;
7182	7194	}
7183		- case 538LLU: // skipped deleter
	7195	+ case 540LLU: // skipped deleter
7184	7196	{
7185	7197	stack[base + 2] = 0;
7186		- label = 543LLU; // skip deleter
	7198	+ label = 545LLU; // skip deleter
7187	7199	break;
7188	7200	}
7189		- case 542LLU: // deleter
	7201	+ case 544LLU: // deleter
7190	7202	{
7191	7203	// throw from emptyscope
7192	7204	if(!stack[base + 0])
7193	7205	{
7194	7206	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
7196	7208	break;
7197	7209	}
7198	7210	fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");

		@@ -7202,28 +7214,28 @@
7202	7214	newstack[0] = (uint64_t)stack; // backup stack location
7203	7215	newstack[1] = 1234567890;
7204	7216	newstack[2] = base;
7205		- newstack[3] = 544LLU;
	7217	+ newstack[3] = 546LLU;
7206	7218	stack = newstack;
7207	7219	// set stack-base & callee-address
7208	7220	base = 4/deloffset/;
7209		- label = 528LLU; // ~scope
	7221	+ label = 530LLU; // ~scope
7210	7222	break;
7211	7223	}
7212		- case 544LLU: // return from ~scope to emptyscope
	7224	+ case 546LLU: // return from ~scope to emptyscope
7213	7225	{
7214	7226	stack = (uint64_t *)stack[0];
7215	7227	// releasing toplevel container
7216	7228	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7217	7229
7218		- label = 537LLU; // continue unrolling stack, delete next variable
	7230	+ label = 539LLU; // continue unrolling stack, delete next variable
7219	7231	break;
7220	7232	}
7221		- case 543LLU: // skipped deleter
	7233	+ case 545LLU: // skipped deleter
7222	7234	{
7223	7235	// construct scope.scope
7224	7236	if(!(stack[base + 0] = construct(2)))
7225	7237	{
7226		- label = 537LLU; // throw: begin to unroll stack
	7238	+ label = 539LLU; // throw: begin to unroll stack
7227	7239	break;
7228	7240	}
7229	7241

		@@ -7236,7 +7248,7 @@
7236	7248	base = stack[base - 2];
7237	7249	break;
7238	7250	}
7239		- case 546LLU: // function chainscope failed
	7251	+ case 548LLU: // function chainscope failed
7240	7252	{
7241	7253	fprintf(stderr, "function chainscope failed\n");
7242	7254	label = stack[base - 3];

		@@ -7243,32 +7255,32 @@
7243	7255	base = stack[base - 2];
7244	7256	break;
7245	7257	}
7246		- case 545LLU: // chainscope
	7258	+ case 547LLU: // chainscope
7247	7259	{
7248	7260	//#define res0 0
7249	7261	//#define arg0 1
7250		- label = 548LLU; // skip deleter
	7262	+ label = 550LLU; // skip deleter
7251	7263	break;
7252	7264	}
7253		- case 547LLU: // deleter
	7265	+ case 549LLU: // deleter
7254	7266	{
7255	7267	// throw from chainscope
7256	7268	if(!stack[base + 2])
7257	7269	{
7258	7270	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
7260	7272	break;
7261	7273	}
7262	7274	fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] \n");
7263	7275	// delete list
7264		- label = 549LLU; // start to repeat
	7276	+ label = 551LLU; // start to repeat
7265	7277	break;
7266	7278	}
7267		- case 549LLU: // repeat from here
	7279	+ case 551LLU: // repeat from here
7268	7280	{
7269	7281	if(!stack[base + 2])
7270	7282	{
7271		- label = 550LLU; // break loop
	7283	+ label = 552LLU; // break loop
7272	7284	break;
7273	7285	}
7274	7286

		@@ -7279,14 +7291,14 @@
7279	7291	newstack[0] = (uint64_t)stack; // backup stack location
7280	7292	newstack[1] = 1234567890;
7281	7293	newstack[2] = base;
7282		- newstack[3] = 551LLU;
	7294	+ newstack[3] = 553LLU;
7283	7295	stack = newstack;
7284	7296	// set stack-base & callee-address
7285	7297	base = 4/deloffset/;
7286		- label = 455LLU; // ~letdef
	7298	+ label = 457LLU; // ~letdef
7287	7299	break;
7288	7300	}
7289		- case 551LLU: // return from ~letdef to chainscope
	7301	+ case 553LLU: // return from ~letdef to chainscope
7290	7302	{
7291	7303	stack = (uint64_t *)stack[0];
7292	7304	// releasing toplevel container

		@@ -7297,27 +7309,27 @@
7297	7309	stack[base + 2] = (uint64_t)list->next;
7298	7310	Free(1, sizeof(struct listnode), list);
7299	7311	}
7300		- label = 549LLU; // repeat
	7312	+ label = 551LLU; // repeat
7301	7313	break;
7302	7314	}
7303		- case 550LLU: // loop finished
	7315	+ case 552LLU: // loop finished
7304	7316	{
7305		- label = 546LLU; // continue unrolling stack, delete next variable
	7317	+ label = 548LLU; // continue unrolling stack, delete next variable
7306	7318	break;
7307	7319	}
7308		- case 548LLU: // skipped deleter
	7320	+ case 550LLU: // skipped deleter
7309	7321	{
7310	7322	stack[base + 2] = 0;
7311		- label = 553LLU; // skip deleter
	7323	+ label = 555LLU; // skip deleter
7312	7324	break;
7313	7325	}
7314		- case 552LLU: // deleter
	7326	+ case 554LLU: // deleter
7315	7327	{
7316	7328	// throw from chainscope
7317	7329	if(!stack[base + 0])
7318	7330	{
7319	7331	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
7321	7333	break;
7322	7334	}
7323	7335	fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");

		@@ -7327,28 +7339,28 @@
7327	7339	newstack[0] = (uint64_t)stack; // backup stack location
7328	7340	newstack[1] = 1234567890;
7329	7341	newstack[2] = base;
7330		- newstack[3] = 554LLU;
	7342	+ newstack[3] = 556LLU;
7331	7343	stack = newstack;
7332	7344	// set stack-base & callee-address
7333	7345	base = 4/deloffset/;
7334		- label = 528LLU; // ~scope
	7346	+ label = 530LLU; // ~scope
7335	7347	break;
7336	7348	}
7337		- case 554LLU: // return from ~scope to chainscope
	7349	+ case 556LLU: // return from ~scope to chainscope
7338	7350	{
7339	7351	stack = (uint64_t *)stack[0];
7340	7352	// releasing toplevel container
7341	7353	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7342	7354
7343		- label = 547LLU; // continue unrolling stack, delete next variable
	7355	+ label = 549LLU; // continue unrolling stack, delete next variable
7344	7356	break;
7345	7357	}
7346		- case 553LLU: // skipped deleter
	7358	+ case 555LLU: // skipped deleter
7347	7359	{
7348	7360	// construct scope.scope
7349	7361	if(!(stack[base + 0] = construct(2)))
7350	7362	{
7351		- label = 547LLU; // throw: begin to unroll stack
	7363	+ label = 549LLU; // throw: begin to unroll stack
7352	7364	break;
7353	7365	}
7354	7366

		@@ -7361,7 +7373,7 @@
7361	7373	base = stack[base - 2];
7362	7374	break;
7363	7375	}
7364		- case 556LLU: // function linkscope failed
	7376	+ case 558LLU: // function linkscope failed
7365	7377	{
7366	7378	fprintf(stderr, "function linkscope failed\n");
7367	7379	label = stack[base - 3];

		@@ -7368,13 +7380,13 @@
7368	7380	base = stack[base - 2];
7369	7381	break;
7370	7382	}
7371		- case 555LLU: // linkscope
	7383	+ case 557LLU: // linkscope
7372	7384	{
7373	7385	//#define res0 0
7374	7386	//#define arg0 1
7375	7387	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7376	7388	{
7377		- label = 558LLU; // jump to alternative
	7389	+ label = 560LLU; // jump to alternative
7378	7390	break;
7379	7391	}
7380	7392

		@@ -7383,24 +7395,24 @@
7383	7395
7384	7396	// case
7385	7397	// call chainscope from linkscope
7386		- stack[base + 4LLU] = 560LLU/throw to this address/;
	7398	+ stack[base + 4LLU] = 562LLU/throw to this address/;
7387	7399	stack[base + 5LLU] = base;
7388		- stack[base + 6LLU] = 561LLU;
	7400	+ stack[base + 6LLU] = 563LLU;
7389	7401	// arguments for call to chainscope
7390	7402	stack[base + 8LLU] = stack[base + 2]/labelthrow/;
7391	7403	// set stack-base & callee-address
7392	7404	base += 7LLU;
7393		- label = 545LLU; // chainscope
	7405	+ label = 547LLU; // chainscope
7394	7406	break;
7395	7407	}
7396		- case 560LLU: // copy-back deleter (chainscope to linkscope)
	7408	+ case 562LLU: // copy-back deleter (chainscope to linkscope)
7397	7409	{
7398	7410	fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
7399	7411	// copy mutable arguments back from call to chainscope
7400		- label = 559LLU; // continue to roll stack
	7412	+ label = 561LLU; // continue to roll stack
7401	7413	break;
7402	7414	}
7403		- case 561LLU: // return from chainscope to linkscope
	7415	+ case 563LLU: // return from chainscope to linkscope
7404	7416	{
7405	7417	// copy mutable arguments back from call to chainscope
7406	7418	// copy back results provided by call to chainscope

		@@ -7407,22 +7419,22 @@
7407	7419	stack[base + 0] = stack[base + 7LLU];
7408	7420	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7409	7421	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7410		- label = 557LLU; // case complete
	7422	+ label = 559LLU; // case complete
7411	7423	break;
7412	7424	}
7413		- case 559LLU: // copy-back deleter (switch)
	7425	+ case 561LLU: // copy-back deleter (switch)
7414	7426	{
7415	7427	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7416	7428	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7417		- label = 556LLU; // continue to unroll stack
	7429	+ label = 558LLU; // continue to unroll stack
7418	7430	break;
7419	7431	}
7420		- case 558LLU: // try next case
	7432	+ case 560LLU: // try next case
7421	7433	{
7422	7434	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7423	7435	exit(-1);
7424	7436	}
7425		- case 557LLU: // completed switch
	7437	+ case 559LLU: // completed switch
7426	7438	{
7427	7439	// return from linkscope
7428	7440	label = stack[base - 1];

		@@ -7429,7 +7441,7 @@
7429	7441	base = stack[base - 2];
7430	7442	break;
7431	7443	}
7432		- case 563LLU: // function getdeladdr failed
	7444	+ case 565LLU: // function getdeladdr failed
7433	7445	{
7434	7446	fprintf(stderr, "function getdeladdr failed\n");
7435	7447	label = stack[base - 3];

		@@ -7436,13 +7448,13 @@
7436	7448	base = stack[base - 2];
7437	7449	break;
7438	7450	}
7439		- case 562LLU: // getdeladdr
	7451	+ case 564LLU: // getdeladdr
7440	7452	{
7441	7453	//#define res0 0
7442	7454	//#define arg0 1
7443	7455	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7444	7456	{
7445		- label = 565LLU; // jump to alternative
	7457	+ label = 567LLU; // jump to alternative
7446	7458	break;
7447	7459	}
7448	7460

		@@ -7450,43 +7462,43 @@
7450	7462	/letdefs/stack[base + 3] = ((uint64_t *)(stack[base + 1]/scope/))[1][1]/letdefs*/;
7451	7463
7452	7464	// case
7453		- label = 568LLU; // skip deleter
	7465	+ label = 570LLU; // skip deleter
7454	7466	break;
7455	7467	}
7456		- case 567LLU: // deleter
	7468	+ case 569LLU: // deleter
7457	7469	{
7458	7470	// throw from getdeladdr
7459	7471	if(!stack[base + 0])
7460	7472	{
7461	7473	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
7463	7475	break;
7464	7476	}
7465	7477	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
7467	7479	break;
7468	7480	}
7469		- case 568LLU: // skipped deleter
	7481	+ case 570LLU: // skipped deleter
7470	7482	{
7471	7483	stack[base + 0] = stack[base + 2]/labelthrow/;
7472	7484	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7473	7485	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7474		- label = 564LLU; // case complete
	7486	+ label = 566LLU; // case complete
7475	7487	break;
7476	7488	}
7477		- case 566LLU: // copy-back deleter (switch)
	7489	+ case 568LLU: // copy-back deleter (switch)
7478	7490	{
7479	7491	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7480	7492	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7481		- label = 563LLU; // continue to unroll stack
	7493	+ label = 565LLU; // continue to unroll stack
7482	7494	break;
7483	7495	}
7484		- case 565LLU: // try next case
	7496	+ case 567LLU: // try next case
7485	7497	{
7486	7498	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7487	7499	exit(-1);
7488	7500	}
7489		- case 564LLU: // completed switch
	7501	+ case 566LLU: // completed switch
7490	7502	{
7491	7503	// return from getdeladdr
7492	7504	label = stack[base - 1];

		@@ -7493,7 +7505,7 @@
7493	7505	base = stack[base - 2];
7494	7506	break;
7495	7507	}
7496		- case 570LLU: // function existslet failed
	7508	+ case 572LLU: // function existslet failed
7497	7509	{
7498	7510	fprintf(stderr, "function existslet failed\n");
7499	7511	label = stack[base - 3];

		@@ -7500,39 +7512,39 @@
7500	7512	base = stack[base - 2];
7501	7513	break;
7502	7514	}
7503		- case 569LLU: // existslet
	7515	+ case 571LLU: // existslet
7504	7516	{
7505	7517	//#define res0 0
7506	7518	//#define arg0 1
7507	7519	//#define arg1 2
7508		- label = 572LLU; // skip deleter
	7520	+ label = 574LLU; // skip deleter
7509	7521	break;
7510	7522	}
7511		- case 571LLU: // deleter
	7523	+ case 573LLU: // deleter
7512	7524	{
7513	7525	// throw from existslet
7514	7526	if(!stack[base + 3])
7515	7527	{
7516	7528	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
7518	7530	break;
7519	7531	}
7520	7532	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
7522	7534	break;
7523	7535	}
7524		- case 572LLU: // skipped deleter
	7536	+ case 574LLU: // skipped deleter
7525	7537	{
7526	7538	stack[base + 3] = 0;
7527	7539	flippedassign(stack[base + 1]/letdefs/, &stack[base + 4]);
7528		- label = 573LLU; // start to repeat
	7540	+ label = 575LLU; // start to repeat
7529	7541	break;
7530	7542	}
7531		- case 573LLU: // repeat from here
	7543	+ case 575LLU: // repeat from here
7532	7544	{
7533	7545	if(!stack[base + 4])
7534	7546	{
7535		- label = 574LLU; // break loop
	7547	+ label = 576LLU; // break loop
7536	7548	break;
7537	7549	}
7538	7550

		@@ -7542,19 +7554,19 @@
7542	7554	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
7543	7555	if(!stack[base + 3]/found/)
7544	7556	{
7545		- label = 575LLU; // jump to alternative
	7557	+ label = 578LLU; // jump to alternative
7546	7558	break;
7547	7559	}
7548	7560
7549	7561	// consequent
7550		- label = 576LLU; // consequent complete
	7562	+ label = 579LLU; // consequent complete
7551	7563	break;
7552	7564	}
7553		- case 575LLU: // alternative
	7565	+ case 578LLU: // alternative
7554	7566	{
7555	7567	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
7556	7568	{
7557		- label = 578LLU; // jump to alternative
	7569	+ label = 581LLU; // jump to alternative
7558	7570	break;
7559	7571	}
7560	7572

		@@ -7566,9 +7578,9 @@
7566	7578
7567	7579	// case
7568	7580	// call equ from existslet
7569		- stack[base + 12LLU] = 580LLU/throw to this address/;
	7581	+ stack[base + 12LLU] = 583LLU/throw to this address/;
7570	7582	stack[base + 13LLU] = base;
7571		- stack[base + 14LLU] = 581LLU;
	7583	+ stack[base + 14LLU] = 584LLU;
7572	7584	// arguments for call to equ
7573	7585	stack[base + 16LLU] = stack[base + 8]/curid/;
7574	7586	stack[base + 17LLU] = stack[base + 2]/id/;

		@@ -7577,14 +7589,14 @@
7577	7589	label = 18446744073709551600LLU; // equ
7578	7590	break;
7579	7591	}
7580		- case 580LLU: // copy-back deleter (equ to existslet)
	7592	+ case 583LLU: // copy-back deleter (equ to existslet)
7581	7593	{
7582	7594	fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
7583	7595	// copy mutable arguments back from call to equ
7584		- label = 579LLU; // continue to roll stack
	7596	+ label = 582LLU; // continue to roll stack
7585	7597	break;
7586	7598	}
7587		- case 581LLU: // return from equ to existslet
	7599	+ case 584LLU: // return from equ to existslet
7588	7600	{
7589	7601	// copy mutable arguments back from call to equ
7590	7602	// copy back results provided by call to equ

		@@ -7594,10 +7606,10 @@
7594	7606	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
7595	7607	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
7596	7608	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7597		- label = 577LLU; // case complete
	7609	+ label = 580LLU; // case complete
7598	7610	break;
7599	7611	}
7600		- case 579LLU: // copy-back deleter (switch)
	7612	+ case 582LLU: // copy-back deleter (switch)
7601	7613	{
7602	7614	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
7603	7615	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];

		@@ -7604,44 +7616,50 @@
7604	7616	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
7605	7617	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
7606	7618	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7607		- label = 571LLU; // continue to unroll stack
	7619	+ label = 577LLU; // continue to unroll stack
7608	7620	break;
7609	7621	}
7610		- case 578LLU: // try next case
	7622	+ case 581LLU: // try next case
7611	7623	{
7612	7624	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7613	7625	exit(-1);
7614	7626	}
7615		- case 577LLU: // completed switch
	7627	+ case 580LLU: // completed switch
7616	7628	{
7617		- label = 576LLU; // alternative complete
	7629	+ label = 579LLU; // alternative complete
7618	7630	break;
7619	7631	}
7620		- case 576LLU: // completed if-then-else
	7632	+ case 579LLU: // completed if-then-else
7621	7633	{
7622	7634	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
7623		- label = 573LLU; // repeat
	7635	+ label = 575LLU; // repeat
7624	7636	break;
7625	7637	}
7626		- case 574LLU: // loop finished
	7638	+ case 577LLU: // copy-back deleter for while next
7627	7639	{
7628		- label = 583LLU; // skip deleter
	7640	+ ((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
	7641	+ label = 573LLU; // continue to unroll stack
7629	7642	break;
7630	7643	}
7631		- case 582LLU: // deleter
	7644	+ case 576LLU: // loop finished
7632	7645	{
	7646	+ label = 586LLU; // skip deleter
	7647	+ break;
	7648	+ }
	7649	+ case 585LLU: // deleter
	7650	+ {
7633	7651	// throw from existslet
7634	7652	if(!stack[base + 0])
7635	7653	{
7636	7654	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
7638	7656	break;
7639	7657	}
7640	7658	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
7642	7660	break;
7643	7661	}
7644		- case 583LLU: // skipped deleter
	7662	+ case 586LLU: // skipped deleter
7645	7663	{
7646	7664	stack[base + 0] = stack[base + 3]/found/;
7647	7665	// return from existslet

		@@ -7649,7 +7667,7 @@
7649	7667	base = stack[base - 2];
7650	7668	break;
7651	7669	}
7652		- case 585LLU: // function FindLetNew failed
	7670	+ case 588LLU: // function FindLetNew failed
7653	7671	{
7654	7672	fprintf(stderr, "function FindLetNew failed\n");
7655	7673	label = stack[base - 3];

		@@ -7656,7 +7674,7 @@
7656	7674	base = stack[base - 2];
7657	7675	break;
7658	7676	}
7659		- case 584LLU: // FindLetNew
	7677	+ case 587LLU: // FindLetNew
7660	7678	{
7661	7679	//#define res0 0
7662	7680	//#define arg0 1

		@@ -7664,87 +7682,87 @@
7664	7682	//#define arg2 3
7665	7683	//#define arg3 4
7666	7684	// call mkletdummy from FindLetNew
7667		- stack[base + 6LLU] = 586LLU/throw to this address/;
	7685	+ stack[base + 6LLU] = 589LLU/throw to this address/;
7668	7686	stack[base + 7LLU] = base;
7669		- stack[base + 8LLU] = 587LLU;
	7687	+ stack[base + 8LLU] = 590LLU;
7670	7688	// arguments for call to mkletdummy
7671	7689	// set stack-base & callee-address
7672	7690	base += 9LLU;
7673		- label = 458LLU; // mkletdummy
	7691	+ label = 460LLU; // mkletdummy
7674	7692	break;
7675	7693	}
7676		- case 586LLU: // copy-back deleter (mkletdummy to FindLetNew)
	7694	+ case 589LLU: // copy-back deleter (mkletdummy to FindLetNew)
7677	7695	{
7678	7696	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (mkletdummy to FindLetNew)\n");
7679	7697	// copy mutable arguments back from call to mkletdummy
7680		- label = 585LLU; // continue to roll stack
	7698	+ label = 588LLU; // continue to roll stack
7681	7699	break;
7682	7700	}
7683		- case 587LLU: // return from mkletdummy to FindLetNew
	7701	+ case 590LLU: // return from mkletdummy to FindLetNew
7684	7702	{
7685	7703	// copy mutable arguments back from call to mkletdummy
7686	7704	// copy back results provided by call to mkletdummy
7687	7705	stack[base + 5] = stack[base + 9LLU];
7688		- label = 589LLU; // skip deleter
	7706	+ label = 592LLU; // skip deleter
7689	7707	break;
7690	7708	}
7691		- case 588LLU: // deleter
	7709	+ case 591LLU: // deleter
7692	7710	{
7693	7711	// throw from FindLetNew
7694	7712	if(!stack[base + 6])
7695	7713	{
7696	7714	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
7698	7716	break;
7699	7717	}
7700	7718	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
7702	7720	break;
7703	7721	}
7704		- case 589LLU: // skipped deleter
	7722	+ case 592LLU: // skipped deleter
7705	7723	{
7706	7724	stack[base + 6] = 0;
7707		- label = 591LLU; // skip deleter
	7725	+ label = 594LLU; // skip deleter
7708	7726	break;
7709	7727	}
7710		- case 590LLU: // deleter
	7728	+ case 593LLU: // deleter
7711	7729	{
7712	7730	// throw from FindLetNew
7713	7731	if(!stack[base + 7])
7714	7732	{
7715	7733	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
7717	7735	break;
7718	7736	}
7719	7737	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
7721	7739	break;
7722	7740	}
7723		- case 591LLU: // skipped deleter
	7741	+ case 594LLU: // skipped deleter
7724	7742	{
7725	7743	stack[base + 7] = 0;
7726		- label = 593LLU; // skip deleter
	7744	+ label = 596LLU; // skip deleter
7727	7745	break;
7728	7746	}
7729		- case 592LLU: // deleter
	7747	+ case 595LLU: // deleter
7730	7748	{
7731	7749	// throw from FindLetNew
7732	7750	if(!stack[base + 8])
7733	7751	{
7734	7752	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
7736	7754	break;
7737	7755	}
7738	7756	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
7740	7758	break;
7741	7759	}
7742		- case 593LLU: // skipped deleter
	7760	+ case 596LLU: // skipped deleter
7743	7761	{
7744	7762	stack[base + 8] = 0;
7745	7763	if(/scope/0 != ((uint64_t )(stack[base + 4]/SCOPE*/))[0])
7746	7764	{
7747		- label = 595LLU; // jump to alternative
	7765	+ label = 598LLU; // jump to alternative
7748	7766	break;
7749	7767	}
7750	7768

		@@ -7753,14 +7771,14 @@
7753	7771
7754	7772	// case
7755	7773	flippedassign(stack[base + 10]/scope/, &stack[base + 11]);
7756		- label = 597LLU; // start to repeat
	7774	+ label = 600LLU; // start to repeat
7757	7775	break;
7758	7776	}
7759		- case 597LLU: // repeat from here
	7777	+ case 600LLU: // repeat from here
7760	7778	{
7761	7779	if(!stack[base + 11])
7762	7780	{
7763		- label = 598LLU; // break loop
	7781	+ label = 601LLU; // break loop
7764	7782	break;
7765	7783	}
7766	7784

		@@ -7770,19 +7788,19 @@
7770	7788	stack[base + 11] = (uint64_t)(((const struct listnode *)(stack[base + 11]))->next);
7771	7789	if(!stack[base + 8]/found/)
7772	7790	{
7773		- label = 599LLU; // jump to alternative
	7791	+ label = 603LLU; // jump to alternative
7774	7792	break;
7775	7793	}
7776	7794
7777	7795	// consequent
7778		- label = 600LLU; // consequent complete
	7796	+ label = 604LLU; // consequent complete
7779	7797	break;
7780	7798	}
7781		- case 599LLU: // alternative
	7799	+ case 603LLU: // alternative
7782	7800	{
7783	7801	if(/letdef/0 != ((uint64_t )(stack[base + 12]/letdef*/))[0])
7784	7802	{
7785		- label = 602LLU; // jump to alternative
	7803	+ label = 606LLU; // jump to alternative
7786	7804	break;
7787	7805	}
7788	7806

		@@ -7794,9 +7812,9 @@
7794	7812
7795	7813	// case
7796	7814	// call equ from FindLetNew
7797		- stack[base + 19LLU] = 604LLU/throw to this address/;
	7815	+ stack[base + 19LLU] = 608LLU/throw to this address/;
7798	7816	stack[base + 20LLU] = base;
7799		- stack[base + 21LLU] = 605LLU;
	7817	+ stack[base + 21LLU] = 609LLU;
7800	7818	// arguments for call to equ
7801	7819	stack[base + 23LLU] = stack[base + 15]/curid/;
7802	7820	stack[base + 24LLU] = stack[base + 2]/id/;

		@@ -7805,14 +7823,14 @@
7805	7823	label = 18446744073709551600LLU; // equ
7806	7824	break;
7807	7825	}
7808		- case 604LLU: // copy-back deleter (equ to FindLetNew)
	7826	+ case 608LLU: // copy-back deleter (equ to FindLetNew)
7809	7827	{
7810	7828	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
7811	7829	// copy mutable arguments back from call to equ
7812		- label = 603LLU; // continue to roll stack
	7830	+ label = 607LLU; // continue to roll stack
7813	7831	break;
7814	7832	}
7815		- case 605LLU: // return from equ to FindLetNew
	7833	+ case 609LLU: // return from equ to FindLetNew
7816	7834	{
7817	7835	// copy mutable arguments back from call to equ
7818	7836	// copy back results provided by call to equ

		@@ -7819,30 +7837,30 @@
7819	7837	stack[base + 8] = stack[base + 22LLU];
7820	7838	if(!stack[base + 8]/found/)
7821	7839	{
7822		- label = 606LLU; // jump to alternative
	7840	+ label = 610LLU; // jump to alternative
7823	7841	break;
7824	7842	}
7825	7843
7826	7844	// consequent
7827	7845	// call copyletdef from FindLetNew
7828		- stack[base + 20LLU] = 608LLU/throw to this address/;
	7846	+ stack[base + 20LLU] = 612LLU/throw to this address/;
7829	7847	stack[base + 21LLU] = base;
7830		- stack[base + 22LLU] = 609LLU;
	7848	+ stack[base + 22LLU] = 613LLU;
7831	7849	// arguments for call to copyletdef
7832	7850	stack[base + 24LLU] = stack[base + 12]/letdef/;
7833	7851	// set stack-base & callee-address
7834	7852	base += 23LLU;
7835		- label = 518LLU; // copyletdef
	7853	+ label = 520LLU; // copyletdef
7836	7854	break;
7837	7855	}
7838		- case 608LLU: // copy-back deleter (copyletdef to FindLetNew)
	7856	+ case 612LLU: // copy-back deleter (copyletdef to FindLetNew)
7839	7857	{
7840	7858	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
7841	7859	// copy mutable arguments back from call to copyletdef
7842		- label = 603LLU; // continue to roll stack
	7860	+ label = 607LLU; // continue to roll stack
7843	7861	break;
7844	7862	}
7845		- case 609LLU: // return from copyletdef to FindLetNew
	7863	+ case 613LLU: // return from copyletdef to FindLetNew
7846	7864	{
7847	7865	// copy mutable arguments back from call to copyletdef
7848	7866	// copy back results provided by call to copyletdef

		@@ -7854,28 +7872,28 @@
7854	7872	newstack[0] = (uint64_t)stack; // backup stack location
7855	7873	newstack[1] = 1234567890;
7856	7874	newstack[2] = base;
7857		- newstack[3] = 610LLU;
	7875	+ newstack[3] = 614LLU;
7858	7876	stack = newstack;
7859	7877	// set stack-base & callee-address
7860	7878	base = 4/deloffset/;
7861		- label = 455LLU; // ~letdef
	7879	+ label = 457LLU; // ~letdef
7862	7880	break;
7863	7881	}
7864		- case 610LLU: // return from ~letdef to FindLetNew
	7882	+ case 614LLU: // return from ~letdef to FindLetNew
7865	7883	{
7866	7884	stack = (uint64_t *)stack[0];
7867	7885	// releasing toplevel container
7868	7886	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 19] - sizeof(uint64_t) 4));
7869	7887
7870		- label = 607LLU; // consequent complete
	7888	+ label = 611LLU; // consequent complete
7871	7889	break;
7872	7890	}
7873		- case 606LLU: // alternative
	7891	+ case 610LLU: // alternative
7874	7892	{
7875		- label = 607LLU; // alternative complete
	7893	+ label = 611LLU; // alternative complete
7876	7894	break;
7877	7895	}
7878		- case 607LLU: // completed if-then-else
	7896	+ case 611LLU: // completed if-then-else
7879	7897	{
7880	7898	((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
7881	7899	((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];

		@@ -7882,10 +7900,10 @@
7882	7900	((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
7883	7901	((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
7884	7902	((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7885		- label = 601LLU; // case complete
	7903	+ label = 605LLU; // case complete
7886	7904	break;
7887	7905	}
7888		- case 603LLU: // copy-back deleter (switch)
	7906	+ case 607LLU: // copy-back deleter (switch)
7889	7907	{
7890	7908	((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
7891	7909	((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];

		@@ -7892,67 +7910,73 @@
7892	7910	((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
7893	7911	((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
7894	7912	((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7895		- label = 596LLU; // continue to unroll stack
	7913	+ label = 602LLU; // continue to unroll stack
7896	7914	break;
7897	7915	}
7898		- case 602LLU: // try next case
	7916	+ case 606LLU: // try next case
7899	7917	{
7900	7918	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7901	7919	exit(-1);
7902	7920	}
7903		- case 601LLU: // completed switch
	7921	+ case 605LLU: // completed switch
7904	7922	{
7905		- label = 600LLU; // alternative complete
	7923	+ label = 604LLU; // alternative complete
7906	7924	break;
7907	7925	}
7908		- case 600LLU: // completed if-then-else
	7926	+ case 604LLU: // completed if-then-else
7909	7927	{
7910	7928	((struct listnode )(stack[base + 13]/previous*/))->data = stack[base + 12];
7911		- label = 597LLU; // repeat
	7929	+ label = 600LLU; // repeat
7912	7930	break;
7913	7931	}
7914		- case 598LLU: // loop finished
	7932	+ case 602LLU: // copy-back deleter for while next
7915	7933	{
	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	+ {
7916	7940	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
7917	7941	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7918		- label = 594LLU; // case complete
	7942	+ label = 597LLU; // case complete
7919	7943	break;
7920	7944	}
7921		- case 596LLU: // copy-back deleter (switch)
	7945	+ case 599LLU: // copy-back deleter (switch)
7922	7946	{
7923	7947	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
7924	7948	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7925		- label = 592LLU; // continue to unroll stack
	7949	+ label = 595LLU; // continue to unroll stack
7926	7950	break;
7927	7951	}
7928		- case 595LLU: // try next case
	7952	+ case 598LLU: // try next case
7929	7953	{
7930	7954	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7931	7955	exit(-1);
7932	7956	}
7933		- case 594LLU: // completed switch
	7957	+ case 597LLU: // completed switch
7934	7958	{
7935	7959	if(!stack[base + 8]/found/)
7936	7960	{
7937		- label = 611LLU; // jump to alternative
	7961	+ label = 615LLU; // jump to alternative
7938	7962	break;
7939	7963	}
7940	7964
7941	7965	// consequent
7942		- label = 612LLU; // consequent complete
	7966	+ label = 616LLU; // consequent complete
7943	7967	break;
7944	7968	}
7945		- case 611LLU: // alternative
	7969	+ case 615LLU: // alternative
7946	7970	{
7947	7971	flippedassign(stack[base + 3]/scopes/, &stack[base + 9]);
7948		- label = 613LLU; // start to repeat
	7972	+ label = 617LLU; // start to repeat
7949	7973	break;
7950	7974	}
7951		- case 613LLU: // repeat from here
	7975	+ case 617LLU: // repeat from here
7952	7976	{
7953	7977	if(!stack[base + 9])
7954	7978	{
7955		- label = 614LLU; // break loop
	7979	+ label = 618LLU; // break loop
7956	7980	break;
7957	7981	}
7958	7982

		@@ -7962,19 +7986,19 @@
7962	7986	stack[base + 9] = (uint64_t)(((const struct listnode *)(stack[base + 9]))->next);
7963	7987	if(!stack[base + 8]/found/)
7964	7988	{
7965		- label = 615LLU; // jump to alternative
	7989	+ label = 620LLU; // jump to alternative
7966	7990	break;
7967	7991	}
7968	7992
7969	7993	// consequent
7970		- label = 616LLU; // consequent complete
	7994	+ label = 621LLU; // consequent complete
7971	7995	break;
7972	7996	}
7973		- case 615LLU: // alternative
	7997	+ case 620LLU: // alternative
7974	7998	{
7975	7999	if(/scope/0 != ((uint64_t )(stack[base + 10]/SCOPE*/))[0])
7976	8000	{
7977		- label = 618LLU; // jump to alternative
	8001	+ label = 623LLU; // jump to alternative
7978	8002	break;
7979	8003	}
7980	8004

		@@ -7983,14 +8007,14 @@
7983	8007
7984	8008	// case
7985	8009	flippedassign(stack[base + 13]/scope/, &stack[base + 14]);
7986		- label = 620LLU; // start to repeat
	8010	+ label = 625LLU; // start to repeat
7987	8011	break;
7988	8012	}
7989		- case 620LLU: // repeat from here
	8013	+ case 625LLU: // repeat from here
7990	8014	{
7991	8015	if(!stack[base + 14])
7992	8016	{
7993		- label = 621LLU; // break loop
	8017	+ label = 626LLU; // break loop
7994	8018	break;
7995	8019	}
7996	8020

		@@ -8000,19 +8024,19 @@
8000	8024	stack[base + 14] = (uint64_t)(((const struct listnode *)(stack[base + 14]))->next);
8001	8025	if(!stack[base + 8]/found/)
8002	8026	{
8003		- label = 622LLU; // jump to alternative
	8027	+ label = 628LLU; // jump to alternative
8004	8028	break;
8005	8029	}
8006	8030
8007	8031	// consequent
8008		- label = 623LLU; // consequent complete
	8032	+ label = 629LLU; // consequent complete
8009	8033	break;
8010	8034	}
8011		- case 622LLU: // alternative
	8035	+ case 628LLU: // alternative
8012	8036	{
8013	8037	if(!stack[base + 15]/letdef/)
8014	8038	{
8015		- label = 624LLU; // jump to alternative
	8039	+ label = 630LLU; // jump to alternative
8016	8040	break;
8017	8041	}
8018	8042

		@@ -8019,7 +8043,7 @@
8019	8043	// consequent
8020	8044	if(/letdef/0 != ((uint64_t )(stack[base + 15]/letdef*/))[0])
8021	8045	{
8022		- label = 627LLU; // jump to alternative
	8046	+ label = 633LLU; // jump to alternative
8023	8047	break;
8024	8048	}
8025	8049

		@@ -8031,9 +8055,9 @@
8031	8055
8032	8056	// case
8033	8057	// call equ from FindLetNew
8034		- stack[base + 22LLU] = 629LLU/throw to this address/;
	8058	+ stack[base + 22LLU] = 635LLU/throw to this address/;
8035	8059	stack[base + 23LLU] = base;
8036		- stack[base + 24LLU] = 630LLU;
	8060	+ stack[base + 24LLU] = 636LLU;
8037	8061	// arguments for call to equ
8038	8062	stack[base + 26LLU] = stack[base + 18]/curid/;
8039	8063	stack[base + 27LLU] = stack[base + 2]/id/;

		@@ -8042,14 +8066,14 @@
8042	8066	label = 18446744073709551600LLU; // equ
8043	8067	break;
8044	8068	}
8045		- case 629LLU: // copy-back deleter (equ to FindLetNew)
	8069	+ case 635LLU: // copy-back deleter (equ to FindLetNew)
8046	8070	{
8047	8071	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
8048	8072	// copy mutable arguments back from call to equ
8049		- label = 628LLU; // continue to roll stack
	8073	+ label = 634LLU; // continue to roll stack
8050	8074	break;
8051	8075	}
8052		- case 630LLU: // return from equ to FindLetNew
	8076	+ case 636LLU: // return from equ to FindLetNew
8053	8077	{
8054	8078	// copy mutable arguments back from call to equ
8055	8079	// copy back results provided by call to equ

		@@ -8056,30 +8080,30 @@
8056	8080	stack[base + 8] = stack[base + 25LLU];
8057	8081	if(!stack[base + 8]/found/)
8058	8082	{
8059		- label = 631LLU; // jump to alternative
	8083	+ label = 637LLU; // jump to alternative
8060	8084	break;
8061	8085	}
8062	8086
8063	8087	// consequent
8064	8088	// call copyletdef from FindLetNew
8065		- stack[base + 23LLU] = 633LLU/throw to this address/;
	8089	+ stack[base + 23LLU] = 639LLU/throw to this address/;
8066	8090	stack[base + 24LLU] = base;
8067		- stack[base + 25LLU] = 634LLU;
	8091	+ stack[base + 25LLU] = 640LLU;
8068	8092	// arguments for call to copyletdef
8069	8093	stack[base + 27LLU] = stack[base + 15]/letdef/;
8070	8094	// set stack-base & callee-address
8071	8095	base += 26LLU;
8072		- label = 518LLU; // copyletdef
	8096	+ label = 520LLU; // copyletdef
8073	8097	break;
8074	8098	}
8075		- case 633LLU: // copy-back deleter (copyletdef to FindLetNew)
	8099	+ case 639LLU: // copy-back deleter (copyletdef to FindLetNew)
8076	8100	{
8077	8101	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
8078	8102	// copy mutable arguments back from call to copyletdef
8079		- label = 628LLU; // continue to roll stack
	8103	+ label = 634LLU; // continue to roll stack
8080	8104	break;
8081	8105	}
8082		- case 634LLU: // return from copyletdef to FindLetNew
	8106	+ case 640LLU: // return from copyletdef to FindLetNew
8083	8107	{
8084	8108	// copy mutable arguments back from call to copyletdef
8085	8109	// copy back results provided by call to copyletdef

		@@ -8091,28 +8115,28 @@
8091	8115	newstack[0] = (uint64_t)stack; // backup stack location
8092	8116	newstack[1] = 1234567890;
8093	8117	newstack[2] = base;
8094		- newstack[3] = 635LLU;
	8118	+ newstack[3] = 641LLU;
8095	8119	stack = newstack;
8096	8120	// set stack-base & callee-address
8097	8121	base = 4/deloffset/;
8098		- label = 455LLU; // ~letdef
	8122	+ label = 457LLU; // ~letdef
8099	8123	break;
8100	8124	}
8101		- case 635LLU: // return from ~letdef to FindLetNew
	8125	+ case 641LLU: // return from ~letdef to FindLetNew
8102	8126	{
8103	8127	stack = (uint64_t *)stack[0];
8104	8128	// releasing toplevel container
8105	8129	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 22] - sizeof(uint64_t) 4));
8106	8130
8107		- label = 632LLU; // consequent complete
	8131	+ label = 638LLU; // consequent complete
8108	8132	break;
8109	8133	}
8110		- case 631LLU: // alternative
	8134	+ case 637LLU: // alternative
8111	8135	{
8112		- label = 632LLU; // alternative complete
	8136	+ label = 638LLU; // alternative complete
8113	8137	break;
8114	8138	}
8115		- case 632LLU: // completed if-then-else
	8139	+ case 638LLU: // completed if-then-else
8116	8140	{
8117	8141	((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
8118	8142	((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];

		@@ -8119,10 +8143,10 @@
8119	8143	((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
8120	8144	((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
8121	8145	((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
8122		- label = 626LLU; // case complete
	8146	+ label = 632LLU; // case complete
8123	8147	break;
8124	8148	}
8125		- case 628LLU: // copy-back deleter (switch)
	8149	+ case 634LLU: // copy-back deleter (switch)
8126	8150	{
8127	8151	((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
8128	8152	((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];

		@@ -8129,85 +8153,97 @@
8129	8153	((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
8130	8154	((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
8131	8155	((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
8132		- label = 619LLU; // continue to unroll stack
	8156	+ label = 627LLU; // continue to unroll stack
8133	8157	break;
8134	8158	}
8135		- case 627LLU: // try next case
	8159	+ case 633LLU: // try next case
8136	8160	{
8137	8161	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8138	8162	exit(-1);
8139	8163	}
8140		- case 626LLU: // completed switch
	8164	+ case 632LLU: // completed switch
8141	8165	{
8142		- label = 625LLU; // consequent complete
	8166	+ label = 631LLU; // consequent complete
8143	8167	break;
8144	8168	}
8145		- case 624LLU: // alternative
	8169	+ case 630LLU: // alternative
8146	8170	{
8147	8171	fprintf(stderr, "%s", "INTERNAL ERROR empty scope\n");
8148		- label = 625LLU; // alternative complete
	8172	+ label = 631LLU; // alternative complete
8149	8173	break;
8150	8174	}
8151		- case 625LLU: // completed if-then-else
	8175	+ case 631LLU: // completed if-then-else
8152	8176	{
8153		- label = 623LLU; // alternative complete
	8177	+ label = 629LLU; // alternative complete
8154	8178	break;
8155	8179	}
8156		- case 623LLU: // completed if-then-else
	8180	+ case 629LLU: // completed if-then-else
8157	8181	{
8158	8182	((struct listnode )(stack[base + 16]/previous*/))->data = stack[base + 15];
8159		- label = 620LLU; // repeat
	8183	+ label = 625LLU; // repeat
8160	8184	break;
8161	8185	}
8162		- case 621LLU: // loop finished
	8186	+ case 627LLU: // copy-back deleter for while next
8163	8187	{
	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	+ {
8164	8194	((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
8165	8195	((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
8166		- label = 617LLU; // case complete
	8196	+ label = 622LLU; // case complete
8167	8197	break;
8168	8198	}
8169		- case 619LLU: // copy-back deleter (switch)
	8199	+ case 624LLU: // copy-back deleter (switch)
8170	8200	{
8171	8201	((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
8172	8202	((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
8173		- label = 592LLU; // continue to unroll stack
	8203	+ label = 619LLU; // continue to unroll stack
8174	8204	break;
8175	8205	}
8176		- case 618LLU: // try next case
	8206	+ case 623LLU: // try next case
8177	8207	{
8178	8208	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8179	8209	exit(-1);
8180	8210	}
8181		- case 617LLU: // completed switch
	8211	+ case 622LLU: // completed switch
8182	8212	{
8183		- label = 616LLU; // alternative complete
	8213	+ label = 621LLU; // alternative complete
8184	8214	break;
8185	8215	}
8186		- case 616LLU: // completed if-then-else
	8216	+ case 621LLU: // completed if-then-else
8187	8217	{
8188	8218	((struct listnode )(stack[base + 11]/previous*/))->data = stack[base + 10];
8189		- label = 613LLU; // repeat
	8219	+ label = 617LLU; // repeat
8190	8220	break;
8191	8221	}
8192		- case 614LLU: // loop finished
	8222	+ case 619LLU: // copy-back deleter for while next
8193	8223	{
	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	+ {
8194	8230	if(!stack[base + 8]/found/)
8195	8231	{
8196		- label = 636LLU; // jump to alternative
	8232	+ label = 642LLU; // jump to alternative
8197	8233	break;
8198	8234	}
8199	8235
8200	8236	// consequent
8201		- label = 637LLU; // consequent complete
	8237	+ label = 643LLU; // consequent complete
8202	8238	break;
8203	8239	}
8204		- case 636LLU: // alternative
	8240	+ case 642LLU: // alternative
8205	8241	{
8206	8242	fprintf(stderr, "%s", "in function ");
8207	8243	// call reportid from FindLetNew
8208		- stack[base + 12LLU] = 638LLU/throw to this address/;
	8244	+ stack[base + 12LLU] = 644LLU/throw to this address/;
8209	8245	stack[base + 13LLU] = base;
8210		- stack[base + 14LLU] = 639LLU;
	8246	+ stack[base + 14LLU] = 645LLU;
8211	8247	// arguments for call to reportid
8212	8248	stack[base + 15LLU] = stack[base + 1]/fnid/;
8213	8249	// set stack-base & callee-address

		@@ -8215,22 +8251,22 @@
8215	8251	label = 18446744073709551586LLU; // reportid
8216	8252	break;
8217	8253	}
8218		- case 638LLU: // copy-back deleter (reportid to FindLetNew)
	8254	+ case 644LLU: // copy-back deleter (reportid to FindLetNew)
8219	8255	{
8220	8256	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
8221	8257	// copy mutable arguments back from call to reportid
8222		- label = 592LLU; // continue to roll stack
	8258	+ label = 595LLU; // continue to roll stack
8223	8259	break;
8224	8260	}
8225		- case 639LLU: // return from reportid to FindLetNew
	8261	+ case 645LLU: // return from reportid to FindLetNew
8226	8262	{
8227	8263	// copy mutable arguments back from call to reportid
8228	8264	fprintf(stderr, "%s", ": ");
8229	8265	fprintf(stderr, "%s", "variable ");
8230	8266	// call reportid from FindLetNew
8231		- stack[base + 12LLU] = 640LLU/throw to this address/;
	8267	+ stack[base + 12LLU] = 646LLU/throw to this address/;
8232	8268	stack[base + 13LLU] = base;
8233		- stack[base + 14LLU] = 641LLU;
	8269	+ stack[base + 14LLU] = 647LLU;
8234	8270	// arguments for call to reportid
8235	8271	stack[base + 15LLU] = stack[base + 2]/id/;
8236	8272	// set stack-base & callee-address

		@@ -8238,38 +8274,38 @@
8238	8274	label = 18446744073709551586LLU; // reportid
8239	8275	break;
8240	8276	}
8241		- case 640LLU: // copy-back deleter (reportid to FindLetNew)
	8277	+ case 646LLU: // copy-back deleter (reportid to FindLetNew)
8242	8278	{
8243	8279	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
8244	8280	// copy mutable arguments back from call to reportid
8245		- label = 592LLU; // continue to roll stack
	8281	+ label = 595LLU; // continue to roll stack
8246	8282	break;
8247	8283	}
8248		- case 641LLU: // return from reportid to FindLetNew
	8284	+ case 647LLU: // return from reportid to FindLetNew
8249	8285	{
8250	8286	// copy mutable arguments back from call to reportid
8251	8287	fprintf(stderr, "%s", " not in scope\n");
8252	8288	exit(-1);
8253		- label = 637LLU; // alternative complete
	8289	+ label = 643LLU; // alternative complete
8254	8290	break;
8255	8291	}
8256		- case 637LLU: // completed if-then-else
	8292	+ case 643LLU: // completed if-then-else
8257	8293	{
8258		- label = 612LLU; // alternative complete
	8294	+ label = 616LLU; // alternative complete
8259	8295	break;
8260	8296	}
8261		- case 612LLU: // completed if-then-else
	8297	+ case 616LLU: // completed if-then-else
8262	8298	{
8263		- label = 643LLU; // skip deleter
	8299	+ label = 649LLU; // skip deleter
8264	8300	break;
8265	8301	}
8266		- case 642LLU: // deleter
	8302	+ case 648LLU: // deleter
8267	8303	{
8268	8304	// throw from FindLetNew
8269	8305	if(!stack[base + 0])
8270	8306	{
8271	8307	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
8273	8309	break;
8274	8310	}
8275	8311	fprintf(stderr, "in function FindLetNew: unrolling stack, variable letdef \n");

		@@ -8279,23 +8315,23 @@
8279	8315	newstack[0] = (uint64_t)stack; // backup stack location
8280	8316	newstack[1] = 1234567890;
8281	8317	newstack[2] = base;
8282		- newstack[3] = 644LLU;
	8318	+ newstack[3] = 650LLU;
8283	8319	stack = newstack;
8284	8320	// set stack-base & callee-address
8285	8321	base = 4/deloffset/;
8286		- label = 455LLU; // ~letdef
	8322	+ label = 457LLU; // ~letdef
8287	8323	break;
8288	8324	}
8289		- case 644LLU: // return from ~letdef to FindLetNew
	8325	+ case 650LLU: // return from ~letdef to FindLetNew
8290	8326	{
8291	8327	stack = (uint64_t *)stack[0];
8292	8328	// releasing toplevel container
8293	8329	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
8294	8330
8295		- label = 592LLU; // continue unrolling stack, delete next variable
	8331	+ label = 595LLU; // continue unrolling stack, delete next variable
8296	8332	break;
8297	8333	}
8298		- case 643LLU: // skipped deleter
	8334	+ case 649LLU: // skipped deleter
8299	8335	{
8300	8336	INIT(&stack[base + 0], &stack[base + 5]/result/);
8301	8337	// return from FindLetNew

		@@ -8303,7 +8339,7 @@
8303	8339	base = stack[base - 2];
8304	8340	break;
8305	8341	}
8306		- case 646LLU: // function getlettype failed
	8342	+ case 652LLU: // function getlettype failed
8307	8343	{
8308	8344	fprintf(stderr, "function getlettype failed\n");
8309	8345	label = stack[base - 3];

		@@ -8310,7 +8346,7 @@
8310	8346	base = stack[base - 2];
8311	8347	break;
8312	8348	}
8313		- case 645LLU: // getlettype
	8349	+ case 651LLU: // getlettype
8314	8350	{
8315	8351	//#define res0 0
8316	8352	//#define arg0 1

		@@ -8318,9 +8354,9 @@
8318	8354	//#define arg2 3
8319	8355	//#define arg3 4
8320	8356	// call FindLetNew from getlettype
8321		- stack[base + 6LLU] = 647LLU/throw to this address/;
	8357	+ stack[base + 6LLU] = 653LLU/throw to this address/;
8322	8358	stack[base + 7LLU] = base;
8323		- stack[base + 8LLU] = 648LLU;
	8359	+ stack[base + 8LLU] = 654LLU;
8324	8360	// arguments for call to FindLetNew
8325	8361	stack[base + 10LLU] = stack[base + 1]/fnid/;
8326	8362	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8328,17 +8364,17 @@
8328	8364	stack[base + 13LLU] = stack[base + 4]/scope/;
8329	8365	// set stack-base & callee-address
8330	8366	base += 9LLU;
8331		- label = 584LLU; // FindLetNew
	8367	+ label = 587LLU; // FindLetNew
8332	8368	break;
8333	8369	}
8334		- case 647LLU: // copy-back deleter (FindLetNew to getlettype)
	8370	+ case 653LLU: // copy-back deleter (FindLetNew to getlettype)
8335	8371	{
8336	8372	fprintf(stderr, "in function getlettype: unrolling stack, copy-back (FindLetNew to getlettype)\n");
8337	8373	// copy mutable arguments back from call to FindLetNew
8338		- label = 646LLU; // continue to roll stack
	8374	+ label = 652LLU; // continue to roll stack
8339	8375	break;
8340	8376	}
8341		- case 648LLU: // return from FindLetNew to getlettype
	8377	+ case 654LLU: // return from FindLetNew to getlettype
8342	8378	{
8343	8379	// copy mutable arguments back from call to FindLetNew
8344	8380	// copy back results provided by call to FindLetNew

		@@ -8345,7 +8381,7 @@
8345	8381	stack[base + 5] = stack[base + 9LLU];
8346	8382	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8347	8383	{
8348		- label = 650LLU; // jump to alternative
	8384	+ label = 656LLU; // jump to alternative
8349	8385	break;
8350	8386	}
8351	8387

		@@ -8359,7 +8395,7 @@
8359	8395	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
8360	8396	if(!newstack)
8361	8397	{
8362		- label = 651LLU; // throw: begin to unroll stack
	8398	+ label = 657LLU; // throw: begin to unroll stack
8363	8399	break;
8364	8400	}
8365	8401

		@@ -8366,18 +8402,18 @@
8366	8402	newstack[15LLU] = 9876543210LLU; // overflow-marker
8367	8403	// call copytype from getlettype
8368	8404	newstack[0] = (uint64_t)stack; // backup stack location
8369		- newstack[1] = 652LLU;
	8405	+ newstack[1] = 658LLU;
8370	8406	newstack[2] = base;
8371		- newstack[3] = 653LLU;
	8407	+ newstack[3] = 659LLU;
8372	8408	// arguments for call to copytype
8373	8409	newstack[5LLU] = stack[base + 6]/type/;
8374	8410	stack = newstack;
8375	8411	// set stack-base & callee-address
8376	8412	base = 4/deloffset/;
8377		- label = 326LLU; // copytype
	8413	+ label = 327LLU; // copytype
8378	8414	break;
8379	8415	}
8380		- case 652LLU: // copy-back deleter (copytype to getlettype)
	8416	+ case 658LLU: // copy-back deleter (copytype to getlettype)
8381	8417	{
8382	8418	fprintf(stderr, "in function getlettype: unrolling stack, copy-back (copytype to getlettype)\n");
8383	8419	uint64_t oldstack = (uint64_t )stack[0];

		@@ -8389,10 +8425,10 @@
8389	8425	}
8390	8426	Free(15LLU + 1, sizeof(uint64_t), stack);
8391	8427	stack = oldstack;
8392		- label = 651LLU; // continue to unroll stack
	8428	+ label = 657LLU; // continue to unroll stack
8393	8429	break;
8394	8430	}
8395		- case 653LLU: // return from copytype to getlettype
	8431	+ case 659LLU: // return from copytype to getlettype
8396	8432	{
8397	8433	uint64_t oldstack = (uint64_t )stack[0];
8398	8434	// copy mutable arguments back from call to copytype

		@@ -8410,10 +8446,10 @@
8410	8446	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8411	8447	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8412	8448	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8413		- label = 649LLU; // case complete
	8449	+ label = 655LLU; // case complete
8414	8450	break;
8415	8451	}
8416		- case 651LLU: // copy-back deleter (switch)
	8452	+ case 657LLU: // copy-back deleter (switch)
8417	8453	{
8418	8454	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
8419	8455	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];

		@@ -8420,15 +8456,15 @@
8420	8456	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8421	8457	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8422	8458	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8423		- label = 646LLU; // continue to unroll stack
	8459	+ label = 652LLU; // continue to unroll stack
8424	8460	break;
8425	8461	}
8426		- case 650LLU: // try next case
	8462	+ case 656LLU: // try next case
8427	8463	{
8428	8464	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8429	8465	exit(-1);
8430	8466	}
8431		- case 649LLU: // completed switch
	8467	+ case 655LLU: // completed switch
8432	8468	{
8433	8469
8434	8470	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8436,14 +8472,14 @@
8436	8472	newstack[0] = (uint64_t)stack; // backup stack location
8437	8473	newstack[1] = 1234567890;
8438	8474	newstack[2] = base;
8439		- newstack[3] = 654LLU;
	8475	+ newstack[3] = 660LLU;
8440	8476	stack = newstack;
8441	8477	// set stack-base & callee-address
8442	8478	base = 4/deloffset/;
8443		- label = 455LLU; // ~letdef
	8479	+ label = 457LLU; // ~letdef
8444	8480	break;
8445	8481	}
8446		- case 654LLU: // return from ~letdef to getlettype
	8482	+ case 660LLU: // return from ~letdef to getlettype
8447	8483	{
8448	8484	stack = (uint64_t *)stack[0];
8449	8485	// releasing toplevel container

		@@ -8454,7 +8490,7 @@
8454	8490	base = stack[base - 2];
8455	8491	break;
8456	8492	}
8457		- case 656LLU: // function findletidx failed
	8493	+ case 662LLU: // function findletidx failed
8458	8494	{
8459	8495	fprintf(stderr, "function findletidx failed\n");
8460	8496	label = stack[base - 3];

		@@ -8461,7 +8497,7 @@
8461	8497	base = stack[base - 2];
8462	8498	break;
8463	8499	}
8464		- case 655LLU: // findletidx
	8500	+ case 661LLU: // findletidx
8465	8501	{
8466	8502	//#define res0 0
8467	8503	//#define arg0 1

		@@ -8469,9 +8505,9 @@
8469	8505	//#define arg2 3
8470	8506	//#define arg3 4
8471	8507	// call FindLetNew from findletidx
8472		- stack[base + 6LLU] = 657LLU/throw to this address/;
	8508	+ stack[base + 6LLU] = 663LLU/throw to this address/;
8473	8509	stack[base + 7LLU] = base;
8474		- stack[base + 8LLU] = 658LLU;
	8510	+ stack[base + 8LLU] = 664LLU;
8475	8511	// arguments for call to FindLetNew
8476	8512	stack[base + 10LLU] = stack[base + 1]/fnid/;
8477	8513	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8479,17 +8515,17 @@
8479	8515	stack[base + 13LLU] = stack[base + 4]/scope/;
8480	8516	// set stack-base & callee-address
8481	8517	base += 9LLU;
8482		- label = 584LLU; // FindLetNew
	8518	+ label = 587LLU; // FindLetNew
8483	8519	break;
8484	8520	}
8485		- case 657LLU: // copy-back deleter (FindLetNew to findletidx)
	8521	+ case 663LLU: // copy-back deleter (FindLetNew to findletidx)
8486	8522	{
8487	8523	fprintf(stderr, "in function findletidx: unrolling stack, copy-back (FindLetNew to findletidx)\n");
8488	8524	// copy mutable arguments back from call to FindLetNew
8489		- label = 656LLU; // continue to roll stack
	8525	+ label = 662LLU; // continue to roll stack
8490	8526	break;
8491	8527	}
8492		- case 658LLU: // return from FindLetNew to findletidx
	8528	+ case 664LLU: // return from FindLetNew to findletidx
8493	8529	{
8494	8530	// copy mutable arguments back from call to FindLetNew
8495	8531	// copy back results provided by call to FindLetNew

		@@ -8496,7 +8532,7 @@
8496	8532	stack[base + 5] = stack[base + 9LLU];
8497	8533	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8498	8534	{
8499		- label = 660LLU; // jump to alternative
	8535	+ label = 666LLU; // jump to alternative
8500	8536	break;
8501	8537	}
8502	8538

		@@ -8507,23 +8543,23 @@
8507	8543	/substruct/stack[base + 10] = ((uint64_t *)(stack[base + 5]/letdef/))[1][4]/substruct*/;
8508	8544
8509	8545	// case
8510		- label = 663LLU; // skip deleter
	8546	+ label = 669LLU; // skip deleter
8511	8547	break;
8512	8548	}
8513		- case 662LLU: // deleter
	8549	+ case 668LLU: // deleter
8514	8550	{
8515	8551	// throw from findletidx
8516	8552	if(!stack[base + 0])
8517	8553	{
8518	8554	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
8520	8556	break;
8521	8557	}
8522	8558	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
8524	8560	break;
8525	8561	}
8526		- case 663LLU: // skipped deleter
	8562	+ case 669LLU: // skipped deleter
8527	8563	{
8528	8564	stack[base + 0] = stack[base + 8]/index/;
8529	8565	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];

		@@ -8531,10 +8567,10 @@
8531	8567	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8532	8568	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8533	8569	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8534		- label = 659LLU; // case complete
	8570	+ label = 665LLU; // case complete
8535	8571	break;
8536	8572	}
8537		- case 661LLU: // copy-back deleter (switch)
	8573	+ case 667LLU: // copy-back deleter (switch)
8538	8574	{
8539	8575	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
8540	8576	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];

		@@ -8541,15 +8577,15 @@
8541	8577	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8542	8578	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8543	8579	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8544		- label = 656LLU; // continue to unroll stack
	8580	+ label = 662LLU; // continue to unroll stack
8545	8581	break;
8546	8582	}
8547		- case 660LLU: // try next case
	8583	+ case 666LLU: // try next case
8548	8584	{
8549	8585	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8550	8586	exit(-1);
8551	8587	}
8552		- case 659LLU: // completed switch
	8588	+ case 665LLU: // completed switch
8553	8589	{
8554	8590
8555	8591	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8557,14 +8593,14 @@
8557	8593	newstack[0] = (uint64_t)stack; // backup stack location
8558	8594	newstack[1] = 1234567890;
8559	8595	newstack[2] = base;
8560		- newstack[3] = 664LLU;
	8596	+ newstack[3] = 670LLU;
8561	8597	stack = newstack;
8562	8598	// set stack-base & callee-address
8563	8599	base = 4/deloffset/;
8564		- label = 455LLU; // ~letdef
	8600	+ label = 457LLU; // ~letdef
8565	8601	break;
8566	8602	}
8567		- case 664LLU: // return from ~letdef to findletidx
	8603	+ case 670LLU: // return from ~letdef to findletidx
8568	8604	{
8569	8605	stack = (uint64_t *)stack[0];
8570	8606	// releasing toplevel container

		@@ -8575,7 +8611,7 @@
8575	8611	base = stack[base - 2];
8576	8612	break;
8577	8613	}
8578		- case 666LLU: // function findletmut failed
	8614	+ case 672LLU: // function findletmut failed
8579	8615	{
8580	8616	fprintf(stderr, "function findletmut failed\n");
8581	8617	label = stack[base - 3];

		@@ -8582,7 +8618,7 @@
8582	8618	base = stack[base - 2];
8583	8619	break;
8584	8620	}
8585		- case 665LLU: // findletmut
	8621	+ case 671LLU: // findletmut
8586	8622	{
8587	8623	//#define res0 0
8588	8624	//#define arg0 1

		@@ -8590,9 +8626,9 @@
8590	8626	//#define arg2 3
8591	8627	//#define arg3 4
8592	8628	// call FindLetNew from findletmut
8593		- stack[base + 6LLU] = 667LLU/throw to this address/;
	8629	+ stack[base + 6LLU] = 673LLU/throw to this address/;
8594	8630	stack[base + 7LLU] = base;
8595		- stack[base + 8LLU] = 668LLU;
	8631	+ stack[base + 8LLU] = 674LLU;
8596	8632	// arguments for call to FindLetNew
8597	8633	stack[base + 10LLU] = stack[base + 1]/fnid/;
8598	8634	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8600,17 +8636,17 @@
8600	8636	stack[base + 13LLU] = stack[base + 4]/scope/;
8601	8637	// set stack-base & callee-address
8602	8638	base += 9LLU;
8603		- label = 584LLU; // FindLetNew
	8639	+ label = 587LLU; // FindLetNew
8604	8640	break;
8605	8641	}
8606		- case 667LLU: // copy-back deleter (FindLetNew to findletmut)
	8642	+ case 673LLU: // copy-back deleter (FindLetNew to findletmut)
8607	8643	{
8608	8644	fprintf(stderr, "in function findletmut: unrolling stack, copy-back (FindLetNew to findletmut)\n");
8609	8645	// copy mutable arguments back from call to FindLetNew
8610		- label = 666LLU; // continue to roll stack
	8646	+ label = 672LLU; // continue to roll stack
8611	8647	break;
8612	8648	}
8613		- case 668LLU: // return from FindLetNew to findletmut
	8649	+ case 674LLU: // return from FindLetNew to findletmut
8614	8650	{
8615	8651	// copy mutable arguments back from call to FindLetNew
8616	8652	// copy back results provided by call to FindLetNew

		@@ -8617,7 +8653,7 @@
8617	8653	stack[base + 5] = stack[base + 9LLU];
8618	8654	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8619	8655	{
8620		- label = 670LLU; // jump to alternative
	8656	+ label = 676LLU; // jump to alternative
8621	8657	break;
8622	8658	}
8623	8659

		@@ -8628,23 +8664,23 @@
8628	8664	/substruct/stack[base + 10] = ((uint64_t *)(stack[base + 5]/letdef/))[1][4]/substruct*/;
8629	8665
8630	8666	// case
8631		- label = 673LLU; // skip deleter
	8667	+ label = 679LLU; // skip deleter
8632	8668	break;
8633	8669	}
8634		- case 672LLU: // deleter
	8670	+ case 678LLU: // deleter
8635	8671	{
8636	8672	// throw from findletmut
8637	8673	if(!stack[base + 0])
8638	8674	{
8639	8675	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
8641	8677	break;
8642	8678	}
8643	8679	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
8645	8681	break;
8646	8682	}
8647		- case 673LLU: // skipped deleter
	8683	+ case 679LLU: // skipped deleter
8648	8684	{
8649	8685	stack[base + 0] = stack[base + 9]/mutable/;
8650	8686	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];

		@@ -8652,10 +8688,10 @@
8652	8688	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8653	8689	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8654	8690	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8655		- label = 669LLU; // case complete
	8691	+ label = 675LLU; // case complete
8656	8692	break;
8657	8693	}
8658		- case 671LLU: // copy-back deleter (switch)
	8694	+ case 677LLU: // copy-back deleter (switch)
8659	8695	{
8660	8696	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
8661	8697	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];

		@@ -8662,15 +8698,15 @@
8662	8698	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8663	8699	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8664	8700	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8665		- label = 666LLU; // continue to unroll stack
	8701	+ label = 672LLU; // continue to unroll stack
8666	8702	break;
8667	8703	}
8668		- case 670LLU: // try next case
	8704	+ case 676LLU: // try next case
8669	8705	{
8670	8706	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8671	8707	exit(-1);
8672	8708	}
8673		- case 669LLU: // completed switch
	8709	+ case 675LLU: // completed switch
8674	8710	{
8675	8711
8676	8712	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8678,14 +8714,14 @@
8678	8714	newstack[0] = (uint64_t)stack; // backup stack location
8679	8715	newstack[1] = 1234567890;
8680	8716	newstack[2] = base;
8681		- newstack[3] = 674LLU;
	8717	+ newstack[3] = 680LLU;
8682	8718	stack = newstack;
8683	8719	// set stack-base & callee-address
8684	8720	base = 4/deloffset/;
8685		- label = 455LLU; // ~letdef
	8721	+ label = 457LLU; // ~letdef
8686	8722	break;
8687	8723	}
8688		- case 674LLU: // return from ~letdef to findletmut
	8724	+ case 680LLU: // return from ~letdef to findletmut
8689	8725	{
8690	8726	stack = (uint64_t *)stack[0];
8691	8727	// releasing toplevel container

		@@ -8696,7 +8732,7 @@
8696	8732	base = stack[base - 2];
8697	8733	break;
8698	8734	}
8699		- case 676LLU: // function assertvar failed
	8735	+ case 682LLU: // function assertvar failed
8700	8736	{
8701	8737	fprintf(stderr, "function assertvar failed\n");
8702	8738	label = stack[base - 3];

		@@ -8703,7 +8739,7 @@
8703	8739	base = stack[base - 2];
8704	8740	break;
8705	8741	}
8706		- case 675LLU: // assertvar
	8742	+ case 681LLU: // assertvar
8707	8743	{
8708	8744	//#define arg0 0
8709	8745	//#define arg1 1

		@@ -8710,9 +8746,9 @@
8710	8746	//#define arg2 2
8711	8747	//#define arg3 3
8712	8748	// call findletidx from assertvar
8713		- stack[base + 5LLU] = 677LLU/throw to this address/;
	8749	+ stack[base + 5LLU] = 683LLU/throw to this address/;
8714	8750	stack[base + 6LLU] = base;
8715		- stack[base + 7LLU] = 678LLU;
	8751	+ stack[base + 7LLU] = 684LLU;
8716	8752	// arguments for call to findletidx
8717	8753	stack[base + 9LLU] = stack[base + 0]/fnid/;
8718	8754	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8720,17 +8756,17 @@
8720	8756	stack[base + 12LLU] = stack[base + 3]/scope/;
8721	8757	// set stack-base & callee-address
8722	8758	base += 8LLU;
8723		- label = 655LLU; // findletidx
	8759	+ label = 661LLU; // findletidx
8724	8760	break;
8725	8761	}
8726		- case 677LLU: // copy-back deleter (findletidx to assertvar)
	8762	+ case 683LLU: // copy-back deleter (findletidx to assertvar)
8727	8763	{
8728	8764	fprintf(stderr, "in function assertvar: unrolling stack, copy-back (findletidx to assertvar)\n");
8729	8765	// copy mutable arguments back from call to findletidx
8730		- label = 676LLU; // continue to roll stack
	8766	+ label = 682LLU; // continue to roll stack
8731	8767	break;
8732	8768	}
8733		- case 678LLU: // return from findletidx to assertvar
	8769	+ case 684LLU: // return from findletidx to assertvar
8734	8770	{
8735	8771	// copy mutable arguments back from call to findletidx
8736	8772	// copy back results provided by call to findletidx

		@@ -8740,7 +8776,7 @@
8740	8776	base = stack[base - 2];
8741	8777	break;
8742	8778	}
8743		- case 680LLU: // function emitindex failed
	8779	+ case 686LLU: // function emitindex failed
8744	8780	{
8745	8781	fprintf(stderr, "function emitindex failed\n");
8746	8782	label = stack[base - 3];

		@@ -8747,7 +8783,7 @@
8747	8783	base = stack[base - 2];
8748	8784	break;
8749	8785	}
8750		- case 679LLU: // emitindex
	8786	+ case 685LLU: // emitindex
8751	8787	{
8752	8788	//#define arg0 0
8753	8789	//#define arg1 1

		@@ -8754,9 +8790,9 @@
8754	8790	//#define arg2 2
8755	8791	//#define arg3 3
8756	8792	// call findletidx from emitindex
8757		- stack[base + 5LLU] = 681LLU/throw to this address/;
	8793	+ stack[base + 5LLU] = 687LLU/throw to this address/;
8758	8794	stack[base + 6LLU] = base;
8759		- stack[base + 7LLU] = 682LLU;
	8795	+ stack[base + 7LLU] = 688LLU;
8760	8796	// arguments for call to findletidx
8761	8797	stack[base + 9LLU] = stack[base + 0]/fnid/;
8762	8798	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8764,25 +8800,25 @@
8764	8800	stack[base + 12LLU] = stack[base + 3]/scope/;
8765	8801	// set stack-base & callee-address
8766	8802	base += 8LLU;
8767		- label = 655LLU; // findletidx
	8803	+ label = 661LLU; // findletidx
8768	8804	break;
8769	8805	}
8770		- case 681LLU: // copy-back deleter (findletidx to emitindex)
	8806	+ case 687LLU: // copy-back deleter (findletidx to emitindex)
8771	8807	{
8772	8808	fprintf(stderr, "in function emitindex: unrolling stack, copy-back (findletidx to emitindex)\n");
8773	8809	// copy mutable arguments back from call to findletidx
8774		- label = 680LLU; // continue to roll stack
	8810	+ label = 686LLU; // continue to roll stack
8775	8811	break;
8776	8812	}
8777		- case 682LLU: // return from findletidx to emitindex
	8813	+ case 688LLU: // return from findletidx to emitindex
8778	8814	{
8779	8815	// copy mutable arguments back from call to findletidx
8780	8816	// copy back results provided by call to findletidx
8781	8817	stack[base + 4] = stack[base + 8LLU];
8782	8818	// call printnr from emitindex
8783		- stack[base + 5LLU] = 683LLU/throw to this address/;
	8819	+ stack[base + 5LLU] = 689LLU/throw to this address/;
8784	8820	stack[base + 6LLU] = base;
8785		- stack[base + 7LLU] = 684LLU;
	8821	+ stack[base + 7LLU] = 690LLU;
8786	8822	// arguments for call to printnr
8787	8823	stack[base + 8LLU] = stack[base + 4]/index/;
8788	8824	// set stack-base & callee-address

		@@ -8790,14 +8826,14 @@
8790	8826	label = 18446744073709551590LLU; // printnr
8791	8827	break;
8792	8828	}
8793		- case 683LLU: // copy-back deleter (printnr to emitindex)
	8829	+ case 689LLU: // copy-back deleter (printnr to emitindex)
8794	8830	{
8795	8831	fprintf(stderr, "in function emitindex: unrolling stack, copy-back (printnr to emitindex)\n");
8796	8832	// copy mutable arguments back from call to printnr
8797		- label = 680LLU; // continue to roll stack
	8833	+ label = 686LLU; // continue to roll stack
8798	8834	break;
8799	8835	}
8800		- case 684LLU: // return from printnr to emitindex
	8836	+ case 690LLU: // return from printnr to emitindex
8801	8837	{
8802	8838	// copy mutable arguments back from call to printnr
8803	8839	// return from emitindex

		@@ -8805,7 +8841,7 @@
8805	8841	base = stack[base - 2];
8806	8842	break;
8807	8843	}
8808		- case 686LLU: // function emitvaridx failed
	8844	+ case 692LLU: // function emitvaridx failed
8809	8845	{
8810	8846	fprintf(stderr, "function emitvaridx failed\n");
8811	8847	label = stack[base - 3];

		@@ -8812,14 +8848,14 @@
8812	8848	base = stack[base - 2];
8813	8849	break;
8814	8850	}
8815		- case 685LLU: // emitvaridx
	8851	+ case 691LLU: // emitvaridx
8816	8852	{
8817	8853	//#define arg0 0
8818	8854	printf("%s", "stack[base + ");
8819	8855	// call printnr from emitvaridx
8820		- stack[base + 1LLU] = 687LLU/throw to this address/;
	8856	+ stack[base + 1LLU] = 693LLU/throw to this address/;
8821	8857	stack[base + 2LLU] = base;
8822		- stack[base + 3LLU] = 688LLU;
	8858	+ stack[base + 3LLU] = 694LLU;
8823	8859	// arguments for call to printnr
8824	8860	stack[base + 4LLU] = stack[base + 0]/index/;
8825	8861	// set stack-base & callee-address

		@@ -8827,14 +8863,14 @@
8827	8863	label = 18446744073709551590LLU; // printnr
8828	8864	break;
8829	8865	}
8830		- case 687LLU: // copy-back deleter (printnr to emitvaridx)
	8866	+ case 693LLU: // copy-back deleter (printnr to emitvaridx)
8831	8867	{
8832	8868	fprintf(stderr, "in function emitvaridx: unrolling stack, copy-back (printnr to emitvaridx)\n");
8833	8869	// copy mutable arguments back from call to printnr
8834		- label = 686LLU; // continue to roll stack
	8870	+ label = 692LLU; // continue to roll stack
8835	8871	break;
8836	8872	}
8837		- case 688LLU: // return from printnr to emitvaridx
	8873	+ case 694LLU: // return from printnr to emitvaridx
8838	8874	{
8839	8875	// copy mutable arguments back from call to printnr
8840	8876	printf("%s", "]");

		@@ -8843,7 +8879,7 @@
8843	8879	base = stack[base - 2];
8844	8880	break;
8845	8881	}
8846		- case 690LLU: // function emitvar failed
	8882	+ case 696LLU: // function emitvar failed
8847	8883	{
8848	8884	fprintf(stderr, "function emitvar failed\n");
8849	8885	label = stack[base - 3];

		@@ -8850,7 +8886,7 @@
8850	8886	base = stack[base - 2];
8851	8887	break;
8852	8888	}
8853		- case 689LLU: // emitvar
	8889	+ case 695LLU: // emitvar
8854	8890	{
8855	8891	//#define arg0 0
8856	8892	//#define arg1 1

		@@ -8857,9 +8893,9 @@
8857	8893	//#define arg2 2
8858	8894	//#define arg3 3
8859	8895	// call findletidx from emitvar
8860		- stack[base + 5LLU] = 691LLU/throw to this address/;
	8896	+ stack[base + 5LLU] = 697LLU/throw to this address/;
8861	8897	stack[base + 6LLU] = base;
8862		- stack[base + 7LLU] = 692LLU;
	8898	+ stack[base + 7LLU] = 698LLU;
8863	8899	// arguments for call to findletidx
8864	8900	stack[base + 9LLU] = stack[base + 0]/fnid/;
8865	8901	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8867,47 +8903,47 @@
8867	8903	stack[base + 12LLU] = stack[base + 3]/scope/;
8868	8904	// set stack-base & callee-address
8869	8905	base += 8LLU;
8870		- label = 655LLU; // findletidx
	8906	+ label = 661LLU; // findletidx
8871	8907	break;
8872	8908	}
8873		- case 691LLU: // copy-back deleter (findletidx to emitvar)
	8909	+ case 697LLU: // copy-back deleter (findletidx to emitvar)
8874	8910	{
8875	8911	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (findletidx to emitvar)\n");
8876	8912	// copy mutable arguments back from call to findletidx
8877		- label = 690LLU; // continue to roll stack
	8913	+ label = 696LLU; // continue to roll stack
8878	8914	break;
8879	8915	}
8880		- case 692LLU: // return from findletidx to emitvar
	8916	+ case 698LLU: // return from findletidx to emitvar
8881	8917	{
8882	8918	// copy mutable arguments back from call to findletidx
8883	8919	// copy back results provided by call to findletidx
8884	8920	stack[base + 4] = stack[base + 8LLU];
8885	8921	// call emitvaridx from emitvar
8886		- stack[base + 5LLU] = 693LLU/throw to this address/;
	8922	+ stack[base + 5LLU] = 699LLU/throw to this address/;
8887	8923	stack[base + 6LLU] = base;
8888		- stack[base + 7LLU] = 694LLU;
	8924	+ stack[base + 7LLU] = 700LLU;
8889	8925	// arguments for call to emitvaridx
8890	8926	stack[base + 8LLU] = stack[base + 4]/index/;
8891	8927	// set stack-base & callee-address
8892	8928	base += 8LLU;
8893		- label = 685LLU; // emitvaridx
	8929	+ label = 691LLU; // emitvaridx
8894	8930	break;
8895	8931	}
8896		- case 693LLU: // copy-back deleter (emitvaridx to emitvar)
	8932	+ case 699LLU: // copy-back deleter (emitvaridx to emitvar)
8897	8933	{
8898	8934	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (emitvaridx to emitvar)\n");
8899	8935	// copy mutable arguments back from call to emitvaridx
8900		- label = 690LLU; // continue to roll stack
	8936	+ label = 696LLU; // continue to roll stack
8901	8937	break;
8902	8938	}
8903		- case 694LLU: // return from emitvaridx to emitvar
	8939	+ case 700LLU: // return from emitvaridx to emitvar
8904	8940	{
8905	8941	// copy mutable arguments back from call to emitvaridx
8906	8942	printf("%s", "/*");
8907	8943	// call printid from emitvar
8908		- stack[base + 5LLU] = 695LLU/throw to this address/;
	8944	+ stack[base + 5LLU] = 701LLU/throw to this address/;
8909	8945	stack[base + 6LLU] = base;
8910		- stack[base + 7LLU] = 696LLU;
	8946	+ stack[base + 7LLU] = 702LLU;
8911	8947	// arguments for call to printid
8912	8948	stack[base + 8LLU] = stack[base + 1]/id/;
8913	8949	// set stack-base & callee-address

		@@ -8915,14 +8951,14 @@
8915	8951	label = 18446744073709551587LLU; // printid
8916	8952	break;
8917	8953	}
8918		- case 695LLU: // copy-back deleter (printid to emitvar)
	8954	+ case 701LLU: // copy-back deleter (printid to emitvar)
8919	8955	{
8920	8956	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (printid to emitvar)\n");
8921	8957	// copy mutable arguments back from call to printid
8922		- label = 690LLU; // continue to roll stack
	8958	+ label = 696LLU; // continue to roll stack
8923	8959	break;
8924	8960	}
8925		- case 696LLU: // return from printid to emitvar
	8961	+ case 702LLU: // return from printid to emitvar
8926	8962	{
8927	8963	// copy mutable arguments back from call to printid
8928	8964	printf("%s", "*/");

		@@ -8931,7 +8967,7 @@
8931	8967	base = stack[base - 2];
8932	8968	break;
8933	8969	}
8934		- case 698LLU: // function newvarraw failed
	8970	+ case 704LLU: // function newvarraw failed
8935	8971	{
8936	8972	fprintf(stderr, "function newvarraw failed\n");
8937	8973	label = stack[base - 3];

		@@ -8938,7 +8974,7 @@
8938	8974	base = stack[base - 2];
8939	8975	break;
8940	8976	}
8941		- case 697LLU: // newvarraw
	8977	+ case 703LLU: // newvarraw
8942	8978	{
8943	8979	//#define res0 0
8944	8980	//#define arg0 1

		@@ -8950,28 +8986,28 @@
8950	8986	//#define arg6 7
8951	8987	//#define arg7 8
8952	8988	//#define arg8 9
8953		- label = 700LLU; // skip deleter
	8989	+ label = 706LLU; // skip deleter
8954	8990	break;
8955	8991	}
8956		- case 699LLU: // deleter
	8992	+ case 705LLU: // deleter
8957	8993	{
8958	8994	// throw from newvarraw
8959	8995	if(!stack[base + 10])
8960	8996	{
8961	8997	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
8963	8999	break;
8964	9000	}
8965	9001	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
8967	9003	break;
8968	9004	}
8969		- case 700LLU: // skipped deleter
	9005	+ case 706LLU: // skipped deleter
8970	9006	{
8971	9007	stack[base + 10] = 0;
8972	9008	if(/scope/0 != ((uint64_t )(stack[base + 8]/scope*/))[0])
8973	9009	{
8974		- label = 702LLU; // jump to alternative
	9010	+ label = 708LLU; // jump to alternative
8975	9011	break;
8976	9012	}
8977	9013

		@@ -8979,29 +9015,29 @@
8979	9015	/letdefs/stack[base + 12] = ((uint64_t *)(stack[base + 8]/scope/))[1][1]/letdefs*/;
8980	9016
8981	9017	// case
8982		- label = 705LLU; // skip deleter
	9018	+ label = 711LLU; // skip deleter
8983	9019	break;
8984	9020	}
8985		- case 704LLU: // deleter
	9021	+ case 710LLU: // deleter
8986	9022	{
8987	9023	// throw from newvarraw
8988	9024	if(!stack[base + 13])
8989	9025	{
8990	9026	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
8992	9028	break;
8993	9029	}
8994	9030	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
8996	9032	break;
8997	9033	}
8998		- case 705LLU: // skipped deleter
	9034	+ case 711LLU: // skipped deleter
8999	9035	{
9000	9036	stack[base + 13] = 0;
9001	9037	// call add from newvarraw
9002		- stack[base + 14LLU] = 706LLU/throw to this address/;
	9038	+ stack[base + 14LLU] = 712LLU/throw to this address/;
9003	9039	stack[base + 15LLU] = base;
9004		- stack[base + 16LLU] = 707LLU;
	9040	+ stack[base + 16LLU] = 713LLU;
9005	9041	// arguments for call to add
9006	9042	stack[base + 18LLU] = stack[base + 4]/fnrescount/;
9007	9043	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -9010,22 +9046,22 @@
9010	9046	label = 18446744073709551605LLU; // add
9011	9047	break;
9012	9048	}
9013		- case 706LLU: // copy-back deleter (add to newvarraw)
	9049	+ case 712LLU: // copy-back deleter (add to newvarraw)
9014	9050	{
9015	9051	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
9016	9052	// copy mutable arguments back from call to add
9017		- label = 704LLU; // continue to roll stack
	9053	+ label = 710LLU; // continue to roll stack
9018	9054	break;
9019	9055	}
9020		- case 707LLU: // return from add to newvarraw
	9056	+ case 713LLU: // return from add to newvarraw
9021	9057	{
9022	9058	// copy mutable arguments back from call to add
9023	9059	// copy back results provided by call to add
9024	9060	stack[base + 13] = stack[base + 17LLU];
9025	9061	// call add from newvarraw
9026		- stack[base + 14LLU] = 708LLU/throw to this address/;
	9062	+ stack[base + 14LLU] = 714LLU/throw to this address/;
9027	9063	stack[base + 15LLU] = base;
9028		- stack[base + 16LLU] = 709LLU;
	9064	+ stack[base + 16LLU] = 715LLU;
9029	9065	// arguments for call to add
9030	9066	stack[base + 18LLU] = stack[base + 5]/fnargcount/;
9031	9067	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -9034,22 +9070,22 @@
9034	9070	label = 18446744073709551605LLU; // add
9035	9071	break;
9036	9072	}
9037		- case 708LLU: // copy-back deleter (add to newvarraw)
	9073	+ case 714LLU: // copy-back deleter (add to newvarraw)
9038	9074	{
9039	9075	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
9040	9076	// copy mutable arguments back from call to add
9041		- label = 704LLU; // continue to roll stack
	9077	+ label = 710LLU; // continue to roll stack
9042	9078	break;
9043	9079	}
9044		- case 709LLU: // return from add to newvarraw
	9080	+ case 715LLU: // return from add to newvarraw
9045	9081	{
9046	9082	// copy mutable arguments back from call to add
9047	9083	// copy back results provided by call to add
9048	9084	stack[base + 13] = stack[base + 17LLU];
9049	9085	// call add from newvarraw
9050		- stack[base + 14LLU] = 710LLU/throw to this address/;
	9086	+ stack[base + 14LLU] = 716LLU/throw to this address/;
9051	9087	stack[base + 15LLU] = base;
9052		- stack[base + 16LLU] = 711LLU;
	9088	+ stack[base + 16LLU] = 717LLU;
9053	9089	// arguments for call to add
9054	9090	stack[base + 18LLU] = stack[base + 7]/varcount/;
9055	9091	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -9058,14 +9094,14 @@
9058	9094	label = 18446744073709551605LLU; // add
9059	9095	break;
9060	9096	}
9061		- case 710LLU: // copy-back deleter (add to newvarraw)
	9097	+ case 716LLU: // copy-back deleter (add to newvarraw)
9062	9098	{
9063	9099	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
9064	9100	// copy mutable arguments back from call to add
9065		- label = 704LLU; // continue to roll stack
	9101	+ label = 710LLU; // continue to roll stack
9066	9102	break;
9067	9103	}
9068		- case 711LLU: // return from add to newvarraw
	9104	+ case 717LLU: // return from add to newvarraw
9069	9105	{
9070	9106	// copy mutable arguments back from call to add
9071	9107	// copy back results provided by call to add

		@@ -9074,7 +9110,7 @@
9074	9110	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
9075	9111	if(!newstack)
9076	9112	{
9077		- label = 704LLU; // throw: begin to unroll stack
	9113	+ label = 710LLU; // throw: begin to unroll stack
9078	9114	break;
9079	9115	}
9080	9116

		@@ -9081,18 +9117,18 @@
9081	9117	newstack[15LLU] = 9876543210LLU; // overflow-marker
9082	9118	// call copytype from newvarraw
9083	9119	newstack[0] = (uint64_t)stack; // backup stack location
9084		- newstack[1] = 712LLU;
	9120	+ newstack[1] = 718LLU;
9085	9121	newstack[2] = base;
9086		- newstack[3] = 713LLU;
	9122	+ newstack[3] = 719LLU;
9087	9123	// arguments for call to copytype
9088	9124	newstack[5LLU] = stack[base + 1]/type/;
9089	9125	stack = newstack;
9090	9126	// set stack-base & callee-address
9091	9127	base = 4/deloffset/;
9092		- label = 326LLU; // copytype
	9128	+ label = 327LLU; // copytype
9093	9129	break;
9094	9130	}
9095		- case 712LLU: // copy-back deleter (copytype to newvarraw)
	9131	+ case 718LLU: // copy-back deleter (copytype to newvarraw)
9096	9132	{
9097	9133	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (copytype to newvarraw)\n");
9098	9134	uint64_t oldstack = (uint64_t )stack[0];

		@@ -9104,10 +9140,10 @@
9104	9140	}
9105	9141	Free(15LLU + 1, sizeof(uint64_t), stack);
9106	9142	stack = oldstack;
9107		- label = 704LLU; // continue to unroll stack
	9143	+ label = 710LLU; // continue to unroll stack
9108	9144	break;
9109	9145	}
9110		- case 713LLU: // return from copytype to newvarraw
	9146	+ case 719LLU: // return from copytype to newvarraw
9111	9147	{
9112	9148	uint64_t oldstack = (uint64_t )stack[0];
9113	9149	// copy mutable arguments back from call to copytype

		@@ -9120,16 +9156,16 @@
9120	9156	}
9121	9157	Free(15LLU + 1, sizeof(uint64_t), stack);
9122	9158	stack = oldstack;
9123		- label = 715LLU; // skip deleter
	9159	+ label = 721LLU; // skip deleter
9124	9160	break;
9125	9161	}
9126		- case 714LLU: // deleter
	9162	+ case 720LLU: // deleter
9127	9163	{
9128	9164	// throw from newvarraw
9129	9165	if(!stack[base + 15])
9130	9166	{
9131	9167	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
9133	9169	break;
9134	9170	}
9135	9171	fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef \n");

		@@ -9139,28 +9175,28 @@
9139	9175	newstack[0] = (uint64_t)stack; // backup stack location
9140	9176	newstack[1] = 1234567890;
9141	9177	newstack[2] = base;
9142		- newstack[3] = 716LLU;
	9178	+ newstack[3] = 722LLU;
9143	9179	stack = newstack;
9144	9180	// set stack-base & callee-address
9145	9181	base = 4/deloffset/;
9146		- label = 455LLU; // ~letdef
	9182	+ label = 457LLU; // ~letdef
9147	9183	break;
9148	9184	}
9149		- case 716LLU: // return from ~letdef to newvarraw
	9185	+ case 722LLU: // return from ~letdef to newvarraw
9150	9186	{
9151	9187	stack = (uint64_t *)stack[0];
9152	9188	// releasing toplevel container
9153	9189	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 15] - sizeof(uint64_t) 4));
9154	9190
9155		- label = 704LLU; // continue unrolling stack, delete next variable
	9191	+ label = 710LLU; // continue unrolling stack, delete next variable
9156	9192	break;
9157	9193	}
9158		- case 715LLU: // skipped deleter
	9194	+ case 721LLU: // skipped deleter
9159	9195	{
9160	9196	// construct letdef.letdef
9161	9197	if(!(stack[base + 15] = construct(5)))
9162	9198	{
9163		- label = 704LLU; // throw: begin to unroll stack
	9199	+ label = 710LLU; // throw: begin to unroll stack
9164	9200	break;
9165	9201	}
9166	9202

		@@ -9184,27 +9220,27 @@
9184	9220	}
9185	9221	((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
9186	9222	((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
9187		- label = 701LLU; // case complete
	9223	+ label = 707LLU; // case complete
9188	9224	break;
9189	9225	}
9190		- case 703LLU: // copy-back deleter (switch)
	9226	+ case 709LLU: // copy-back deleter (switch)
9191	9227	{
9192	9228	((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
9193	9229	((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
9194		- label = 699LLU; // continue to unroll stack
	9230	+ label = 705LLU; // continue to unroll stack
9195	9231	break;
9196	9232	}
9197		- case 702LLU: // try next case
	9233	+ case 708LLU: // try next case
9198	9234	{
9199	9235	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
9200	9236	exit(-1);
9201	9237	}
9202		- case 701LLU: // completed switch
	9238	+ case 707LLU: // completed switch
9203	9239	{
9204	9240	// call add from newvarraw
9205		- stack[base + 11LLU] = 717LLU/throw to this address/;
	9241	+ stack[base + 11LLU] = 723LLU/throw to this address/;
9206	9242	stack[base + 12LLU] = base;
9207		- stack[base + 13LLU] = 718LLU;
	9243	+ stack[base + 13LLU] = 724LLU;
9208	9244	// arguments for call to add
9209	9245	stack[base + 15LLU] = 1LLU;
9210	9246	stack[base + 16LLU] = stack[base + 7]/varcount/;

		@@ -9213,22 +9249,22 @@
9213	9249	label = 18446744073709551605LLU; // add
9214	9250	break;
9215	9251	}
9216		- case 717LLU: // copy-back deleter (add to newvarraw)
	9252	+ case 723LLU: // copy-back deleter (add to newvarraw)
9217	9253	{
9218	9254	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
9219	9255	// copy mutable arguments back from call to add
9220		- label = 699LLU; // continue to roll stack
	9256	+ label = 705LLU; // continue to roll stack
9221	9257	break;
9222	9258	}
9223		- case 718LLU: // return from add to newvarraw
	9259	+ case 724LLU: // return from add to newvarraw
9224	9260	{
9225	9261	// copy mutable arguments back from call to add
9226	9262	// copy back results provided by call to add
9227	9263	stack[base + 7] = stack[base + 14LLU];
9228	9264	// call max from newvarraw
9229		- stack[base + 11LLU] = 719LLU/throw to this address/;
	9265	+ stack[base + 11LLU] = 725LLU/throw to this address/;
9230	9266	stack[base + 12LLU] = base;
9231		- stack[base + 13LLU] = 720LLU;
	9267	+ stack[base + 13LLU] = 726LLU;
9232	9268	// arguments for call to max
9233	9269	stack[base + 15LLU] = stack[base + 7]/varcount/;
9234	9270	stack[base + 16LLU] = stack[base + 6]/fnmaxcount/;

		@@ -9237,35 +9273,35 @@
9237	9273	label = 18446744073709551606LLU; // max
9238	9274	break;
9239	9275	}
9240		- case 719LLU: // copy-back deleter (max to newvarraw)
	9276	+ case 725LLU: // copy-back deleter (max to newvarraw)
9241	9277	{
9242	9278	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (max to newvarraw)\n");
9243	9279	// copy mutable arguments back from call to max
9244		- label = 699LLU; // continue to roll stack
	9280	+ label = 705LLU; // continue to roll stack
9245	9281	break;
9246	9282	}
9247		- case 720LLU: // return from max to newvarraw
	9283	+ case 726LLU: // return from max to newvarraw
9248	9284	{
9249	9285	// copy mutable arguments back from call to max
9250	9286	// copy back results provided by call to max
9251	9287	stack[base + 6] = stack[base + 14LLU];
9252		- label = 722LLU; // skip deleter
	9288	+ label = 728LLU; // skip deleter
9253	9289	break;
9254	9290	}
9255		- case 721LLU: // deleter
	9291	+ case 727LLU: // deleter
9256	9292	{
9257	9293	// throw from newvarraw
9258	9294	if(!stack[base + 0])
9259	9295	{
9260	9296	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
9262	9298	break;
9263	9299	}
9264	9300	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
9266	9302	break;
9267	9303	}
9268		- case 722LLU: // skipped deleter
	9304	+ case 728LLU: // skipped deleter
9269	9305	{
9270	9306	stack[base + 0] = stack[base + 10]/index/;
9271	9307	// return from newvarraw

		@@ -9273,7 +9309,7 @@
9273	9309	base = stack[base - 2];
9274	9310	break;
9275	9311	}
9276		- case 724LLU: // function newvar failed
	9312	+ case 730LLU: // function newvar failed
9277	9313	{
9278	9314	fprintf(stderr, "function newvar failed\n");
9279	9315	label = stack[base - 3];

		@@ -9280,7 +9316,7 @@
9280	9316	base = stack[base - 2];
9281	9317	break;
9282	9318	}
9283		- case 723LLU: // newvar
	9319	+ case 729LLU: // newvar
9284	9320	{
9285	9321	//#define arg0 0
9286	9322	//#define arg1 1

		@@ -9292,9 +9328,9 @@
9292	9328	//#define arg7 7
9293	9329	printf("%s", "\n//#define ");
9294	9330	// call printid from newvar
9295		- stack[base + 8LLU] = 725LLU/throw to this address/;
	9331	+ stack[base + 8LLU] = 731LLU/throw to this address/;
9296	9332	stack[base + 9LLU] = base;
9297		- stack[base + 10LLU] = 726LLU;
	9333	+ stack[base + 10LLU] = 732LLU;
9298	9334	// arguments for call to printid
9299	9335	stack[base + 11LLU] = stack[base + 1]/id/;
9300	9336	// set stack-base & callee-address

		@@ -9302,19 +9338,19 @@
9302	9338	label = 18446744073709551587LLU; // printid
9303	9339	break;
9304	9340	}
9305		- case 725LLU: // copy-back deleter (printid to newvar)
	9341	+ case 731LLU: // copy-back deleter (printid to newvar)
9306	9342	{
9307	9343	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
9308	9344	// copy mutable arguments back from call to printid
9309		- label = 724LLU; // continue to roll stack
	9345	+ label = 730LLU; // continue to roll stack
9310	9346	break;
9311	9347	}
9312		- case 726LLU: // return from printid to newvar
	9348	+ case 732LLU: // return from printid to newvar
9313	9349	{
9314	9350	// copy mutable arguments back from call to printid
9315	9351	if(/scope/0 != ((uint64_t )(stack[base + 7]/scope*/))[0])
9316	9352	{
9317		- label = 728LLU; // jump to alternative
	9353	+ label = 734LLU; // jump to alternative
9318	9354	break;
9319	9355	}
9320	9356

		@@ -9322,29 +9358,29 @@
9322	9358	/letdefs/stack[base + 9] = ((uint64_t *)(stack[base + 7]/scope/))[1][1]/letdefs*/;
9323	9359
9324	9360	// case
9325		- label = 731LLU; // skip deleter
	9361	+ label = 737LLU; // skip deleter
9326	9362	break;
9327	9363	}
9328		- case 730LLU: // deleter
	9364	+ case 736LLU: // deleter
9329	9365	{
9330	9366	// throw from newvar
9331	9367	if(!stack[base + 10])
9332	9368	{
9333	9369	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
9335	9371	break;
9336	9372	}
9337	9373	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
9339	9375	break;
9340	9376	}
9341		- case 731LLU: // skipped deleter
	9377	+ case 737LLU: // skipped deleter
9342	9378	{
9343	9379	stack[base + 10] = 0;
9344	9380	// call add from newvar
9345		- stack[base + 11LLU] = 732LLU/throw to this address/;
	9381	+ stack[base + 11LLU] = 738LLU/throw to this address/;
9346	9382	stack[base + 12LLU] = base;
9347		- stack[base + 13LLU] = 733LLU;
	9383	+ stack[base + 13LLU] = 739LLU;
9348	9384	// arguments for call to add
9349	9385	stack[base + 15LLU] = stack[base + 3]/fnrescount/;
9350	9386	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9353,22 +9389,22 @@
9353	9389	label = 18446744073709551605LLU; // add
9354	9390	break;
9355	9391	}
9356		- case 732LLU: // copy-back deleter (add to newvar)
	9392	+ case 738LLU: // copy-back deleter (add to newvar)
9357	9393	{
9358	9394	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9359	9395	// copy mutable arguments back from call to add
9360		- label = 730LLU; // continue to roll stack
	9396	+ label = 736LLU; // continue to roll stack
9361	9397	break;
9362	9398	}
9363		- case 733LLU: // return from add to newvar
	9399	+ case 739LLU: // return from add to newvar
9364	9400	{
9365	9401	// copy mutable arguments back from call to add
9366	9402	// copy back results provided by call to add
9367	9403	stack[base + 10] = stack[base + 14LLU];
9368	9404	// call add from newvar
9369		- stack[base + 11LLU] = 734LLU/throw to this address/;
	9405	+ stack[base + 11LLU] = 740LLU/throw to this address/;
9370	9406	stack[base + 12LLU] = base;
9371		- stack[base + 13LLU] = 735LLU;
	9407	+ stack[base + 13LLU] = 741LLU;
9372	9408	// arguments for call to add
9373	9409	stack[base + 15LLU] = stack[base + 4]/fnargcount/;
9374	9410	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9377,22 +9413,22 @@
9377	9413	label = 18446744073709551605LLU; // add
9378	9414	break;
9379	9415	}
9380		- case 734LLU: // copy-back deleter (add to newvar)
	9416	+ case 740LLU: // copy-back deleter (add to newvar)
9381	9417	{
9382	9418	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9383	9419	// copy mutable arguments back from call to add
9384		- label = 730LLU; // continue to roll stack
	9420	+ label = 736LLU; // continue to roll stack
9385	9421	break;
9386	9422	}
9387		- case 735LLU: // return from add to newvar
	9423	+ case 741LLU: // return from add to newvar
9388	9424	{
9389	9425	// copy mutable arguments back from call to add
9390	9426	// copy back results provided by call to add
9391	9427	stack[base + 10] = stack[base + 14LLU];
9392	9428	// call add from newvar
9393		- stack[base + 11LLU] = 736LLU/throw to this address/;
	9429	+ stack[base + 11LLU] = 742LLU/throw to this address/;
9394	9430	stack[base + 12LLU] = base;
9395		- stack[base + 13LLU] = 737LLU;
	9431	+ stack[base + 13LLU] = 743LLU;
9396	9432	// arguments for call to add
9397	9433	stack[base + 15LLU] = stack[base + 6]/varcount/;
9398	9434	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9401,14 +9437,14 @@
9401	9437	label = 18446744073709551605LLU; // add
9402	9438	break;
9403	9439	}
9404		- case 736LLU: // copy-back deleter (add to newvar)
	9440	+ case 742LLU: // copy-back deleter (add to newvar)
9405	9441	{
9406	9442	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9407	9443	// copy mutable arguments back from call to add
9408		- label = 730LLU; // continue to roll stack
	9444	+ label = 736LLU; // continue to roll stack
9409	9445	break;
9410	9446	}
9411		- case 737LLU: // return from add to newvar
	9447	+ case 743LLU: // return from add to newvar
9412	9448	{
9413	9449	// copy mutable arguments back from call to add
9414	9450	// copy back results provided by call to add

		@@ -9415,9 +9451,9 @@
9415	9451	stack[base + 10] = stack[base + 14LLU];
9416	9452	printf("%s", " ");
9417	9453	// call printnr from newvar
9418		- stack[base + 11LLU] = 738LLU/throw to this address/;
	9454	+ stack[base + 11LLU] = 744LLU/throw to this address/;
9419	9455	stack[base + 12LLU] = base;
9420		- stack[base + 13LLU] = 739LLU;
	9456	+ stack[base + 13LLU] = 745LLU;
9421	9457	// arguments for call to printnr
9422	9458	stack[base + 14LLU] = stack[base + 10]/sum/;
9423	9459	// set stack-base & callee-address

		@@ -9425,20 +9461,20 @@
9425	9461	label = 18446744073709551590LLU; // printnr
9426	9462	break;
9427	9463	}
9428		- case 738LLU: // copy-back deleter (printnr to newvar)
	9464	+ case 744LLU: // copy-back deleter (printnr to newvar)
9429	9465	{
9430	9466	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
9431	9467	// copy mutable arguments back from call to printnr
9432		- label = 730LLU; // continue to roll stack
	9468	+ label = 736LLU; // continue to roll stack
9433	9469	break;
9434	9470	}
9435		- case 739LLU: // return from printnr to newvar
	9471	+ case 745LLU: // return from printnr to newvar
9436	9472	{
9437	9473	// copy mutable arguments back from call to printnr
9438	9474	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
9439	9475	if(!newstack)
9440	9476	{
9441		- label = 730LLU; // throw: begin to unroll stack
	9477	+ label = 736LLU; // throw: begin to unroll stack
9442	9478	break;
9443	9479	}
9444	9480

		@@ -9445,18 +9481,18 @@
9445	9481	newstack[15LLU] = 9876543210LLU; // overflow-marker
9446	9482	// call copytype from newvar
9447	9483	newstack[0] = (uint64_t)stack; // backup stack location
9448		- newstack[1] = 740LLU;
	9484	+ newstack[1] = 746LLU;
9449	9485	newstack[2] = base;
9450		- newstack[3] = 741LLU;
	9486	+ newstack[3] = 747LLU;
9451	9487	// arguments for call to copytype
9452	9488	newstack[5LLU] = stack[base + 0]/type/;
9453	9489	stack = newstack;
9454	9490	// set stack-base & callee-address
9455	9491	base = 4/deloffset/;
9456		- label = 326LLU; // copytype
	9492	+ label = 327LLU; // copytype
9457	9493	break;
9458	9494	}
9459		- case 740LLU: // copy-back deleter (copytype to newvar)
	9495	+ case 746LLU: // copy-back deleter (copytype to newvar)
9460	9496	{
9461	9497	fprintf(stderr, "in function newvar: unrolling stack, copy-back (copytype to newvar)\n");
9462	9498	uint64_t oldstack = (uint64_t )stack[0];

		@@ -9468,10 +9504,10 @@
9468	9504	}
9469	9505	Free(15LLU + 1, sizeof(uint64_t), stack);
9470	9506	stack = oldstack;
9471		- label = 730LLU; // continue to unroll stack
	9507	+ label = 736LLU; // continue to unroll stack
9472	9508	break;
9473	9509	}
9474		- case 741LLU: // return from copytype to newvar
	9510	+ case 747LLU: // return from copytype to newvar
9475	9511	{
9476	9512	uint64_t oldstack = (uint64_t )stack[0];
9477	9513	// copy mutable arguments back from call to copytype

		@@ -9484,35 +9520,35 @@
9484	9520	}
9485	9521	Free(15LLU + 1, sizeof(uint64_t), stack);
9486	9522	stack = oldstack;
9487		- label = 743LLU; // skip deleter
	9523	+ label = 749LLU; // skip deleter
9488	9524	break;
9489	9525	}
9490		- case 742LLU: // deleter
	9526	+ case 748LLU: // deleter
9491	9527	{
9492	9528	// throw from newvar
9493	9529	if(!stack[base + 12])
9494	9530	{
9495	9531	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
9497	9533	break;
9498	9534	}
9499	9535	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
9501	9537	break;
9502	9538	}
9503		- case 743LLU: // skipped deleter
	9539	+ case 749LLU: // skipped deleter
9504	9540	{
9505	9541	stack[base + 12] = 0;
9506		- label = 745LLU; // skip deleter
	9542	+ label = 751LLU; // skip deleter
9507	9543	break;
9508	9544	}
9509		- case 744LLU: // deleter
	9545	+ case 750LLU: // deleter
9510	9546	{
9511	9547	// throw from newvar
9512	9548	if(!stack[base + 13])
9513	9549	{
9514	9550	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
9516	9552	break;
9517	9553	}
9518	9554	fprintf(stderr, "in function newvar: unrolling stack, variable letdef \n");

		@@ -9522,28 +9558,28 @@
9522	9558	newstack[0] = (uint64_t)stack; // backup stack location
9523	9559	newstack[1] = 1234567890;
9524	9560	newstack[2] = base;
9525		- newstack[3] = 746LLU;
	9561	+ newstack[3] = 752LLU;
9526	9562	stack = newstack;
9527	9563	// set stack-base & callee-address
9528	9564	base = 4/deloffset/;
9529		- label = 455LLU; // ~letdef
	9565	+ label = 457LLU; // ~letdef
9530	9566	break;
9531	9567	}
9532		- case 746LLU: // return from ~letdef to newvar
	9568	+ case 752LLU: // return from ~letdef to newvar
9533	9569	{
9534	9570	stack = (uint64_t *)stack[0];
9535	9571	// releasing toplevel container
9536	95