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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisão	1171 (tree)
Hora	2021-02-24 07:30:28
Autor	jakobthomsen

Mensagem de Log

cleanup

Mudança Sumário

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

Diff

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

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

		@@ -27413,160 +27413,129 @@
27413	27413	base = stack[base - 2];
27414	27414	break;
27415	27415	}
27416		- case 2254LLU: // function initfrom failed
	27416	+ case 2254LLU: // function emitdelete failed
27417	27417	{
27418		- fprintf(stderr, "function initfrom failed\n");
	27418	+ fprintf(stderr, "function emitdelete failed\n");
27419	27419	label = stack[base - 3];
27420	27420	base = stack[base - 2];
27421	27421	break;
27422	27422	}
27423		- case 2253LLU: // initfrom
	27423	+ case 2253LLU: // emitdelete
27424	27424	{
27425		-//#define arg0 0
27426		-//#define arg1 1
27427		-//#define arg2 2
27428		-//#define arg3 3
27429		-//#define arg4 4
27430		-//#define arg5 5
27431		-//#define arg6 6
27432		-//#define arg7 7
27433		-//#define arg8 8
27434		-//#define arg9 9
27435		- label = 2256LLU; // skip deleter
27436		- break;
27437		- }
27438		- case 2255LLU: // deleter
27439		- {
27440		- // throw from initfrom
27441		- if(!stack[base + 10])
27442		- {
27443		- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
27444		- label = 2254LLU; // skip, variable already deleted/unscoped
27445		- break;
27446		- }
27447		- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 isequal\n");
27448		- label = 2254LLU; // continue unrolling stack, delete next variable
27449		- break;
27450		- }
27451		- case 2256LLU: // skipped deleter
27452		- {
27453		- stack[base + 10] = 0;
27454		- // call add from initfrom
27455		- stack[base + 11LLU] = 2257LLU/throw to this address/;
27456		- stack[base + 12LLU] = base;
27457		- stack[base + 13LLU] = 2258LLU;
	27425	+//#define res0 0
	27426	+//#define arg0 1
	27427	+//#define arg1 2
	27428	+//#define arg2 3
	27429	+//#define arg3 4
	27430	+//#define arg4 5
	27431	+//#define arg5 6
	27432	+//#define arg6 7
	27433	+ // call add from emitdelete
	27434	+ stack[base + 8LLU] = 2255LLU/throw to this address/;
	27435	+ stack[base + 9LLU] = base;
	27436	+ stack[base + 10LLU] = 2256LLU;
27458	27437	// arguments for call to add
27459		- stack[base + 15LLU] = 1LLU;
27460		- stack[base + 16LLU] = stack[base + 8]/label/;
	27438	+ stack[base + 12LLU] = 1LLU;
	27439	+ stack[base + 13LLU] = stack[base + 7]/label/;
27461	27440	// set stack-base & callee-address
27462		- base += 14LLU;
	27441	+ base += 11LLU;
27463	27442	label = 18446744073709551605LLU; // add
27464	27443	break;
27465	27444	}
27466		- case 2257LLU: // copy-back deleter (add to initfrom)
	27445	+ case 2255LLU: // copy-back deleter (add to emitdelete)
27467	27446	{
27468		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
	27447	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (add to emitdelete)\n");
27469	27448	// copy mutable arguments back from call to add
27470		- label = 2255LLU; // continue to roll stack
	27449	+ label = 2254LLU; // continue to roll stack
27471	27450	break;
27472	27451	}
27473		- case 2258LLU: // return from add to initfrom
	27452	+ case 2256LLU: // return from add to emitdelete
27474	27453	{
27475	27454	// copy mutable arguments back from call to add
27476	27455	// copy back results provided by call to add
27477		- stack[base + 8] = stack[base + 14LLU];
27478		- label = 2260LLU; // skip deleter
	27456	+ stack[base + 7] = stack[base + 11LLU];
	27457	+ label = 2258LLU; // skip deleter
27479	27458	break;
27480	27459	}
27481		- case 2259LLU: // deleter
	27460	+ case 2257LLU: // deleter
27482	27461	{
27483		- // throw from initfrom
27484		- if(!stack[base + 11])
	27462	+ // throw from emitdelete
	27463	+ if(!stack[base + 8])
27485	27464	{
27486		- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
27487		- label = 2255LLU; // skip, variable already deleted/unscoped
	27465	+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 labelfail\n");
	27466	+ label = 2254LLU; // skip, variable already deleted/unscoped
27488	27467	break;
27489	27468	}
27490		- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelfail\n");
27491		- label = 2255LLU; // continue unrolling stack, delete next variable
	27469	+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 labelfail\n");
	27470	+ label = 2254LLU; // continue unrolling stack, delete next variable
27492	27471	break;
27493	27472	}
27494		- case 2260LLU: // skipped deleter
	27473	+ case 2258LLU: // skipped deleter
27495	27474	{
27496		- stack[base + 11] = stack[base + 8]/label/;
27497		- if(/scope/0 != ((uint64_t )(stack[base + 6]/scope*/))[0])
27498		- {
27499		- label = 2262LLU; // jump to alternative
27500		- break;
27501		- }
27502		-
27503		- /labelthrow/stack[base + 12] = ((uint64_t *)(stack[base + 6]/scope/))[1][0]/deleteaddr*/;
27504		- /dummy/stack[base + 13] = ((uint64_t *)(stack[base + 6]/scope/))[1][1]/letdefs*/;
27505		-
27506		- // case
27507		- // call add from initfrom
27508		- stack[base + 14LLU] = 2264LLU/throw to this address/;
27509		- stack[base + 15LLU] = base;
27510		- stack[base + 16LLU] = 2265LLU;
	27475	+ stack[base + 8] = stack[base + 7]/label/;
	27476	+ // call add from emitdelete
	27477	+ stack[base + 9LLU] = 2259LLU/throw to this address/;
	27478	+ stack[base + 10LLU] = base;
	27479	+ stack[base + 11LLU] = 2260LLU;
27511	27480	// arguments for call to add
27512		- stack[base + 18LLU] = 1LLU;
27513		- stack[base + 19LLU] = stack[base + 8]/label/;
	27481	+ stack[base + 13LLU] = 1LLU;
	27482	+ stack[base + 14LLU] = stack[base + 7]/label/;
27514	27483	// set stack-base & callee-address
27515		- base += 17LLU;
	27484	+ base += 12LLU;
27516	27485	label = 18446744073709551605LLU; // add
27517	27486	break;
27518	27487	}
27519		- case 2264LLU: // copy-back deleter (add to initfrom)
	27488	+ case 2259LLU: // copy-back deleter (add to emitdelete)
27520	27489	{
27521		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
	27490	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (add to emitdelete)\n");
27522	27491	// copy mutable arguments back from call to add
27523		- label = 2263LLU; // continue to roll stack
	27492	+ label = 2257LLU; // continue to roll stack
27524	27493	break;
27525	27494	}
27526		- case 2265LLU: // return from add to initfrom
	27495	+ case 2260LLU: // return from add to emitdelete
27527	27496	{
27528	27497	// copy mutable arguments back from call to add
27529	27498	// copy back results provided by call to add
27530		- stack[base + 8] = stack[base + 17LLU];
27531		- label = 2267LLU; // skip deleter
	27499	+ stack[base + 7] = stack[base + 12LLU];
	27500	+ label = 2262LLU; // skip deleter
27532	27501	break;
27533	27502	}
27534		- case 2266LLU: // deleter
	27503	+ case 2261LLU: // deleter
27535	27504	{
27536		- // throw from initfrom
27537		- if(!stack[base + 14])
	27505	+ // throw from emitdelete
	27506	+ if(!stack[base + 9])
27538	27507	{
27539		- fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
27540		- label = 2263LLU; // skip, variable already deleted/unscoped
	27508	+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 labelskip\n");
	27509	+ label = 2257LLU; // skip, variable already deleted/unscoped
27541	27510	break;
27542	27511	}
27543		- fprintf(stderr, "in function initfrom: unrolling stack, variable u64 labelskip\n");
27544		- label = 2263LLU; // continue unrolling stack, delete next variable
	27512	+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 labelskip\n");
	27513	+ label = 2257LLU; // continue unrolling stack, delete next variable
27545	27514	break;
27546	27515	}
27547		- case 2267LLU: // skipped deleter
	27516	+ case 2262LLU: // skipped deleter
27548	27517	{
27549		- stack[base + 14] = stack[base + 8]/label/;
	27518	+ stack[base + 9] = stack[base + 7]/label/;
27550	27519	printf("%s", "\n label = ");
27551		- // call printnr from initfrom
27552		- stack[base + 15LLU] = 2268LLU/throw to this address/;
27553		- stack[base + 16LLU] = base;
27554		- stack[base + 17LLU] = 2269LLU;
	27520	+ // call printnr from emitdelete
	27521	+ stack[base + 10LLU] = 2263LLU/throw to this address/;
	27522	+ stack[base + 11LLU] = base;
	27523	+ stack[base + 12LLU] = 2264LLU;
27555	27524	// arguments for call to printnr
27556		- stack[base + 18LLU] = stack[base + 14]/labelskip/;
	27525	+ stack[base + 13LLU] = stack[base + 9]/labelskip/;
27557	27526	// set stack-base & callee-address
27558		- base += 18LLU;
	27527	+ base += 13LLU;
27559	27528	label = 18446744073709551590LLU; // printnr
27560	27529	break;
27561	27530	}
27562		- case 2268LLU: // copy-back deleter (printnr to initfrom)
	27531	+ case 2263LLU: // copy-back deleter (printnr to emitdelete)
27563	27532	{
27564		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
	27533	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
27565	27534	// copy mutable arguments back from call to printnr
27566		- label = 2266LLU; // continue to roll stack
	27535	+ label = 2261LLU; // continue to roll stack
27567	27536	break;
27568	27537	}
27569		- case 2269LLU: // return from printnr to initfrom
	27538	+ case 2264LLU: // return from printnr to emitdelete
27570	27539	{
27571	27540	// copy mutable arguments back from call to printnr
27572	27541	printf("%s", "LLU; // skip deleter");

		@@ -27573,95 +27542,95 @@
27573	27542	printf("%s", "\n break;");
27574	27543	printf("%s", "\n }");
27575	27544	printf("%s", "\n case ");
27576		- // call printnr from initfrom
27577		- stack[base + 15LLU] = 2270LLU/throw to this address/;
27578		- stack[base + 16LLU] = base;
27579		- stack[base + 17LLU] = 2271LLU;
	27545	+ // call printnr from emitdelete
	27546	+ stack[base + 10LLU] = 2265LLU/throw to this address/;
	27547	+ stack[base + 11LLU] = base;
	27548	+ stack[base + 12LLU] = 2266LLU;
27580	27549	// arguments for call to printnr
27581		- stack[base + 18LLU] = stack[base + 11]/labelfail/;
	27550	+ stack[base + 13LLU] = stack[base + 8]/labelfail/;
27582	27551	// set stack-base & callee-address
27583		- base += 18LLU;
	27552	+ base += 13LLU;
27584	27553	label = 18446744073709551590LLU; // printnr
27585	27554	break;
27586	27555	}
27587		- case 2270LLU: // copy-back deleter (printnr to initfrom)
	27556	+ case 2265LLU: // copy-back deleter (printnr to emitdelete)
27588	27557	{
27589		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
	27558	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
27590	27559	// copy mutable arguments back from call to printnr
27591		- label = 2266LLU; // continue to roll stack
	27560	+ label = 2261LLU; // continue to roll stack
27592	27561	break;
27593	27562	}
27594		- case 2271LLU: // return from printnr to initfrom
	27563	+ case 2266LLU: // return from printnr to emitdelete
27595	27564	{
27596	27565	// copy mutable arguments back from call to printnr
27597	27566	printf("%s", "LLU: // deleter");
27598	27567	printf("%s", "\n {");
27599	27568	printf("%s", "\n // throw from ");
27600		- // call printid from initfrom
27601		- stack[base + 15LLU] = 2272LLU/throw to this address/;
27602		- stack[base + 16LLU] = base;
27603		- stack[base + 17LLU] = 2273LLU;
	27569	+ // call printid from emitdelete
	27570	+ stack[base + 10LLU] = 2267LLU/throw to this address/;
	27571	+ stack[base + 11LLU] = base;
	27572	+ stack[base + 12LLU] = 2268LLU;
27604	27573	// arguments for call to printid
27605		- stack[base + 18LLU] = stack[base + 0]/fnid/;
	27574	+ stack[base + 13LLU] = stack[base + 1]/fnid/;
27606	27575	// set stack-base & callee-address
27607		- base += 18LLU;
	27576	+ base += 13LLU;
27608	27577	label = 18446744073709551587LLU; // printid
27609	27578	break;
27610	27579	}
27611		- case 2272LLU: // copy-back deleter (printid to initfrom)
	27580	+ case 2267LLU: // copy-back deleter (printid to emitdelete)
27612	27581	{
27613		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
	27582	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
27614	27583	// copy mutable arguments back from call to printid
27615		- label = 2266LLU; // continue to roll stack
	27584	+ label = 2261LLU; // continue to roll stack
27616	27585	break;
27617	27586	}
27618		- case 2273LLU: // return from printid to initfrom
	27587	+ case 2268LLU: // return from printid to emitdelete
27619	27588	{
27620	27589	// copy mutable arguments back from call to printid
27621	27590	printf("%s", "\n if(!");
27622		- // call emitvaridx from initfrom
27623		- stack[base + 15LLU] = 2274LLU/throw to this address/;
27624		- stack[base + 16LLU] = base;
27625		- stack[base + 17LLU] = 2275LLU;
	27591	+ // call emitvaridx from emitdelete
	27592	+ stack[base + 10LLU] = 2269LLU/throw to this address/;
	27593	+ stack[base + 11LLU] = base;
	27594	+ stack[base + 12LLU] = 2270LLU;
27626	27595	// arguments for call to emitvaridx
27627		- stack[base + 18LLU] = stack[base + 3]/dstindex/;
	27596	+ stack[base + 13LLU] = stack[base + 4]/dstindex/;
27628	27597	// set stack-base & callee-address
27629		- base += 18LLU;
	27598	+ base += 13LLU;
27630	27599	label = 691LLU; // emitvaridx
27631	27600	break;
27632	27601	}
27633		- case 2274LLU: // copy-back deleter (emitvaridx to initfrom)
	27602	+ case 2269LLU: // copy-back deleter (emitvaridx to emitdelete)
27634	27603	{
27635		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
	27604	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (emitvaridx to emitdelete)\n");
27636	27605	// copy mutable arguments back from call to emitvaridx
27637		- label = 2266LLU; // continue to roll stack
	27606	+ label = 2261LLU; // continue to roll stack
27638	27607	break;
27639	27608	}
27640		- case 2275LLU: // return from emitvaridx to initfrom
	27609	+ case 2270LLU: // return from emitvaridx to emitdelete
27641	27610	{
27642	27611	// copy mutable arguments back from call to emitvaridx
27643	27612	printf("%s", ")");
27644	27613	printf("%s", "\n {");
27645	27614	printf("%s", "\n fprintf(stderr, \"in function ");
27646		- // call printid from initfrom
27647		- stack[base + 15LLU] = 2276LLU/throw to this address/;
27648		- stack[base + 16LLU] = base;
27649		- stack[base + 17LLU] = 2277LLU;
	27615	+ // call printid from emitdelete
	27616	+ stack[base + 10LLU] = 2271LLU/throw to this address/;
	27617	+ stack[base + 11LLU] = base;
	27618	+ stack[base + 12LLU] = 2272LLU;
27650	27619	// arguments for call to printid
27651		- stack[base + 18LLU] = stack[base + 0]/fnid/;
	27620	+ stack[base + 13LLU] = stack[base + 1]/fnid/;
27652	27621	// set stack-base & callee-address
27653		- base += 18LLU;
	27622	+ base += 13LLU;
27654	27623	label = 18446744073709551587LLU; // printid
27655	27624	break;
27656	27625	}
27657		- case 2276LLU: // copy-back deleter (printid to initfrom)
	27626	+ case 2271LLU: // copy-back deleter (printid to emitdelete)
27658	27627	{
27659		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
	27628	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
27660	27629	// copy mutable arguments back from call to printid
27661		- label = 2266LLU; // continue to roll stack
	27630	+ label = 2261LLU; // continue to roll stack
27662	27631	break;
27663	27632	}
27664		- case 2277LLU: // return from printid to initfrom
	27633	+ case 2272LLU: // return from printid to emitdelete
27665	27634	{
27666	27635	// copy mutable arguments back from call to printid
27667	27636	printf("%s", ": unrolling stack, skipping already deleted/unscoped variable ");

		@@ -27668,18 +27637,18 @@
27668	27637	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
27669	27638	if(!newstack)
27670	27639	{
27671		- label = 2266LLU; // throw: begin to unroll stack
	27640	+ label = 2261LLU; // throw: begin to unroll stack
27672	27641	break;
27673	27642	}
27674	27643
27675	27644	newstack[10LLU] = 9876543210LLU; // overflow-marker
27676		- // call printtype from initfrom
	27645	+ // call printtype from emitdelete
27677	27646	newstack[0] = (uint64_t)stack; // backup stack location
27678		- newstack[1] = 2278LLU;
	27647	+ newstack[1] = 2273LLU;
27679	27648	newstack[2] = base;
27680		- newstack[3] = 2279LLU;
	27649	+ newstack[3] = 2274LLU;
27681	27650	// arguments for call to printtype
27682		- newstack[4LLU] = stack[base + 1]/dsttype/;
	27651	+ newstack[4LLU] = stack[base + 2]/dsttype/;
27683	27652	stack = newstack;
27684	27653	// set stack-base & callee-address
27685	27654	base = 4/deloffset/;

		@@ -27686,9 +27655,9 @@
27686	27655	label = 305LLU; // printtype
27687	27656	break;
27688	27657	}
27689		- case 2278LLU: // copy-back deleter (printtype to initfrom)
	27658	+ case 2273LLU: // copy-back deleter (printtype to emitdelete)
27690	27659	{
27691		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
	27660	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printtype to emitdelete)\n");
27692	27661	uint64_t oldstack = (uint64_t )stack[0];
27693	27662	// copy mutable arguments back from call to printtype
27694	27663	if(stack[10LLU] != 9876543210LLU)

		@@ -27698,10 +27667,10 @@
27698	27667	}
27699	27668	Free(10LLU + 1, sizeof(uint64_t), stack);
27700	27669	stack = oldstack;
27701		- label = 2266LLU; // continue to unroll stack
	27670	+ label = 2261LLU; // continue to unroll stack
27702	27671	break;
27703	27672	}
27704		- case 2279LLU: // return from printtype to initfrom
	27673	+ case 2274LLU: // return from printtype to emitdelete
27705	27674	{
27706	27675	uint64_t oldstack = (uint64_t )stack[0];
27707	27676	// copy mutable arguments back from call to printtype

		@@ -27713,48 +27682,48 @@
27713	27682	Free(10LLU + 1, sizeof(uint64_t), stack);
27714	27683	stack = oldstack;
27715	27684	printf("%s", " ");
27716		- // call printid from initfrom
27717		- stack[base + 15LLU] = 2280LLU/throw to this address/;
27718		- stack[base + 16LLU] = base;
27719		- stack[base + 17LLU] = 2281LLU;
	27685	+ // call printid from emitdelete
	27686	+ stack[base + 10LLU] = 2275LLU/throw to this address/;
	27687	+ stack[base + 11LLU] = base;
	27688	+ stack[base + 12LLU] = 2276LLU;
27720	27689	// arguments for call to printid
27721		- stack[base + 18LLU] = stack[base + 2]/dstid/;
	27690	+ stack[base + 13LLU] = stack[base + 3]/dstid/;
27722	27691	// set stack-base & callee-address
27723		- base += 18LLU;
	27692	+ base += 13LLU;
27724	27693	label = 18446744073709551587LLU; // printid
27725	27694	break;
27726	27695	}
27727		- case 2280LLU: // copy-back deleter (printid to initfrom)
	27696	+ case 2275LLU: // copy-back deleter (printid to emitdelete)
27728	27697	{
27729		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
	27698	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
27730	27699	// copy mutable arguments back from call to printid
27731		- label = 2266LLU; // continue to roll stack
	27700	+ label = 2261LLU; // continue to roll stack
27732	27701	break;
27733	27702	}
27734		- case 2281LLU: // return from printid to initfrom
	27703	+ case 2276LLU: // return from printid to emitdelete
27735	27704	{
27736	27705	// copy mutable arguments back from call to printid
27737	27706	printf("%s", "\\n\");");
27738	27707	printf("%s", "\n label = ");
27739		- // call printnr from initfrom
27740		- stack[base + 15LLU] = 2282LLU/throw to this address/;
27741		- stack[base + 16LLU] = base;
27742		- stack[base + 17LLU] = 2283LLU;
	27708	+ // call printnr from emitdelete
	27709	+ stack[base + 10LLU] = 2277LLU/throw to this address/;
	27710	+ stack[base + 11LLU] = base;
	27711	+ stack[base + 12LLU] = 2278LLU;
27743	27712	// arguments for call to printnr
27744		- stack[base + 18LLU] = stack[base + 12]/labelthrow/;
	27713	+ stack[base + 13LLU] = stack[base + 6]/labelthrow/;
27745	27714	// set stack-base & callee-address
27746		- base += 18LLU;
	27715	+ base += 13LLU;
27747	27716	label = 18446744073709551590LLU; // printnr
27748	27717	break;
27749	27718	}
27750		- case 2282LLU: // copy-back deleter (printnr to initfrom)
	27719	+ case 2277LLU: // copy-back deleter (printnr to emitdelete)
27751	27720	{
27752		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
	27721	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
27753	27722	// copy mutable arguments back from call to printnr
27754		- label = 2266LLU; // continue to roll stack
	27723	+ label = 2261LLU; // continue to roll stack
27755	27724	break;
27756	27725	}
27757		- case 2283LLU: // return from printnr to initfrom
	27726	+ case 2278LLU: // return from printnr to emitdelete
27758	27727	{
27759	27728	// copy mutable arguments back from call to printnr
27760	27729	printf("%s", "LLU; // skip, variable already deleted/unscoped");

		@@ -27761,25 +27730,25 @@
27761	27730	printf("%s", "\n break;");
27762	27731	printf("%s", "\n }");
27763	27732	printf("%s", "\n fprintf(stderr, \"in function ");
27764		- // call printid from initfrom
27765		- stack[base + 15LLU] = 2284LLU/throw to this address/;
27766		- stack[base + 16LLU] = base;
27767		- stack[base + 17LLU] = 2285LLU;
	27733	+ // call printid from emitdelete
	27734	+ stack[base + 10LLU] = 2279LLU/throw to this address/;
	27735	+ stack[base + 11LLU] = base;
	27736	+ stack[base + 12LLU] = 2280LLU;
27768	27737	// arguments for call to printid
27769		- stack[base + 18LLU] = stack[base + 0]/fnid/;
	27738	+ stack[base + 13LLU] = stack[base + 1]/fnid/;
27770	27739	// set stack-base & callee-address
27771		- base += 18LLU;
	27740	+ base += 13LLU;
27772	27741	label = 18446744073709551587LLU; // printid
27773	27742	break;
27774	27743	}
27775		- case 2284LLU: // copy-back deleter (printid to initfrom)
	27744	+ case 2279LLU: // copy-back deleter (printid to emitdelete)
27776	27745	{
27777		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
	27746	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
27778	27747	// copy mutable arguments back from call to printid
27779		- label = 2266LLU; // continue to roll stack
	27748	+ label = 2261LLU; // continue to roll stack
27780	27749	break;
27781	27750	}
27782		- case 2285LLU: // return from printid to initfrom
	27751	+ case 2280LLU: // return from printid to emitdelete
27783	27752	{
27784	27753	// copy mutable arguments back from call to printid
27785	27754	printf("%s", ": unrolling stack, variable ");

		@@ -27786,18 +27755,18 @@
27786	27755	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
27787	27756	if(!newstack)
27788	27757	{
27789		- label = 2266LLU; // throw: begin to unroll stack
	27758	+ label = 2261LLU; // throw: begin to unroll stack
27790	27759	break;
27791	27760	}
27792	27761
27793	27762	newstack[10LLU] = 9876543210LLU; // overflow-marker
27794		- // call printtype from initfrom
	27763	+ // call printtype from emitdelete
27795	27764	newstack[0] = (uint64_t)stack; // backup stack location
27796		- newstack[1] = 2286LLU;
	27765	+ newstack[1] = 2281LLU;
27797	27766	newstack[2] = base;
27798		- newstack[3] = 2287LLU;
	27767	+ newstack[3] = 2282LLU;
27799	27768	// arguments for call to printtype
27800		- newstack[4LLU] = stack[base + 1]/dsttype/;
	27769	+ newstack[4LLU] = stack[base + 2]/dsttype/;
27801	27770	stack = newstack;
27802	27771	// set stack-base & callee-address
27803	27772	base = 4/deloffset/;

		@@ -27804,9 +27773,9 @@
27804	27773	label = 305LLU; // printtype
27805	27774	break;
27806	27775	}
27807		- case 2286LLU: // copy-back deleter (printtype to initfrom)
	27776	+ case 2281LLU: // copy-back deleter (printtype to emitdelete)
27808	27777	{
27809		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
	27778	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printtype to emitdelete)\n");
27810	27779	uint64_t oldstack = (uint64_t )stack[0];
27811	27780	// copy mutable arguments back from call to printtype
27812	27781	if(stack[10LLU] != 9876543210LLU)

		@@ -27816,10 +27785,10 @@
27816	27785	}
27817	27786	Free(10LLU + 1, sizeof(uint64_t), stack);
27818	27787	stack = oldstack;
27819		- label = 2266LLU; // continue to unroll stack
	27788	+ label = 2261LLU; // continue to unroll stack
27820	27789	break;
27821	27790	}
27822		- case 2287LLU: // return from printtype to initfrom
	27791	+ case 2282LLU: // return from printtype to emitdelete
27823	27792	{
27824	27793	uint64_t oldstack = (uint64_t )stack[0];
27825	27794	// copy mutable arguments back from call to printtype

		@@ -27831,25 +27800,25 @@
27831	27800	Free(10LLU + 1, sizeof(uint64_t), stack);
27832	27801	stack = oldstack;
27833	27802	printf("%s", " ");
27834		- // call printid from initfrom
27835		- stack[base + 15LLU] = 2288LLU/throw to this address/;
27836		- stack[base + 16LLU] = base;
27837		- stack[base + 17LLU] = 2289LLU;
	27803	+ // call printid from emitdelete
	27804	+ stack[base + 10LLU] = 2283LLU/throw to this address/;
	27805	+ stack[base + 11LLU] = base;
	27806	+ stack[base + 12LLU] = 2284LLU;
27838	27807	// arguments for call to printid
27839		- stack[base + 18LLU] = stack[base + 2]/dstid/;
	27808	+ stack[base + 13LLU] = stack[base + 3]/dstid/;
27840	27809	// set stack-base & callee-address
27841		- base += 18LLU;
	27810	+ base += 13LLU;
27842	27811	label = 18446744073709551587LLU; // printid
27843	27812	break;
27844	27813	}
27845		- case 2288LLU: // copy-back deleter (printid to initfrom)
	27814	+ case 2283LLU: // copy-back deleter (printid to emitdelete)
27846	27815	{
27847		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
	27816	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printid to emitdelete)\n");
27848	27817	// copy mutable arguments back from call to printid
27849		- label = 2266LLU; // continue to roll stack
	27818	+ label = 2261LLU; // continue to roll stack
27850	27819	break;
27851	27820	}
27852		- case 2289LLU: // return from printid to initfrom
	27821	+ case 2284LLU: // return from printid to emitdelete
27853	27822	{
27854	27823	// copy mutable arguments back from call to printid
27855	27824	printf("%s", "\\n\");");

		@@ -27856,22 +27825,22 @@
27856	27825	uint64_t newstack = (uint64_t )Calloc(75LLU + 1, sizeof(uint64_t));
27857	27826	if(!newstack)
27858	27827	{
27859		- label = 2266LLU; // throw: begin to unroll stack
	27828	+ label = 2261LLU; // throw: begin to unroll stack
27860	27829	break;
27861	27830	}
27862	27831
27863	27832	newstack[75LLU] = 9876543210LLU; // overflow-marker
27864		- // call calldestr from initfrom
	27833	+ // call calldestr from emitdelete
27865	27834	newstack[0] = (uint64_t)stack; // backup stack location
27866		- newstack[1] = 2290LLU;
	27835	+ newstack[1] = 2285LLU;
27867	27836	newstack[2] = base;
27868		- newstack[3] = 2291LLU;
	27837	+ newstack[3] = 2286LLU;
27869	27838	// arguments for call to calldestr
27870		- newstack[4LLU] = stack[base + 0]/fnid/;
27871		- newstack[5LLU] = stack[base + 4]/typedefs/;
27872		- newstack[6LLU] = stack[base + 1]/dsttype/;
27873		- newstack[7LLU] = stack[base + 3]/dstindex/;
27874		- newstack[8LLU] = stack[base + 8]/label/;
	27839	+ newstack[4LLU] = stack[base + 1]/fnid/;
	27840	+ newstack[5LLU] = stack[base + 5]/typedefs/;
	27841	+ newstack[6LLU] = stack[base + 2]/dsttype/;
	27842	+ newstack[7LLU] = stack[base + 4]/dstindex/;
	27843	+ newstack[8LLU] = stack[base + 7]/label/;
27875	27844	newstack[9LLU] = 0LLU; //
27876	27845	stack = newstack;
27877	27846	// set stack-base & callee-address

		@@ -27879,12 +27848,12 @@
27879	27848	label = 1084LLU; // calldestr
27880	27849	break;
27881	27850	}
27882		- case 2290LLU: // copy-back deleter (calldestr to initfrom)
	27851	+ case 2285LLU: // copy-back deleter (calldestr to emitdelete)
27883	27852	{
27884		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (calldestr to initfrom)\n");
	27853	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (calldestr to emitdelete)\n");
27885	27854	uint64_t oldstack = (uint64_t )stack[0];
27886	27855	// copy mutable arguments back from call to calldestr
27887		- oldstack[base + 8]/label/ = stack[8LLU];
	27856	+ oldstack[base + 7]/label/ = stack[8LLU];
27888	27857	if(stack[75LLU] != 9876543210LLU)
27889	27858	{
27890	27859	fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");

		@@ -27892,14 +27861,14 @@
27892	27861	}
27893	27862	Free(75LLU + 1, sizeof(uint64_t), stack);
27894	27863	stack = oldstack;
27895		- label = 2266LLU; // continue to unroll stack
	27864	+ label = 2261LLU; // continue to unroll stack
27896	27865	break;
27897	27866	}
27898		- case 2291LLU: // return from calldestr to initfrom
	27867	+ case 2286LLU: // return from calldestr to emitdelete
27899	27868	{
27900	27869	uint64_t oldstack = (uint64_t )stack[0];
27901	27870	// copy mutable arguments back from call to calldestr
27902		- oldstack[base + 8]/label/ = stack[8LLU];
	27871	+ oldstack[base + 7]/label/ = stack[8LLU];
27903	27872	if(stack[75LLU] != 9876543210LLU)
27904	27873	{
27905	27874	fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to calldestr)!");

		@@ -27908,25 +27877,25 @@
27908	27877	Free(75LLU + 1, sizeof(uint64_t), stack);
27909	27878	stack = oldstack;
27910	27879	printf("%s", "\n label = ");
27911		- // call printnr from initfrom
27912		- stack[base + 15LLU] = 2292LLU/throw to this address/;
27913		- stack[base + 16LLU] = base;
27914		- stack[base + 17LLU] = 2293LLU;
	27880	+ // call printnr from emitdelete
	27881	+ stack[base + 10LLU] = 2287LLU/throw to this address/;
	27882	+ stack[base + 11LLU] = base;
	27883	+ stack[base + 12LLU] = 2288LLU;
27915	27884	// arguments for call to printnr
27916		- stack[base + 18LLU] = stack[base + 12]/labelthrow/;
	27885	+ stack[base + 13LLU] = stack[base + 6]/labelthrow/;
27917	27886	// set stack-base & callee-address
27918		- base += 18LLU;
	27887	+ base += 13LLU;
27919	27888	label = 18446744073709551590LLU; // printnr
27920	27889	break;
27921	27890	}
27922		- case 2292LLU: // copy-back deleter (printnr to initfrom)
	27891	+ case 2287LLU: // copy-back deleter (printnr to emitdelete)
27923	27892	{
27924		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
	27893	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
27925	27894	// copy mutable arguments back from call to printnr
27926		- label = 2266LLU; // continue to roll stack
	27895	+ label = 2261LLU; // continue to roll stack
27927	27896	break;
27928	27897	}
27929		- case 2293LLU: // return from printnr to initfrom
	27898	+ case 2288LLU: // return from printnr to emitdelete
27930	27899	{
27931	27900	// copy mutable arguments back from call to printnr
27932	27901	printf("%s", "LLU; // continue unrolling stack, delete next variable");

		@@ -27933,52 +27902,149 @@
27933	27902	printf("%s", "\n break;");
27934	27903	printf("%s", "\n }");
27935	27904	printf("%s", "\n case ");
27936		- // call printnr from initfrom
27937		- stack[base + 15LLU] = 2294LLU/throw to this address/;
27938		- stack[base + 16LLU] = base;
27939		- stack[base + 17LLU] = 2295LLU;
	27905	+ // call printnr from emitdelete
	27906	+ stack[base + 10LLU] = 2289LLU/throw to this address/;
	27907	+ stack[base + 11LLU] = base;
	27908	+ stack[base + 12LLU] = 2290LLU;
27940	27909	// arguments for call to printnr
27941		- stack[base + 18LLU] = stack[base + 14]/labelskip/;
	27910	+ stack[base + 13LLU] = stack[base + 9]/labelskip/;
27942	27911	// set stack-base & callee-address
27943		- base += 18LLU;
	27912	+ base += 13LLU;
27944	27913	label = 18446744073709551590LLU; // printnr
27945	27914	break;
27946	27915	}
27947		- case 2294LLU: // copy-back deleter (printnr to initfrom)
	27916	+ case 2289LLU: // copy-back deleter (printnr to emitdelete)
27948	27917	{
27949		- fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
	27918	+ fprintf(stderr, "in function emitdelete: unrolling stack, copy-back (printnr to emitdelete)\n");
27950	27919	// copy mutable arguments back from call to printnr
27951		- label = 2266LLU; // continue to roll stack
	27920	+ label = 2261LLU; // continue to roll stack
27952	27921	break;
27953	27922	}
27954		- case 2295LLU: // return from printnr to initfrom
	27923	+ case 2290LLU: // return from printnr to emitdelete
27955	27924	{
27956	27925	// copy mutable arguments back from call to printnr
27957	27926	printf("%s", "LLU: // skipped deleter");
27958	27927	printf("%s", "\n {");
27959		- ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 13];
27960		- ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 12];
27961		- label = 2261LLU; // case complete
	27928	+ label = 2292LLU; // skip deleter
27962	27929	break;
27963	27930	}
27964		- case 2263LLU: // copy-back deleter (switch)
	27931	+ case 2291LLU: // deleter
27965	27932	{
27966		- ((uint64_t **)(stack[base + 6]))[1][1] = stack[base + 13];
27967		- ((uint64_t **)(stack[base + 6]))[1][0] = stack[base + 12];
27968		- label = 2259LLU; // continue to unroll stack
	27933	+ // throw from emitdelete
	27934	+ if(!stack[base + 0])
	27935	+ {
	27936	+ fprintf(stderr, "in function emitdelete: unrolling stack, skipping already deleted/unscoped variable u64 \n");
	27937	+ label = 2261LLU; // skip, variable already deleted/unscoped
	27938	+ break;
	27939	+ }
	27940	+ fprintf(stderr, "in function emitdelete: unrolling stack, variable u64 \n");
	27941	+ label = 2261LLU; // continue unrolling stack, delete next variable
27969	27942	break;
27970	27943	}
27971		- case 2262LLU: // try next case
	27944	+ case 2292LLU: // skipped deleter
27972	27945	{
27973		- fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
27974		- exit(-1);
	27946	+ stack[base + 0] = stack[base + 8]/labelfail/;
	27947	+ // return from emitdelete
	27948	+ label = stack[base - 1];
	27949	+ base = stack[base - 2];
	27950	+ break;
27975	27951	}
27976		- case 2261LLU: // completed switch
	27952	+ case 2294LLU: // function initfrom failed
27977	27953	{
	27954	+ fprintf(stderr, "function initfrom failed\n");
	27955	+ label = stack[base - 3];
	27956	+ base = stack[base - 2];
	27957	+ break;
	27958	+ }
	27959	+ case 2293LLU: // initfrom
	27960	+ {
	27961	+//#define arg0 0
	27962	+//#define arg1 1
	27963	+//#define arg2 2
	27964	+//#define arg3 3
	27965	+//#define arg4 4
	27966	+//#define arg5 5
	27967	+//#define arg6 6
	27968	+//#define arg7 7
	27969	+//#define arg8 8
	27970	+//#define arg9 9
	27971	+ label = 2296LLU; // skip deleter
	27972	+ break;
	27973	+ }
	27974	+ case 2295LLU: // deleter
	27975	+ {
	27976	+ // throw from initfrom
	27977	+ if(!stack[base + 10])
	27978	+ {
	27979	+ fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
	27980	+ label = 2294LLU; // skip, variable already deleted/unscoped
	27981	+ break;
	27982	+ }
	27983	+ fprintf(stderr, "in function initfrom: unrolling stack, variable u64 isequal\n");
	27984	+ label = 2294LLU; // continue unrolling stack, delete next variable
	27985	+ break;
	27986	+ }
	27987	+ case 2296LLU: // skipped deleter
	27988	+ {
	27989	+ stack[base + 10] = 0;
	27990	+ // call getdeladdr from initfrom
	27991	+ stack[base + 13LLU] = 2297LLU/throw to this address/;
	27992	+ stack[base + 14LLU] = base;
	27993	+ stack[base + 15LLU] = 2298LLU;
	27994	+ // arguments for call to getdeladdr
	27995	+ stack[base + 17LLU] = stack[base + 6]/scope/;
	27996	+ // set stack-base & callee-address
	27997	+ base += 16LLU;
	27998	+ label = 564LLU; // getdeladdr
	27999	+ break;
	28000	+ }
	28001	+ case 2297LLU: // copy-back deleter (getdeladdr to initfrom)
	28002	+ {
	28003	+ fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getdeladdr to initfrom)\n");
	28004	+ // copy mutable arguments back from call to getdeladdr
	28005	+ label = 2295LLU; // continue to roll stack
	28006	+ break;
	28007	+ }
	28008	+ case 2298LLU: // return from getdeladdr to initfrom
	28009	+ {
	28010	+ // copy mutable arguments back from call to getdeladdr
	28011	+ // copy back results provided by call to getdeladdr
	28012	+ stack[base + 12] = stack[base + 16LLU];
	28013	+ // call emitdelete from initfrom
	28014	+ stack[base + 13LLU] = 2299LLU/throw to this address/;
	28015	+ stack[base + 14LLU] = base;
	28016	+ stack[base + 15LLU] = 2300LLU;
	28017	+ // arguments for call to emitdelete
	28018	+ stack[base + 17LLU] = stack[base + 0]/fnid/;
	28019	+ stack[base + 18LLU] = stack[base + 1]/dsttype/;
	28020	+ stack[base + 19LLU] = stack[base + 2]/dstid/;
	28021	+ stack[base + 20LLU] = stack[base + 3]/dstindex/;
	28022	+ stack[base + 21LLU] = stack[base + 4]/typedefs/;
	28023	+ stack[base + 22LLU] = stack[base + 12]/labelthrow/;
	28024	+ stack[base + 23LLU] = stack[base + 8]/label/;
	28025	+ // set stack-base & callee-address
	28026	+ base += 16LLU;
	28027	+ label = 2253LLU; // emitdelete
	28028	+ break;
	28029	+ }
	28030	+ case 2299LLU: // copy-back deleter (emitdelete to initfrom)
	28031	+ {
	28032	+ fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitdelete to initfrom)\n");
	28033	+ // copy mutable arguments back from call to emitdelete
	28034	+ stack[base + 8]/label/ = stack[base + 23LLU];
	28035	+ label = 2295LLU; // continue to roll stack
	28036	+ break;
	28037	+ }
	28038	+ case 2300LLU: // return from emitdelete to initfrom
	28039	+ {
	28040	+ // copy mutable arguments back from call to emitdelete
	28041	+ stack[base + 8]/label/ = stack[base + 23LLU];
	28042	+ // copy back results provided by call to emitdelete
	28043	+ stack[base + 11] = stack[base + 16LLU];
27978	28044	// call ParseToken from initfrom
27979		- stack[base + 14LLU] = 2296LLU/throw to this address/;
	28045	+ stack[base + 14LLU] = 2301LLU/throw to this address/;
27980	28046	stack[base + 15LLU] = base;
27981		- stack[base + 16LLU] = 2297LLU;
	28047	+ stack[base + 16LLU] = 2302LLU;
27982	28048	// arguments for call to ParseToken
27983	28049	stack[base + 19LLU] = stack[base + 7]/lookahead/;
27984	28050	// set stack-base & callee-address

		@@ -27986,15 +28052,15 @@
27986	28052	label = 3LLU; // ParseToken
27987	28053	break;
27988	28054	}
27989		- case 2296LLU: // copy-back deleter (ParseToken to initfrom)
	28055	+ case 2301LLU: // copy-back deleter (ParseToken to initfrom)
27990	28056	{
27991	28057	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
27992	28058	// copy mutable arguments back from call to ParseToken
27993	28059	stack[base + 7]/lookahead/ = stack[base + 19LLU];
27994		- label = 2259LLU; // continue to roll stack
	28060	+ label = 2295LLU; // continue to roll stack
27995	28061	break;
27996	28062	}
27997		- case 2297LLU: // return from ParseToken to initfrom
	28063	+ case 2302LLU: // return from ParseToken to initfrom
27998	28064	{
27999	28065	// copy mutable arguments back from call to ParseToken
28000	28066	stack[base + 7]/lookahead/ = stack[base + 19LLU];

		@@ -28002,9 +28068,9 @@
28002	28068	stack[base + 12] = stack[base + 17LLU];
28003	28069	stack[base + 13] = stack[base + 18LLU];
28004	28070	// call issimple from initfrom
28005		- stack[base + 15LLU] = 2298LLU/throw to this address/;
	28071	+ stack[base + 15LLU] = 2303LLU/throw to this address/;
28006	28072	stack[base + 16LLU] = base;
28007		- stack[base + 17LLU] = 2299LLU;
	28073	+ stack[base + 17LLU] = 2304LLU;
28008	28074	// arguments for call to issimple
28009	28075	stack[base + 19LLU] = stack[base + 12]/variant/;
28010	28076	stack[base + 20LLU] = stack[base + 13]/content/;

		@@ -28014,14 +28080,14 @@
28014	28080	label = 158LLU; // issimple
28015	28081	break;
28016	28082	}
28017		- case 2298LLU: // copy-back deleter (issimple to initfrom)
	28083	+ case 2303LLU: // copy-back deleter (issimple to initfrom)
28018	28084	{
28019	28085	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
28020	28086	// copy mutable arguments back from call to issimple
28021		- label = 2259LLU; // continue to roll stack
	28087	+ label = 2295LLU; // continue to roll stack
28022	28088	break;
28023	28089	}
28024		- case 2299LLU: // return from issimple to initfrom
	28090	+ case 2304LLU: // return from issimple to initfrom
28025	28091	{
28026	28092	// copy mutable arguments back from call to issimple
28027	28093	// copy back results provided by call to issimple

		@@ -28028,7 +28094,7 @@
28028	28094	stack[base + 14] = stack[base + 18LLU];
28029	28095	if(!stack[base + 14]/forceerror/)
28030	28096	{
28031		- label = 2300LLU; // jump to alternative
	28097	+ label = 2305LLU; // jump to alternative
28032	28098	break;
28033	28099	}
28034	28100

		@@ -28035,9 +28101,9 @@
28035	28101	// consequent
28036	28102	fprintf(stderr, "%s", "in function ");
28037	28103	// call reportid from initfrom
28038		- stack[base + 15LLU] = 2302LLU/throw to this address/;
	28104	+ stack[base + 15LLU] = 2307LLU/throw to this address/;
28039	28105	stack[base + 16LLU] = base;
28040		- stack[base + 17LLU] = 2303LLU;
	28106	+ stack[base + 17LLU] = 2308LLU;
28041	28107	// arguments for call to reportid
28042	28108	stack[base + 18LLU] = stack[base + 0]/fnid/;
28043	28109	// set stack-base & callee-address

		@@ -28045,21 +28111,21 @@
28045	28111	label = 18446744073709551586LLU; // reportid
28046	28112	break;
28047	28113	}
28048		- case 2302LLU: // copy-back deleter (reportid to initfrom)
	28114	+ case 2307LLU: // copy-back deleter (reportid to initfrom)
28049	28115	{
28050	28116	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28051	28117	// copy mutable arguments back from call to reportid
28052		- label = 2259LLU; // continue to roll stack
	28118	+ label = 2295LLU; // continue to roll stack
28053	28119	break;
28054	28120	}
28055		- case 2303LLU: // return from reportid to initfrom
	28121	+ case 2308LLU: // return from reportid to initfrom
28056	28122	{
28057	28123	// copy mutable arguments back from call to reportid
28058	28124	fprintf(stderr, "%s", ": WARNING, FORCING CONSTRUCTION TO FAIL TO TEST THROW MECHANISM!\n");
28059	28125	// call ParseToken from initfrom
28060		- stack[base + 15LLU] = 2304LLU/throw to this address/;
	28126	+ stack[base + 15LLU] = 2309LLU/throw to this address/;
28061	28127	stack[base + 16LLU] = base;
28062		- stack[base + 17LLU] = 2305LLU;
	28128	+ stack[base + 17LLU] = 2310LLU;
28063	28129	// arguments for call to ParseToken
28064	28130	stack[base + 20LLU] = stack[base + 7]/lookahead/;
28065	28131	// set stack-base & callee-address

		@@ -28067,15 +28133,15 @@
28067	28133	label = 3LLU; // ParseToken
28068	28134	break;
28069	28135	}
28070		- case 2304LLU: // copy-back deleter (ParseToken to initfrom)
	28136	+ case 2309LLU: // copy-back deleter (ParseToken to initfrom)
28071	28137	{
28072	28138	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
28073	28139	// copy mutable arguments back from call to ParseToken
28074	28140	stack[base + 7]/lookahead/ = stack[base + 20LLU];
28075		- label = 2259LLU; // continue to roll stack
	28141	+ label = 2295LLU; // continue to roll stack
28076	28142	break;
28077	28143	}
28078		- case 2305LLU: // return from ParseToken to initfrom
	28144	+ case 2310LLU: // return from ParseToken to initfrom
28079	28145	{
28080	28146	// copy mutable arguments back from call to ParseToken
28081	28147	stack[base + 7]/lookahead/ = stack[base + 20LLU];

		@@ -28082,20 +28148,20 @@
28082	28148	// copy back results provided by call to ParseToken
28083	28149	stack[base + 12] = stack[base + 18LLU];
28084	28150	stack[base + 13] = stack[base + 19LLU];
28085		- label = 2301LLU; // consequent complete
	28151	+ label = 2306LLU; // consequent complete
28086	28152	break;
28087	28153	}
28088		- case 2300LLU: // alternative
	28154	+ case 2305LLU: // alternative
28089	28155	{
28090		- label = 2301LLU; // alternative complete
	28156	+ label = 2306LLU; // alternative complete
28091	28157	break;
28092	28158	}
28093		- case 2301LLU: // completed if-then-else
	28159	+ case 2306LLU: // completed if-then-else
28094	28160	{
28095	28161	// call equ from initfrom
28096		- stack[base + 15LLU] = 2306LLU/throw to this address/;
	28162	+ stack[base + 15LLU] = 2311LLU/throw to this address/;
28097	28163	stack[base + 16LLU] = base;
28098		- stack[base + 17LLU] = 2307LLU;
	28164	+ stack[base + 17LLU] = 2312LLU;
28099	28165	// arguments for call to equ
28100	28166	stack[base + 19LLU] = stack[base + 12]/variant/;
28101	28167	stack[base + 20LLU] = 4LLU;

		@@ -28104,14 +28170,14 @@
28104	28170	label = 18446744073709551600LLU; // equ
28105	28171	break;
28106	28172	}
28107		- case 2306LLU: // copy-back deleter (equ to initfrom)
	28173	+ case 2311LLU: // copy-back deleter (equ to initfrom)
28108	28174	{
28109	28175	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28110	28176	// copy mutable arguments back from call to equ
28111		- label = 2259LLU; // continue to roll stack
	28177	+ label = 2295LLU; // continue to roll stack
28112	28178	break;
28113	28179	}
28114		- case 2307LLU: // return from equ to initfrom
	28180	+ case 2312LLU: // return from equ to initfrom
28115	28181	{
28116	28182	// copy mutable arguments back from call to equ
28117	28183	// copy back results provided by call to equ

		@@ -28118,15 +28184,15 @@
28118	28184	stack[base + 10] = stack[base + 18LLU];
28119	28185	if(!stack[base + 10]/isequal/)
28120	28186	{
28121		- label = 2308LLU; // jump to alternative
	28187	+ label = 2313LLU; // jump to alternative
28122	28188	break;
28123	28189	}
28124	28190
28125	28191	// consequent
28126	28192	// call skipwscmnt from initfrom
28127		- stack[base + 15LLU] = 2310LLU/throw to this address/;
	28193	+ stack[base + 15LLU] = 2315LLU/throw to this address/;
28128	28194	stack[base + 16LLU] = base;
28129		- stack[base + 17LLU] = 2311LLU;
	28195	+ stack[base + 17LLU] = 2316LLU;
28130	28196	// arguments for call to skipwscmnt
28131	28197	stack[base + 19LLU] = stack[base + 7]/lookahead/;
28132	28198	// set stack-base & callee-address

		@@ -28134,22 +28200,22 @@
28134	28200	label = 18446744073709551580LLU; // skipwscmnt
28135	28201	break;
28136	28202	}
28137		- case 2310LLU: // copy-back deleter (skipwscmnt to initfrom)
	28203	+ case 2315LLU: // copy-back deleter (skipwscmnt to initfrom)
28138	28204	{
28139	28205	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (skipwscmnt to initfrom)\n");
28140	28206	// copy mutable arguments back from call to skipwscmnt
28141		- label = 2259LLU; // continue to roll stack
	28207	+ label = 2295LLU; // continue to roll stack
28142	28208	break;
28143	28209	}
28144		- case 2311LLU: // return from skipwscmnt to initfrom
	28210	+ case 2316LLU: // return from skipwscmnt to initfrom
28145	28211	{
28146	28212	// copy mutable arguments back from call to skipwscmnt
28147	28213	// copy back results provided by call to skipwscmnt
28148	28214	stack[base + 7] = stack[base + 18LLU];
28149	28215	// call equ from initfrom
28150		- stack[base + 16LLU] = 2312LLU/throw to this address/;
	28216	+ stack[base + 16LLU] = 2317LLU/throw to this address/;
28151	28217	stack[base + 17LLU] = base;
28152		- stack[base + 18LLU] = 2313LLU;
	28218	+ stack[base + 18LLU] = 2318LLU;
28153	28219	// arguments for call to equ
28154	28220	stack[base + 20LLU] = stack[base + 7]/lookahead/;
28155	28221	stack[base + 21LLU] = 46LLU;

		@@ -28158,14 +28224,14 @@
28158	28224	label = 18446744073709551600LLU; // equ
28159	28225	break;
28160	28226	}
28161		- case 2312LLU: // copy-back deleter (equ to initfrom)
	28227	+ case 2317LLU: // copy-back deleter (equ to initfrom)
28162	28228	{
28163	28229	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28164	28230	// copy mutable arguments back from call to equ
28165		- label = 2259LLU; // continue to roll stack
	28231	+ label = 2295LLU; // continue to roll stack
28166	28232	break;
28167	28233	}
28168		- case 2313LLU: // return from equ to initfrom
	28234	+ case 2318LLU: // return from equ to initfrom
28169	28235	{
28170	28236	// copy mutable arguments back from call to equ
28171	28237	// copy back results provided by call to equ

		@@ -28172,40 +28238,40 @@
28172	28238	stack[base + 15] = stack[base + 19LLU];
28173	28239	if(!stack[base + 15]/namespace/)
28174	28240	{
28175		- label = 2314LLU; // jump to alternative
	28241	+ label = 2319LLU; // jump to alternative
28176	28242	break;
28177	28243	}
28178	28244
28179	28245	// consequent
28180		- label = 2317LLU; // skip deleter
	28246	+ label = 2322LLU; // skip deleter
28181	28247	break;
28182	28248	}
28183		- case 2316LLU: // deleter
	28249	+ case 2321LLU: // deleter
28184	28250	{
28185	28251	// throw from initfrom
28186	28252	if(!stack[base + 16])
28187	28253	{
28188	28254	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 typename\n");
28189		- label = 2259LLU; // skip, variable already deleted/unscoped
	28255	+ label = 2295LLU; // skip, variable already deleted/unscoped
28190	28256	break;
28191	28257	}
28192	28258	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 typename\n");
28193		- label = 2259LLU; // continue unrolling stack, delete next variable
	28259	+ label = 2295LLU; // continue unrolling stack, delete next variable
28194	28260	break;
28195	28261	}
28196		- case 2317LLU: // skipped deleter
	28262	+ case 2322LLU: // skipped deleter
28197	28263	{
28198	28264	stack[base + 16] = stack[base + 13]/content/;
28199		- label = 2319LLU; // skip deleter
	28265	+ label = 2324LLU; // skip deleter
28200	28266	break;
28201	28267	}
28202		- case 2318LLU: // deleter
	28268	+ case 2323LLU: // deleter
28203	28269	{
28204	28270	// throw from initfrom
28205	28271	if(!stack[base + 17])
28206	28272	{
28207	28273	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type assigntype\n");
28208		- label = 2316LLU; // skip, variable already deleted/unscoped
	28274	+ label = 2321LLU; // skip, variable already deleted/unscoped
28209	28275	break;
28210	28276	}
28211	28277	fprintf(stderr, "in function initfrom: unrolling stack, variable type assigntype\n");

		@@ -28215,7 +28281,7 @@
28215	28281	newstack[0] = (uint64_t)stack; // backup stack location
28216	28282	newstack[1] = 1234567890;
28217	28283	newstack[2] = base;
28218		- newstack[3] = 2320LLU;
	28284	+ newstack[3] = 2325LLU;
28219	28285	stack = newstack;
28220	28286	// set stack-base & callee-address
28221	28287	base = 4/deloffset/;

		@@ -28222,21 +28288,21 @@
28222	28288	label = 296LLU; // ~type
28223	28289	break;
28224	28290	}
28225		- case 2320LLU: // return from ~type to initfrom
	28291	+ case 2325LLU: // return from ~type to initfrom
28226	28292	{
28227	28293	stack = (uint64_t *)stack[0];
28228	28294	// releasing toplevel container
28229	28295	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 17] - sizeof(uint64_t) 4));
28230	28296
28231		- label = 2316LLU; // continue unrolling stack, delete next variable
	28297	+ label = 2321LLU; // continue unrolling stack, delete next variable
28232	28298	break;
28233	28299	}
28234		- case 2319LLU: // skipped deleter
	28300	+ case 2324LLU: // skipped deleter
28235	28301	{
28236	28302	// construct type.typename
28237	28303	if(!(stack[base + 17] = construct(1)))
28238	28304	{
28239		- label = 2316LLU; // throw: begin to unroll stack
	28305	+ label = 2321LLU; // throw: begin to unroll stack
28240	28306	break;
28241	28307	}
28242	28308

		@@ -28246,7 +28312,7 @@
28246	28312	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
28247	28313	if(!newstack)
28248	28314	{
28249		- label = 2318LLU; // throw: begin to unroll stack
	28315	+ label = 2323LLU; // throw: begin to unroll stack
28250	28316	break;
28251	28317	}
28252	28318

		@@ -28253,9 +28319,9 @@
28253	28319	newstack[15LLU] = 9876543210LLU; // overflow-marker
28254	28320	// call equtype from initfrom
28255	28321	newstack[0] = (uint64_t)stack; // backup stack location
28256		- newstack[1] = 2321LLU;
	28322	+ newstack[1] = 2326LLU;
28257	28323	newstack[2] = base;
28258		- newstack[3] = 2322LLU;
	28324	+ newstack[3] = 2327LLU;
28259	28325	// arguments for call to equtype
28260	28326	newstack[5LLU] = stack[base + 1]/dsttype/;
28261	28327	newstack[6LLU] = stack[base + 17]/assigntype/;

		@@ -28265,7 +28331,7 @@
28265	28331	label = 342LLU; // equtype
28266	28332	break;
28267	28333	}
28268		- case 2321LLU: // copy-back deleter (equtype to initfrom)
	28334	+ case 2326LLU: // copy-back deleter (equtype to initfrom)
28269	28335	{
28270	28336	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
28271	28337	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28277,10 +28343,10 @@
28277	28343	}
28278	28344	Free(15LLU + 1, sizeof(uint64_t), stack);
28279	28345	stack = oldstack;
28280		- label = 2318LLU; // continue to unroll stack
	28346	+ label = 2323LLU; // continue to unroll stack
28281	28347	break;
28282	28348	}
28283		- case 2322LLU: // return from equtype to initfrom
	28349	+ case 2327LLU: // return from equtype to initfrom
28284	28350	{
28285	28351	uint64_t oldstack = (uint64_t )stack[0];
28286	28352	// copy mutable arguments back from call to equtype

		@@ -28295,21 +28361,21 @@
28295	28361	stack = oldstack;
28296	28362	if(!stack[base + 10]/isequal/)
28297	28363	{
28298		- label = 2323LLU; // jump to alternative
	28364	+ label = 2328LLU; // jump to alternative
28299	28365	break;
28300	28366	}
28301	28367
28302	28368	// consequent
28303		- label = 2324LLU; // consequent complete
	28369	+ label = 2329LLU; // consequent complete
28304	28370	break;
28305	28371	}
28306		- case 2323LLU: // alternative
	28372	+ case 2328LLU: // alternative
28307	28373	{
28308	28374	fprintf(stderr, "%s", "in function ");
28309	28375	// call reportid from initfrom
28310		- stack[base + 18LLU] = 2325LLU/throw to this address/;
	28376	+ stack[base + 18LLU] = 2330LLU/throw to this address/;
28311	28377	stack[base + 19LLU] = base;
28312		- stack[base + 20LLU] = 2326LLU;
	28378	+ stack[base + 20LLU] = 2331LLU;
28313	28379	// arguments for call to reportid
28314	28380	stack[base + 21LLU] = stack[base + 0]/fnid/;
28315	28381	// set stack-base & callee-address

		@@ -28317,14 +28383,14 @@
28317	28383	label = 18446744073709551586LLU; // reportid
28318	28384	break;
28319	28385	}
28320		- case 2325LLU: // copy-back deleter (reportid to initfrom)
	28386	+ case 2330LLU: // copy-back deleter (reportid to initfrom)
28321	28387	{
28322	28388	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28323	28389	// copy mutable arguments back from call to reportid
28324		- label = 2318LLU; // continue to roll stack
	28390	+ label = 2323LLU; // continue to roll stack
28325	28391	break;
28326	28392	}
28327		- case 2326LLU: // return from reportid to initfrom
	28393	+ case 2331LLU: // return from reportid to initfrom
28328	28394	{
28329	28395	// copy mutable arguments back from call to reportid
28330	28396	fprintf(stderr, "%s", ": can't construct type ");

		@@ -28331,7 +28397,7 @@
28331	28397	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
28332	28398	if(!newstack)
28333	28399	{
28334		- label = 2318LLU; // throw: begin to unroll stack
	28400	+ label = 2323LLU; // throw: begin to unroll stack
28335	28401	break;
28336	28402	}
28337	28403

		@@ -28338,9 +28404,9 @@
28338	28404	newstack[10LLU] = 9876543210LLU; // overflow-marker
28339	28405	// call reporttype from initfrom
28340	28406	newstack[0] = (uint64_t)stack; // backup stack location
28341		- newstack[1] = 2327LLU;
	28407	+ newstack[1] = 2332LLU;
28342	28408	newstack[2] = base;
28343		- newstack[3] = 2328LLU;
	28409	+ newstack[3] = 2333LLU;
28344	28410	// arguments for call to reporttype
28345	28411	newstack[4LLU] = stack[base + 1]/dsttype/;
28346	28412	stack = newstack;

		@@ -28349,7 +28415,7 @@
28349	28415	label = 316LLU; // reporttype
28350	28416	break;
28351	28417	}
28352		- case 2327LLU: // copy-back deleter (reporttype to initfrom)
	28418	+ case 2332LLU: // copy-back deleter (reporttype to initfrom)
28353	28419	{
28354	28420	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
28355	28421	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28361,10 +28427,10 @@
28361	28427	}
28362	28428	Free(10LLU + 1, sizeof(uint64_t), stack);
28363	28429	stack = oldstack;
28364		- label = 2318LLU; // continue to unroll stack
	28430	+ label = 2323LLU; // continue to unroll stack
28365	28431	break;
28366	28432	}
28367		- case 2328LLU: // return from reporttype to initfrom
	28433	+ case 2333LLU: // return from reporttype to initfrom
28368	28434	{
28369	28435	uint64_t oldstack = (uint64_t )stack[0];
28370	28436	// copy mutable arguments back from call to reporttype

		@@ -28379,7 +28445,7 @@
28379	28445	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
28380	28446	if(!newstack)
28381	28447	{
28382		- label = 2318LLU; // throw: begin to unroll stack
	28448	+ label = 2323LLU; // throw: begin to unroll stack
28383	28449	break;
28384	28450	}
28385	28451

		@@ -28386,9 +28452,9 @@
28386	28452	newstack[10LLU] = 9876543210LLU; // overflow-marker
28387	28453	// call reporttype from initfrom
28388	28454	newstack[0] = (uint64_t)stack; // backup stack location
28389		- newstack[1] = 2329LLU;
	28455	+ newstack[1] = 2334LLU;
28390	28456	newstack[2] = base;
28391		- newstack[3] = 2330LLU;
	28457	+ newstack[3] = 2335LLU;
28392	28458	// arguments for call to reporttype
28393	28459	newstack[4LLU] = stack[base + 17]/assigntype/;
28394	28460	stack = newstack;

		@@ -28397,7 +28463,7 @@
28397	28463	label = 316LLU; // reporttype
28398	28464	break;
28399	28465	}
28400		- case 2329LLU: // copy-back deleter (reporttype to initfrom)
	28466	+ case 2334LLU: // copy-back deleter (reporttype to initfrom)
28401	28467	{
28402	28468	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
28403	28469	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28409,10 +28475,10 @@
28409	28475	}
28410	28476	Free(10LLU + 1, sizeof(uint64_t), stack);
28411	28477	stack = oldstack;
28412		- label = 2318LLU; // continue to unroll stack
	28478	+ label = 2323LLU; // continue to unroll stack
28413	28479	break;
28414	28480	}
28415		- case 2330LLU: // return from reporttype to initfrom
	28481	+ case 2335LLU: // return from reporttype to initfrom
28416	28482	{
28417	28483	uint64_t oldstack = (uint64_t )stack[0];
28418	28484	// copy mutable arguments back from call to reporttype

		@@ -28425,10 +28491,10 @@
28425	28491	stack = oldstack;
28426	28492	fprintf(stderr, "%s", "\n");
28427	28493	exit(-1);
28428		- label = 2324LLU; // alternative complete
	28494	+ label = 2329LLU; // alternative complete
28429	28495	break;
28430	28496	}
28431		- case 2324LLU: // completed if-then-else
	28497	+ case 2329LLU: // completed if-then-else
28432	28498	{
28433	28499
28434	28500	uint64_t newstack = (uint64_t )(stack[base + 17] - sizeof(uint64_t) * 4);

		@@ -28436,7 +28502,7 @@
28436	28502	newstack[0] = (uint64_t)stack; // backup stack location
28437	28503	newstack[1] = 1234567890;
28438	28504	newstack[2] = base;
28439		- newstack[3] = 2331LLU;
	28505	+ newstack[3] = 2336LLU;
28440	28506	stack = newstack;
28441	28507	// set stack-base & callee-address
28442	28508	base = 4/deloffset/;

		@@ -28443,7 +28509,7 @@
28443	28509	label = 296LLU; // ~type
28444	28510	break;
28445	28511	}
28446		- case 2331LLU: // return from ~type to initfrom
	28512	+ case 2336LLU: // return from ~type to initfrom
28447	28513	{
28448	28514	stack = (uint64_t *)stack[0];
28449	28515	// releasing toplevel container

		@@ -28450,9 +28516,9 @@
28450	28516	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 17] - sizeof(uint64_t) 4));
28451	28517
28452	28518	// call matchsym from initfrom
28453		- stack[base + 17LLU] = 2332LLU/throw to this address/;
	28519	+ stack[base + 17LLU] = 2337LLU/throw to this address/;
28454	28520	stack[base + 18LLU] = base;
28455		- stack[base + 19LLU] = 2333LLU;
	28521	+ stack[base + 19LLU] = 2338LLU;
28456	28522	// arguments for call to matchsym
28457	28523	stack[base + 20LLU] = stack[base + 0]/fnid/;
28458	28524	stack[base + 21LLU] = 46LLU;

		@@ -28462,22 +28528,22 @@
28462	28528	label = 212LLU; // matchsym
28463	28529	break;
28464	28530	}
28465		- case 2332LLU: // copy-back deleter (matchsym to initfrom)
	28531	+ case 2337LLU: // copy-back deleter (matchsym to initfrom)
28466	28532	{
28467	28533	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
28468	28534	// copy mutable arguments back from call to matchsym
28469	28535	stack[base + 7]/lookahead/ = stack[base + 22LLU];
28470		- label = 2316LLU; // continue to roll stack
	28536	+ label = 2321LLU; // continue to roll stack
28471	28537	break;
28472	28538	}
28473		- case 2333LLU: // return from matchsym to initfrom
	28539	+ case 2338LLU: // return from matchsym to initfrom
28474	28540	{
28475	28541	// copy mutable arguments back from call to matchsym
28476	28542	stack[base + 7]/lookahead/ = stack[base + 22LLU];
28477	28543	// call ParseToken from initfrom
28478		- stack[base + 17LLU] = 2334LLU/throw to this address/;
	28544	+ stack[base + 17LLU] = 2339LLU/throw to this address/;
28479	28545	stack[base + 18LLU] = base;
28480		- stack[base + 19LLU] = 2335LLU;
	28546	+ stack[base + 19LLU] = 2340LLU;
28481	28547	// arguments for call to ParseToken
28482	28548	stack[base + 22LLU] = stack[base + 7]/lookahead/;
28483	28549	// set stack-base & callee-address

		@@ -28485,15 +28551,15 @@
28485	28551	label = 3LLU; // ParseToken
28486	28552	break;
28487	28553	}
28488		- case 2334LLU: // copy-back deleter (ParseToken to initfrom)
	28554	+ case 2339LLU: // copy-back deleter (ParseToken to initfrom)
28489	28555	{
28490	28556	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
28491	28557	// copy mutable arguments back from call to ParseToken
28492	28558	stack[base + 7]/lookahead/ = stack[base + 22LLU];
28493		- label = 2316LLU; // continue to roll stack
	28559	+ label = 2321LLU; // continue to roll stack
28494	28560	break;
28495	28561	}
28496		- case 2335LLU: // return from ParseToken to initfrom
	28562	+ case 2340LLU: // return from ParseToken to initfrom
28497	28563	{
28498	28564	// copy mutable arguments back from call to ParseToken
28499	28565	stack[base + 7]/lookahead/ = stack[base + 22LLU];

		@@ -28501,9 +28567,9 @@
28501	28567	stack[base + 12] = stack[base + 20LLU];
28502	28568	stack[base + 13] = stack[base + 21LLU];
28503	28569	// call equ from initfrom
28504		- stack[base + 17LLU] = 2336LLU/throw to this address/;
	28570	+ stack[base + 17LLU] = 2341LLU/throw to this address/;
28505	28571	stack[base + 18LLU] = base;
28506		- stack[base + 19LLU] = 2337LLU;
	28572	+ stack[base + 19LLU] = 2342LLU;
28507	28573	// arguments for call to equ
28508	28574	stack[base + 21LLU] = stack[base + 12]/variant/;
28509	28575	stack[base + 22LLU] = 4LLU;

		@@ -28512,14 +28578,14 @@
28512	28578	label = 18446744073709551600LLU; // equ
28513	28579	break;
28514	28580	}
28515		- case 2336LLU: // copy-back deleter (equ to initfrom)
	28581	+ case 2341LLU: // copy-back deleter (equ to initfrom)
28516	28582	{
28517	28583	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28518	28584	// copy mutable arguments back from call to equ
28519		- label = 2316LLU; // continue to roll stack
	28585	+ label = 2321LLU; // continue to roll stack
28520	28586	break;
28521	28587	}
28522		- case 2337LLU: // return from equ to initfrom
	28588	+ case 2342LLU: // return from equ to initfrom
28523	28589	{
28524	28590	// copy mutable arguments back from call to equ
28525	28591	// copy back results provided by call to equ

		@@ -28526,21 +28592,21 @@
28526	28592	stack[base + 10] = stack[base + 20LLU];
28527	28593	if(!stack[base + 10]/isequal/)
28528	28594	{
28529		- label = 2338LLU; // jump to alternative
	28595	+ label = 2343LLU; // jump to alternative
28530	28596	break;
28531	28597	}
28532	28598
28533	28599	// consequent
28534		- label = 2339LLU; // consequent complete
	28600	+ label = 2344LLU; // consequent complete
28535	28601	break;
28536	28602	}
28537		- case 2338LLU: // alternative
	28603	+ case 2343LLU: // alternative
28538	28604	{
28539	28605	fprintf(stderr, "%s", "construct requires constructor but found ");
28540	28606	// call reporttok from initfrom
28541		- stack[base + 17LLU] = 2340LLU/throw to this address/;
	28607	+ stack[base + 17LLU] = 2345LLU/throw to this address/;
28542	28608	stack[base + 18LLU] = base;
28543		- stack[base + 19LLU] = 2341LLU;
	28609	+ stack[base + 19LLU] = 2346LLU;
28544	28610	// arguments for call to reporttok
28545	28611	stack[base + 20LLU] = stack[base + 12]/variant/;
28546	28612	stack[base + 21LLU] = stack[base + 13]/content/;

		@@ -28549,40 +28615,40 @@
28549	28615	label = 18446744073709551582LLU; // reporttok
28550	28616	break;
28551	28617	}
28552		- case 2340LLU: // copy-back deleter (reporttok to initfrom)
	28618	+ case 2345LLU: // copy-back deleter (reporttok to initfrom)
28553	28619	{
28554	28620	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
28555	28621	// copy mutable arguments back from call to reporttok
28556		- label = 2316LLU; // continue to roll stack
	28622	+ label = 2321LLU; // continue to roll stack
28557	28623	break;
28558	28624	}
28559		- case 2341LLU: // return from reporttok to initfrom
	28625	+ case 2346LLU: // return from reporttok to initfrom
28560	28626	{
28561	28627	// copy mutable arguments back from call to reporttok
28562	28628	fprintf(stderr, "%s", "\n");
28563	28629	exit(-1);
28564		- label = 2339LLU; // alternative complete
	28630	+ label = 2344LLU; // alternative complete
28565	28631	break;
28566	28632	}
28567		- case 2339LLU: // completed if-then-else
	28633	+ case 2344LLU: // completed if-then-else
28568	28634	{
28569	28635	if(!stack[base + 9]/fncanthrow/)
28570	28636	{
28571		- label = 2342LLU; // jump to alternative
	28637	+ label = 2347LLU; // jump to alternative
28572	28638	break;
28573	28639	}
28574	28640
28575	28641	// consequent
28576		- label = 2343LLU; // consequent complete
	28642	+ label = 2348LLU; // consequent complete
28577	28643	break;
28578	28644	}
28579		- case 2342LLU: // alternative
	28645	+ case 2347LLU: // alternative
28580	28646	{
28581	28647	fprintf(stderr, "%s", "in function ");
28582	28648	// call reportid from initfrom
28583		- stack[base + 17LLU] = 2344LLU/throw to this address/;
	28649	+ stack[base + 17LLU] = 2349LLU/throw to this address/;
28584	28650	stack[base + 18LLU] = base;
28585		- stack[base + 19LLU] = 2345LLU;
	28651	+ stack[base + 19LLU] = 2350LLU;
28586	28652	// arguments for call to reportid
28587	28653	stack[base + 20LLU] = stack[base + 0]/fnid/;
28588	28654	// set stack-base & callee-address

		@@ -28590,21 +28656,21 @@
28590	28656	label = 18446744073709551586LLU; // reportid
28591	28657	break;
28592	28658	}
28593		- case 2344LLU: // copy-back deleter (reportid to initfrom)
	28659	+ case 2349LLU: // copy-back deleter (reportid to initfrom)
28594	28660	{
28595	28661	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28596	28662	// copy mutable arguments back from call to reportid
28597		- label = 2316LLU; // continue to roll stack
	28663	+ label = 2321LLU; // continue to roll stack
28598	28664	break;
28599	28665	}
28600		- case 2345LLU: // return from reportid to initfrom
	28666	+ case 2350LLU: // return from reportid to initfrom
28601	28667	{
28602	28668	// copy mutable arguments back from call to reportid
28603	28669	fprintf(stderr, "%s", ": construction of data ");
28604	28670	// call reportid from initfrom
28605		- stack[base + 17LLU] = 2346LLU/throw to this address/;
	28671	+ stack[base + 17LLU] = 2351LLU/throw to this address/;
28606	28672	stack[base + 18LLU] = base;
28607		- stack[base + 19LLU] = 2347LLU;
	28673	+ stack[base + 19LLU] = 2352LLU;
28608	28674	// arguments for call to reportid
28609	28675	stack[base + 20LLU] = stack[base + 16]/typename/;
28610	28676	// set stack-base & callee-address

		@@ -28612,28 +28678,28 @@
28612	28678	label = 18446744073709551586LLU; // reportid
28613	28679	break;
28614	28680	}
28615		- case 2346LLU: // copy-back deleter (reportid to initfrom)
	28681	+ case 2351LLU: // copy-back deleter (reportid to initfrom)
28616	28682	{
28617	28683	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28618	28684	// copy mutable arguments back from call to reportid
28619		- label = 2316LLU; // continue to roll stack
	28685	+ label = 2321LLU; // continue to roll stack
28620	28686	break;
28621	28687	}
28622		- case 2347LLU: // return from reportid to initfrom
	28688	+ case 2352LLU: // return from reportid to initfrom
28623	28689	{
28624	28690	// copy mutable arguments back from call to reportid
28625	28691	fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
28626	28692	exit(-1);
28627		- label = 2343LLU; // alternative complete
	28693	+ label = 2348LLU; // alternative complete
28628	28694	break;
28629	28695	}
28630		- case 2343LLU: // completed if-then-else
	28696	+ case 2348LLU: // completed if-then-else
28631	28697	{
28632	28698	printf("%s", "\n // construct ");
28633	28699	// call printid from initfrom
28634		- stack[base + 17LLU] = 2348LLU/throw to this address/;
	28700	+ stack[base + 17LLU] = 2353LLU/throw to this address/;
28635	28701	stack[base + 18LLU] = base;
28636		- stack[base + 19LLU] = 2349LLU;
	28702	+ stack[base + 19LLU] = 2354LLU;
28637	28703	// arguments for call to printid
28638	28704	stack[base + 20LLU] = stack[base + 16]/typename/;
28639	28705	// set stack-base & callee-address

		@@ -28641,21 +28707,21 @@
28641	28707	label = 18446744073709551587LLU; // printid
28642	28708	break;
28643	28709	}
28644		- case 2348LLU: // copy-back deleter (printid to initfrom)
	28710	+ case 2353LLU: // copy-back deleter (printid to initfrom)
28645	28711	{
28646	28712	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
28647	28713	// copy mutable arguments back from call to printid
28648		- label = 2316LLU; // continue to roll stack
	28714	+ label = 2321LLU; // continue to roll stack
28649	28715	break;
28650	28716	}
28651		- case 2349LLU: // return from printid to initfrom
	28717	+ case 2354LLU: // return from printid to initfrom
28652	28718	{
28653	28719	// copy mutable arguments back from call to printid
28654	28720	printf("%s", ".");
28655	28721	// call printid from initfrom
28656		- stack[base + 17LLU] = 2350LLU/throw to this address/;
	28722	+ stack[base + 17LLU] = 2355LLU/throw to this address/;
28657	28723	stack[base + 18LLU] = base;
28658		- stack[base + 19LLU] = 2351LLU;
	28724	+ stack[base + 19LLU] = 2356LLU;
28659	28725	// arguments for call to printid
28660	28726	stack[base + 20LLU] = stack[base + 13]/content/;
28661	28727	// set stack-base & callee-address

		@@ -28663,20 +28729,20 @@
28663	28729	label = 18446744073709551587LLU; // printid
28664	28730	break;
28665	28731	}
28666		- case 2350LLU: // copy-back deleter (printid to initfrom)
	28732	+ case 2355LLU: // copy-back deleter (printid to initfrom)
28667	28733	{
28668	28734	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
28669	28735	// copy mutable arguments back from call to printid
28670		- label = 2316LLU; // continue to roll stack
	28736	+ label = 2321LLU; // continue to roll stack
28671	28737	break;
28672	28738	}
28673		- case 2351LLU: // return from printid to initfrom
	28739	+ case 2356LLU: // return from printid to initfrom
28674	28740	{
28675	28741	// copy mutable arguments back from call to printid
28676	28742	// call FindData from initfrom
28677		- stack[base + 18LLU] = 2352LLU/throw to this address/;
	28743	+ stack[base + 18LLU] = 2357LLU/throw to this address/;
28678	28744	stack[base + 19LLU] = base;
28679		- stack[base + 20LLU] = 2353LLU;
	28745	+ stack[base + 20LLU] = 2358LLU;
28680	28746	// arguments for call to FindData
28681	28747	stack[base + 22LLU] = stack[base + 4]/typedefs/;
28682	28748	stack[base + 23LLU] = stack[base + 16]/typename/;

		@@ -28685,14 +28751,14 @@
28685	28751	label = 1004LLU; // FindData
28686	28752	break;
28687	28753	}
28688		- case 2352LLU: // copy-back deleter (FindData to initfrom)
	28754	+ case 2357LLU: // copy-back deleter (FindData to initfrom)
28689	28755	{
28690	28756	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
28691	28757	// copy mutable arguments back from call to FindData
28692		- label = 2316LLU; // continue to roll stack
	28758	+ label = 2321LLU; // continue to roll stack
28693	28759	break;
28694	28760	}
28695		- case 2353LLU: // return from FindData to initfrom
	28761	+ case 2358LLU: // return from FindData to initfrom
28696	28762	{
28697	28763	// copy mutable arguments back from call to FindData
28698	28764	// copy back results provided by call to FindData

		@@ -28699,7 +28765,7 @@
28699	28765	stack[base + 17] = stack[base + 21LLU];
28700	28766	if(/datadef/0 != ((uint64_t )(stack[base + 17]/reftypedef*/))[0])
28701	28767	{
28702		- label = 2355LLU; // jump to alternative
	28768	+ label = 2360LLU; // jump to alternative
28703	28769	break;
28704	28770	}
28705	28771

		@@ -28709,9 +28775,9 @@
28709	28775
28710	28776	// case
28711	28777	// call GetVariant from initfrom
28712		- stack[base + 23LLU] = 2357LLU/throw to this address/;
	28778	+ stack[base + 23LLU] = 2362LLU/throw to this address/;
28713	28779	stack[base + 24LLU] = base;
28714		- stack[base + 25LLU] = 2358LLU;
	28780	+ stack[base + 25LLU] = 2363LLU;
28715	28781	// arguments for call to GetVariant
28716	28782	stack[base + 28LLU] = stack[base + 0]/fnid/;
28717	28783	stack[base + 29LLU] = stack[base + 19]/variants/;

		@@ -28721,14 +28787,14 @@
28721	28787	label = 907LLU; // GetVariant
28722	28788	break;
28723	28789	}
28724		- case 2357LLU: // copy-back deleter (GetVariant to initfrom)
	28790	+ case 2362LLU: // copy-back deleter (GetVariant to initfrom)
28725	28791	{
28726	28792	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
28727	28793	// copy mutable arguments back from call to GetVariant
28728		- label = 2356LLU; // continue to roll stack
	28794	+ label = 2361LLU; // continue to roll stack
28729	28795	break;
28730	28796	}
28731		- case 2358LLU: // return from GetVariant to initfrom
	28797	+ case 2363LLU: // return from GetVariant to initfrom
28732	28798	{
28733	28799	// copy mutable arguments back from call to GetVariant
28734	28800	// copy back results provided by call to GetVariant

		@@ -28736,7 +28802,7 @@
28736	28802	stack[base + 22] = stack[base + 27LLU];
28737	28803	if(/variant/0 != ((uint64_t )(stack[base + 22]/constr*/))[0])
28738	28804	{
28739		- label = 2360LLU; // jump to alternative
	28805	+ label = 2365LLU; // jump to alternative
28740	28806	break;
28741	28807	}
28742	28808

		@@ -28744,29 +28810,29 @@
28744	28810	/TYPEIDS/stack[base + 24] = ((uint64_t *)(stack[base + 22]/constr/))[1][1]/elements*/;
28745	28811
28746	28812	// case
28747		- label = 2363LLU; // skip deleter
	28813	+ label = 2368LLU; // skip deleter
28748	28814	break;
28749	28815	}
28750		- case 2362LLU: // deleter
	28816	+ case 2367LLU: // deleter
28751	28817	{
28752	28818	// throw from initfrom
28753	28819	if(!stack[base + 25])
28754	28820	{
28755	28821	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
28756		- label = 2361LLU; // skip, variable already deleted/unscoped
	28822	+ label = 2366LLU; // skip, variable already deleted/unscoped
28757	28823	break;
28758	28824	}
28759	28825	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
28760		- label = 2361LLU; // continue unrolling stack, delete next variable
	28826	+ label = 2366LLU; // continue unrolling stack, delete next variable
28761	28827	break;
28762	28828	}
28763		- case 2363LLU: // skipped deleter
	28829	+ case 2368LLU: // skipped deleter
28764	28830	{
28765	28831	stack[base + 25] = 0;
28766	28832	stack[base + 25]/size/ = list_size(((struct listnode )(stack[base + 24]/TYPEIDS*/)));
28767	28833	if(!stack[base + 14]/forceerror/)
28768	28834	{
28769		- label = 2364LLU; // jump to alternative
	28835	+ label = 2369LLU; // jump to alternative
28770	28836	break;
28771	28837	}
28772	28838

		@@ -28773,9 +28839,9 @@
28773	28839	// consequent
28774	28840	printf("%s", "\n // if(!(");
28775	28841	// call emitvaridx from initfrom
28776		- stack[base + 26LLU] = 2366LLU/throw to this address/;
	28842	+ stack[base + 26LLU] = 2371LLU/throw to this address/;
28777	28843	stack[base + 27LLU] = base;
28778		- stack[base + 28LLU] = 2367LLU;
	28844	+ stack[base + 28LLU] = 2372LLU;
28779	28845	// arguments for call to emitvaridx
28780	28846	stack[base + 29LLU] = stack[base + 3]/dstindex/;
28781	28847	// set stack-base & callee-address

		@@ -28783,21 +28849,21 @@
28783	28849	label = 691LLU; // emitvaridx
28784	28850	break;
28785	28851	}
28786		- case 2366LLU: // copy-back deleter (emitvaridx to initfrom)
	28852	+ case 2371LLU: // copy-back deleter (emitvaridx to initfrom)
28787	28853	{
28788	28854	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28789	28855	// copy mutable arguments back from call to emitvaridx
28790		- label = 2362LLU; // continue to roll stack
	28856	+ label = 2367LLU; // continue to roll stack
28791	28857	break;
28792	28858	}
28793		- case 2367LLU: // return from emitvaridx to initfrom
	28859	+ case 2372LLU: // return from emitvaridx to initfrom
28794	28860	{
28795	28861	// copy mutable arguments back from call to emitvaridx
28796	28862	printf("%s", " = construct(");
28797	28863	// call printnr from initfrom
28798		- stack[base + 26LLU] = 2368LLU/throw to this address/;
	28864	+ stack[base + 26LLU] = 2373LLU/throw to this address/;
28799	28865	stack[base + 27LLU] = base;
28800		- stack[base + 28LLU] = 2369LLU;
	28866	+ stack[base + 28LLU] = 2374LLU;
28801	28867	// arguments for call to printnr
28802	28868	stack[base + 29LLU] = stack[base + 25]/size/;
28803	28869	// set stack-base & callee-address

		@@ -28805,27 +28871,27 @@
28805	28871	label = 18446744073709551590LLU; // printnr
28806	28872	break;
28807	28873	}
28808		- case 2368LLU: // copy-back deleter (printnr to initfrom)
	28874	+ case 2373LLU: // copy-back deleter (printnr to initfrom)
28809	28875	{
28810	28876	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28811	28877	// copy mutable arguments back from call to printnr
28812		- label = 2362LLU; // continue to roll stack
	28878	+ label = 2367LLU; // continue to roll stack
28813	28879	break;
28814	28880	}
28815		- case 2369LLU: // return from printnr to initfrom
	28881	+ case 2374LLU: // return from printnr to initfrom
28816	28882	{
28817	28883	// copy mutable arguments back from call to printnr
28818	28884	printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
28819		- label = 2365LLU; // consequent complete
	28885	+ label = 2370LLU; // consequent complete
28820	28886	break;
28821	28887	}
28822		- case 2364LLU: // alternative
	28888	+ case 2369LLU: // alternative
28823	28889	{
28824	28890	printf("%s", "\n if(!(");
28825	28891	// call emitvaridx from initfrom
28826		- stack[base + 26LLU] = 2370LLU/throw to this address/;
	28892	+ stack[base + 26LLU] = 2375LLU/throw to this address/;
28827	28893	stack[base + 27LLU] = base;
28828		- stack[base + 28LLU] = 2371LLU;
	28894	+ stack[base + 28LLU] = 2376LLU;
28829	28895	// arguments for call to emitvaridx
28830	28896	stack[base + 29LLU] = stack[base + 3]/dstindex/;
28831	28897	// set stack-base & callee-address

		@@ -28833,21 +28899,21 @@
28833	28899	label = 691LLU; // emitvaridx
28834	28900	break;
28835	28901	}
28836		- case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
	28902	+ case 2375LLU: // copy-back deleter (emitvaridx to initfrom)
28837	28903	{
28838	28904	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28839	28905	// copy mutable arguments back from call to emitvaridx
28840		- label = 2362LLU; // continue to roll stack
	28906	+ label = 2367LLU; // continue to roll stack
28841	28907	break;
28842	28908	}
28843		- case 2371LLU: // return from emitvaridx to initfrom
	28909	+ case 2376LLU: // return from emitvaridx to initfrom
28844	28910	{
28845	28911	// copy mutable arguments back from call to emitvaridx
28846	28912	printf("%s", " = construct(");
28847	28913	// call printnr from initfrom
28848		- stack[base + 26LLU] = 2372LLU/throw to this address/;
	28914	+ stack[base + 26LLU] = 2377LLU/throw to this address/;
28849	28915	stack[base + 27LLU] = base;
28850		- stack[base + 28LLU] = 2373LLU;
	28916	+ stack[base + 28LLU] = 2378LLU;
28851	28917	// arguments for call to printnr
28852	28918	stack[base + 29LLU] = stack[base + 25]/size/;
28853	28919	// set stack-base & callee-address

		@@ -28855,26 +28921,26 @@
28855	28921	label = 18446744073709551590LLU; // printnr
28856	28922	break;
28857	28923	}
28858		- case 2372LLU: // copy-back deleter (printnr to initfrom)
	28924	+ case 2377LLU: // copy-back deleter (printnr to initfrom)
28859	28925	{
28860	28926	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28861	28927	// copy mutable arguments back from call to printnr
28862		- label = 2362LLU; // continue to roll stack
	28928	+ label = 2367LLU; // continue to roll stack
28863	28929	break;
28864	28930	}
28865		- case 2373LLU: // return from printnr to initfrom
	28931	+ case 2378LLU: // return from printnr to initfrom
28866	28932	{
28867	28933	// copy mutable arguments back from call to printnr
28868	28934	printf("%s", ")))");
28869		- label = 2365LLU; // alternative complete
	28935	+ label = 2370LLU; // alternative complete
28870	28936	break;
28871	28937	}
28872		- case 2365LLU: // completed if-then-else
	28938	+ case 2370LLU: // completed if-then-else
28873	28939	{
28874	28940	// call emitthrow from initfrom
28875		- stack[base + 26LLU] = 2374LLU/throw to this address/;
	28941	+ stack[base + 26LLU] = 2379LLU/throw to this address/;
28876	28942	stack[base + 27LLU] = base;
28877		- stack[base + 28LLU] = 2375LLU;
	28943	+ stack[base + 28LLU] = 2380LLU;
28878	28944	// arguments for call to emitthrow
28879	28945	stack[base + 29LLU] = stack[base + 6]/scope/;
28880	28946	// set stack-base & callee-address

		@@ -28882,22 +28948,22 @@
28882	28948	label = 1559LLU; // emitthrow
28883	28949	break;
28884	28950	}
28885		- case 2374LLU: // copy-back deleter (emitthrow to initfrom)
	28951	+ case 2379LLU: // copy-back deleter (emitthrow to initfrom)
28886	28952	{
28887	28953	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
28888	28954	// copy mutable arguments back from call to emitthrow
28889		- label = 2362LLU; // continue to roll stack
	28955	+ label = 2367LLU; // continue to roll stack
28890	28956	break;
28891	28957	}
28892		- case 2375LLU: // return from emitthrow to initfrom
	28958	+ case 2380LLU: // return from emitthrow to initfrom
28893	28959	{
28894	28960	// copy mutable arguments back from call to emitthrow
28895	28961	printf("%s", "\n // consequent");
28896	28962	printf("%s", "\n ((uint64_t *)");
28897	28963	// call emitvaridx from initfrom
28898		- stack[base + 26LLU] = 2376LLU/throw to this address/;
	28964	+ stack[base + 26LLU] = 2381LLU/throw to this address/;
28899	28965	stack[base + 27LLU] = base;
28900		- stack[base + 28LLU] = 2377LLU;
	28966	+ stack[base + 28LLU] = 2382LLU;
28901	28967	// arguments for call to emitvaridx
28902	28968	stack[base + 29LLU] = stack[base + 3]/dstindex/;
28903	28969	// set stack-base & callee-address

		@@ -28905,21 +28971,21 @@
28905	28971	label = 691LLU; // emitvaridx
28906	28972	break;
28907	28973	}
28908		- case 2376LLU: // copy-back deleter (emitvaridx to initfrom)
	28974	+ case 2381LLU: // copy-back deleter (emitvaridx to initfrom)
28909	28975	{
28910	28976	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28911	28977	// copy mutable arguments back from call to emitvaridx
28912		- label = 2362LLU; // continue to roll stack
	28978	+ label = 2367LLU; // continue to roll stack
28913	28979	break;
28914	28980	}
28915		- case 2377LLU: // return from emitvaridx to initfrom
	28981	+ case 2382LLU: // return from emitvaridx to initfrom
28916	28982	{
28917	28983	// copy mutable arguments back from call to emitvaridx
28918	28984	printf("%s", ")[0] = ");
28919	28985	// call printnr from initfrom
28920		- stack[base + 26LLU] = 2378LLU/throw to this address/;
	28986	+ stack[base + 26LLU] = 2383LLU/throw to this address/;
28921	28987	stack[base + 27LLU] = base;
28922		- stack[base + 28LLU] = 2379LLU;
	28988	+ stack[base + 28LLU] = 2384LLU;
28923	28989	// arguments for call to printnr
28924	28990	stack[base + 29LLU] = stack[base + 21]/varnr/;
28925	28991	// set stack-base & callee-address

		@@ -28927,21 +28993,21 @@
28927	28993	label = 18446744073709551590LLU; // printnr
28928	28994	break;
28929	28995	}
28930		- case 2378LLU: // copy-back deleter (printnr to initfrom)
	28996	+ case 2383LLU: // copy-back deleter (printnr to initfrom)
28931	28997	{
28932	28998	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28933	28999	// copy mutable arguments back from call to printnr
28934		- label = 2362LLU; // continue to roll stack
	29000	+ label = 2367LLU; // continue to roll stack
28935	29001	break;
28936	29002	}
28937		- case 2379LLU: // return from printnr to initfrom
	29003	+ case 2384LLU: // return from printnr to initfrom
28938	29004	{
28939	29005	// copy mutable arguments back from call to printnr
28940	29006	printf("%s", ";");
28941	29007	// call matchsym from initfrom
28942		- stack[base + 26LLU] = 2380LLU/throw to this address/;
	29008	+ stack[base + 26LLU] = 2385LLU/throw to this address/;
28943	29009	stack[base + 27LLU] = base;
28944		- stack[base + 28LLU] = 2381LLU;
	29010	+ stack[base + 28LLU] = 2386LLU;
28945	29011	// arguments for call to matchsym
28946	29012	stack[base + 29LLU] = stack[base + 0]/fnid/;
28947	29013	stack[base + 30LLU] = 40LLU;

		@@ -28951,46 +29017,46 @@
28951	29017	label = 212LLU; // matchsym
28952	29018	break;
28953	29019	}
28954		- case 2380LLU: // copy-back deleter (matchsym to initfrom)
	29020	+ case 2385LLU: // copy-back deleter (matchsym to initfrom)
28955	29021	{
28956	29022	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
28957	29023	// copy mutable arguments back from call to matchsym
28958	29024	stack[base + 7]/lookahead/ = stack[base + 31LLU];
28959		- label = 2362LLU; // continue to roll stack
	29025	+ label = 2367LLU; // continue to roll stack
28960	29026	break;
28961	29027	}
28962		- case 2381LLU: // return from matchsym to initfrom
	29028	+ case 2386LLU: // return from matchsym to initfrom
28963	29029	{
28964	29030	// copy mutable arguments back from call to matchsym
28965	29031	stack[base + 7]/lookahead/ = stack[base + 31LLU];
28966		- label = 2383LLU; // skip deleter
	29032	+ label = 2388LLU; // skip deleter
28967	29033	break;
28968	29034	}
28969		- case 2382LLU: // deleter
	29035	+ case 2387LLU: // deleter
28970	29036	{
28971	29037	// throw from initfrom
28972	29038	if(!stack[base + 26])
28973	29039	{
28974	29040	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
28975		- label = 2362LLU; // skip, variable already deleted/unscoped
	29041	+ label = 2367LLU; // skip, variable already deleted/unscoped
28976	29042	break;
28977	29043	}
28978	29044	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
28979		- label = 2362LLU; // continue unrolling stack, delete next variable
	29045	+ label = 2367LLU; // continue unrolling stack, delete next variable
28980	29046	break;
28981	29047	}
28982		- case 2383LLU: // skipped deleter
	29048	+ case 2388LLU: // skipped deleter
28983	29049	{
28984	29050	stack[base + 26] = 0;
28985	29051	flippedassign(stack[base + 24]/TYPEIDS/, &stack[base + 27]);
28986		- label = 2384LLU; // start to repeat
	29052	+ label = 2389LLU; // start to repeat
28987	29053	break;
28988	29054	}
28989		- case 2384LLU: // repeat from here
	29055	+ case 2389LLU: // repeat from here
28990	29056	{
28991	29057	if(!stack[base + 27])
28992	29058	{
28993		- label = 2385LLU; // break loop
	29059	+ label = 2390LLU; // break loop
28994	29060	break;
28995	29061	}
28996	29062

		@@ -29000,7 +29066,7 @@
29000	29066	stack[base + 27] = (uint64_t)(((const struct listnode *)(stack[base + 27]))->next);
29001	29067	if(/typeid/0 != ((uint64_t )(stack[base + 28]/typeid*/))[0])
29002	29068	{
29003		- label = 2388LLU; // jump to alternative
	29069	+ label = 2393LLU; // jump to alternative
29004	29070	break;
29005	29071	}
29006	29072

		@@ -29010,15 +29076,15 @@
29010	29076	// case
29011	29077	if(!stack[base + 26]/elemindex/)
29012	29078	{
29013		- label = 2390LLU; // jump to alternative
	29079	+ label = 2395LLU; // jump to alternative
29014	29080	break;
29015	29081	}
29016	29082
29017	29083	// consequent
29018	29084	// call matchsym from initfrom
29019		- stack[base + 32LLU] = 2392LLU/throw to this address/;
	29085	+ stack[base + 32LLU] = 2397LLU/throw to this address/;
29020	29086	stack[base + 33LLU] = base;
29021		- stack[base + 34LLU] = 2393LLU;
	29087	+ stack[base + 34LLU] = 2398LLU;
29022	29088	// arguments for call to matchsym
29023	29089	stack[base + 35LLU] = stack[base + 0]/fnid/;
29024	29090	stack[base + 36LLU] = 44LLU;

		@@ -29028,32 +29094,32 @@
29028	29094	label = 212LLU; // matchsym
29029	29095	break;
29030	29096	}
29031		- case 2392LLU: // copy-back deleter (matchsym to initfrom)
	29097	+ case 2397LLU: // copy-back deleter (matchsym to initfrom)
29032	29098	{
29033	29099	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
29034	29100	// copy mutable arguments back from call to matchsym
29035	29101	stack[base + 7]/lookahead/ = stack[base + 37LLU];
29036		- label = 2389LLU; // continue to roll stack
	29102	+ label = 2394LLU; // continue to roll stack
29037	29103	break;
29038	29104	}
29039		- case 2393LLU: // return from matchsym to initfrom
	29105	+ case 2398LLU: // return from matchsym to initfrom
29040	29106	{
29041	29107	// copy mutable arguments back from call to matchsym
29042	29108	stack[base + 7]/lookahead/ = stack[base + 37LLU];
29043		- label = 2391LLU; // consequent complete
	29109	+ label = 2396LLU; // consequent complete
29044	29110	break;
29045	29111	}
29046		- case 2390LLU: // alternative
	29112	+ case 2395LLU: // alternative
29047	29113	{
29048		- label = 2391LLU; // alternative complete
	29114	+ label = 2396LLU; // alternative complete
29049	29115	break;
29050	29116	}
29051		- case 2391LLU: // completed if-then-else
	29117	+ case 2396LLU: // completed if-then-else
29052	29118	{
29053	29119	// call ParseToken from initfrom
29054		- stack[base + 32LLU] = 2394LLU/throw to this address/;
	29120	+ stack[base + 32LLU] = 2399LLU/throw to this address/;
29055	29121	stack[base + 33LLU] = base;
29056		- stack[base + 34LLU] = 2395LLU;
	29122	+ stack[base + 34LLU] = 2400LLU;
29057	29123	// arguments for call to ParseToken
29058	29124	stack[base + 37LLU] = stack[base + 7]/lookahead/;
29059	29125	// set stack-base & callee-address

		@@ -29061,15 +29127,15 @@
29061	29127	label = 3LLU; // ParseToken
29062	29128	break;
29063	29129	}
29064		- case 2394LLU: // copy-back deleter (ParseToken to initfrom)
	29130	+ case 2399LLU: // copy-back deleter (ParseToken to initfrom)
29065	29131	{
29066	29132	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
29067	29133	// copy mutable arguments back from call to ParseToken
29068	29134	stack[base + 7]/lookahead/ = stack[base + 37LLU];
29069		- label = 2389LLU; // continue to roll stack
	29135	+ label = 2394LLU; // continue to roll stack
29070	29136	break;
29071	29137	}
29072		- case 2395LLU: // return from ParseToken to initfrom
	29138	+ case 2400LLU: // return from ParseToken to initfrom
29073	29139	{
29074	29140	// copy mutable arguments back from call to ParseToken
29075	29141	stack[base + 7]/lookahead/ = stack[base + 37LLU];

		@@ -29077,9 +29143,9 @@
29077	29143	stack[base + 12] = stack[base + 35LLU];
29078	29144	stack[base + 13] = stack[base + 36LLU];
29079	29145	// call equ from initfrom
29080		- stack[base + 32LLU] = 2396LLU/throw to this address/;
	29146	+ stack[base + 32LLU] = 2401LLU/throw to this address/;
29081	29147	stack[base + 33LLU] = base;
29082		- stack[base + 34LLU] = 2397LLU;
	29148	+ stack[base + 34LLU] = 2402LLU;
29083	29149	// arguments for call to equ
29084	29150	stack[base + 36LLU] = stack[base + 12]/variant/;
29085	29151	stack[base + 37LLU] = 4LLU;

		@@ -29088,14 +29154,14 @@
29088	29154	label = 18446744073709551600LLU; // equ
29089	29155	break;
29090	29156	}
29091		- case 2396LLU: // copy-back deleter (equ to initfrom)
	29157	+ case 2401LLU: // copy-back deleter (equ to initfrom)
29092	29158	{
29093	29159	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
29094	29160	// copy mutable arguments back from call to equ
29095		- label = 2389LLU; // continue to roll stack
	29161	+ label = 2394LLU; // continue to roll stack
29096	29162	break;
29097	29163	}
29098		- case 2397LLU: // return from equ to initfrom
	29164	+ case 2402LLU: // return from equ to initfrom
29099	29165	{
29100	29166	// copy mutable arguments back from call to equ
29101	29167	// copy back results provided by call to equ

		@@ -29102,21 +29168,21 @@
29102	29168	stack[base + 10] = stack[base + 35LLU];
29103	29169	if(!stack[base + 10]/isequal/)
29104	29170	{
29105		- label = 2398LLU; // jump to alternative
	29171	+ label = 2403LLU; // jump to alternative
29106	29172	break;
29107	29173	}
29108	29174
29109	29175	// consequent
29110		- label = 2399LLU; // consequent complete
	29176	+ label = 2404LLU; // consequent complete
29111	29177	break;
29112	29178	}
29113		- case 2398LLU: // alternative
	29179	+ case 2403LLU: // alternative
29114	29180	{
29115	29181	fprintf(stderr, "%s", "constructor requires variables but found ");
29116	29182	// call reporttok from initfrom
29117		- stack[base + 32LLU] = 2400LLU/throw to this address/;
	29183	+ stack[base + 32LLU] = 2405LLU/throw to this address/;
29118	29184	stack[base + 33LLU] = base;
29119		- stack[base + 34LLU] = 2401LLU;
	29185	+ stack[base + 34LLU] = 2406LLU;
29120	29186	// arguments for call to reporttok
29121	29187	stack[base + 35LLU] = stack[base + 12]/variant/;
29122	29188	stack[base + 36LLU] = stack[base + 13]/content/;

		@@ -29125,27 +29191,27 @@
29125	29191	label = 18446744073709551582LLU; // reporttok
29126	29192	break;
29127	29193	}
29128		- case 2400LLU: // copy-back deleter (reporttok to initfrom)
	29194	+ case 2405LLU: // copy-back deleter (reporttok to initfrom)
29129	29195	{
29130	29196	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
29131	29197	// copy mutable arguments back from call to reporttok
29132		- label = 2389LLU; // continue to roll stack
	29198	+ label = 2394LLU; // continue to roll stack
29133	29199	break;
29134	29200	}
29135		- case 2401LLU: // return from reporttok to initfrom
	29201	+ case 2406LLU: // return from reporttok to initfrom
29136	29202	{
29137	29203	// copy mutable arguments back from call to reporttok
29138	29204	fprintf(stderr, "%s", "\n");
29139	29205	exit(-1);
29140		- label = 2399LLU; // alternative complete
	29206	+ label = 2404LLU; // alternative complete
29141	29207	break;
29142	29208	}
29143		- case 2399LLU: // completed if-then-else
	29209	+ case 2404LLU: // completed if-then-else
29144	29210	{
29145	29211	// call getlettype from initfrom
29146		- stack[base + 33LLU] = 2402LLU/throw to this address/;
	29212	+ stack[base + 33LLU] = 2407LLU/throw to this address/;
29147	29213	stack[base + 34LLU] = base;
29148		- stack[base + 35LLU] = 2403LLU;
	29214	+ stack[base + 35LLU] = 2408LLU;
29149	29215	// arguments for call to getlettype
29150	29216	stack[base + 37LLU] = stack[base + 0]/fnid/;
29151	29217	stack[base + 38LLU] = stack[base + 13]/content/;

		@@ -29156,14 +29222,14 @@
29156	29222	label = 651LLU; // getlettype
29157	29223	break;
29158	29224	}
29159		- case 2402LLU: // copy-back deleter (getlettype to initfrom)
	29225	+ case 2407LLU: // copy-back deleter (getlettype to initfrom)
29160	29226	{
29161	29227	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
29162	29228	// copy mutable arguments back from call to getlettype
29163		- label = 2389LLU; // continue to roll stack
	29229	+ label = 2394LLU; // continue to roll stack
29164	29230	break;
29165	29231	}
29166		- case 2403LLU: // return from getlettype to initfrom
	29232	+ case 2408LLU: // return from getlettype to initfrom
29167	29233	{
29168	29234	// copy mutable arguments back from call to getlettype
29169	29235	// copy back results provided by call to getlettype

		@@ -29171,7 +29237,7 @@
29171	29237	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
29172	29238	if(!newstack)
29173	29239	{
29174		- label = 2389LLU; // throw: begin to unroll stack
	29240	+ label = 2394LLU; // throw: begin to unroll stack
29175	29241	break;
29176	29242	}
29177	29243

		@@ -29178,9 +29244,9 @@
29178	29244	newstack[15LLU] = 9876543210LLU; // overflow-marker
29179	29245	// call equtype from initfrom
29180	29246	newstack[0] = (uint64_t)stack; // backup stack location
29181		- newstack[1] = 2404LLU;
	29247	+ newstack[1] = 2409LLU;
29182	29248	newstack[2] = base;
29183		- newstack[3] = 2405LLU;
	29249	+ newstack[3] = 2410LLU;
29184	29250	// arguments for call to equtype
29185	29251	newstack[5LLU] = stack[base + 30]/dsttype/;
29186	29252	newstack[6LLU] = stack[base + 32]/srctype/;

		@@ -29190,7 +29256,7 @@
29190	29256	label = 342LLU; // equtype
29191	29257	break;
29192	29258	}
29193		- case 2404LLU: // copy-back deleter (equtype to initfrom)
	29259	+ case 2409LLU: // copy-back deleter (equtype to initfrom)
29194	29260	{
29195	29261	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
29196	29262	uint64_t oldstack = (uint64_t )stack[0];

		@@ -29202,10 +29268,10 @@
29202	29268	}
29203	29269	Free(15LLU + 1, sizeof(uint64_t), stack);
29204	29270	stack = oldstack;
29205		- label = 2389LLU; // continue to unroll stack
	29271	+ label = 2394LLU; // continue to unroll stack
29206	29272	break;
29207	29273	}
29208		- case 2405LLU: // return from equtype to initfrom
	29274	+ case 2410LLU: // return from equtype to initfrom
29209	29275	{
29210	29276	uint64_t oldstack = (uint64_t )stack[0];
29211	29277	// copy mutable arguments back from call to equtype

		@@ -29220,7 +29286,7 @@
29220	29286	stack = oldstack;
29221	29287	if(!stack[base + 10]/isequal/)
29222	29288	{
29223		- label = 2406LLU; // jump to alternative
	29289	+ label = 2411LLU; // jump to alternative
29224	29290	break;
29225	29291	}
29226	29292

		@@ -29227,7 +29293,7 @@
29227	29293	// consequent
29228	29294	if(/typename/0 != ((uint64_t )(stack[base + 30]/dsttype*/))[0])
29229	29295	{
29230		- label = 2409LLU; // jump to alternative
	29296	+ label = 2414LLU; // jump to alternative
29231	29297	break;
29232	29298	}
29233	29299

		@@ -29235,9 +29301,9 @@
29235	29301
29236	29302	// case
29237	29303	// call equ from initfrom
29238		- stack[base + 34LLU] = 2411LLU/throw to this address/;
	29304	+ stack[base + 34LLU] = 2416LLU/throw to this address/;
29239	29305	stack[base + 35LLU] = base;
29240		- stack[base + 36LLU] = 2412LLU;
	29306	+ stack[base + 36LLU] = 2417LLU;
29241	29307	// arguments for call to equ
29242	29308	stack[base + 38LLU] = 881834713755418624LLU;
29243	29309	stack[base + 39LLU] = stack[base + 33]/name/;

		@@ -29246,14 +29312,14 @@
29246	29312	label = 18446744073709551600LLU; // equ
29247	29313	break;
29248	29314	}
29249		- case 2411LLU: // copy-back deleter (equ to initfrom)
	29315	+ case 2416LLU: // copy-back deleter (equ to initfrom)
29250	29316	{
29251	29317	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
29252	29318	// copy mutable arguments back from call to equ
29253		- label = 2410LLU; // continue to roll stack
	29319	+ label = 2415LLU; // continue to roll stack
29254	29320	break;
29255	29321	}
29256		- case 2412LLU: // return from equ to initfrom
	29322	+ case 2417LLU: // return from equ to initfrom
29257	29323	{
29258	29324	// copy mutable arguments back from call to equ
29259	29325	// copy back results provided by call to equ

		@@ -29260,7 +29326,7 @@
29260	29326	stack[base + 10] = stack[base + 37LLU];
29261	29327	if(!stack[base + 10]/isequal/)
29262	29328	{
29263		- label = 2413LLU; // jump to alternative
	29329	+ label = 2418LLU; // jump to alternative
29264	29330	break;
29265	29331	}
29266	29332

		@@ -29267,9 +29333,9 @@
29267	29333	// consequent
29268	29334	printf("%s", "\n (((uint64_t **)(");
29269	29335	// call emitvaridx from initfrom
29270		- stack[base + 34LLU] = 2415LLU/throw to this address/;
	29336	+ stack[base + 34LLU] = 2420LLU/throw to this address/;
29271	29337	stack[base + 35LLU] = base;
29272		- stack[base + 36LLU] = 2416LLU;
	29338	+ stack[base + 36LLU] = 2421LLU;
29273	29339	// arguments for call to emitvaridx
29274	29340	stack[base + 37LLU] = stack[base + 3]/dstindex/;
29275	29341	// set stack-base & callee-address

		@@ -29277,21 +29343,21 @@
29277	29343	label = 691LLU; // emitvaridx
29278	29344	break;
29279	29345	}
29280		- case 2415LLU: // copy-back deleter (emitvaridx to initfrom)
	29346	+ case 2420LLU: // copy-back deleter (emitvaridx to initfrom)
29281	29347	{
29282	29348	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29283	29349	// copy mutable arguments back from call to emitvaridx
29284		- label = 2410LLU; // continue to roll stack
	29350	+ label = 2415LLU; // continue to roll stack
29285	29351	break;
29286	29352	}
29287		- case 2416LLU: // return from emitvaridx to initfrom
	29353	+ case 2421LLU: // return from emitvaridx to initfrom
29288	29354	{
29289	29355	// copy mutable arguments back from call to emitvaridx
29290	29356	printf("%s", "))[1][");
29291	29357	// call printnr from initfrom
29292		- stack[base + 34LLU] = 2417LLU/throw to this address/;
	29358	+ stack[base + 34LLU] = 2422LLU/throw to this address/;
29293	29359	stack[base + 35LLU] = base;
29294		- stack[base + 36LLU] = 2418LLU;
	29360	+ stack[base + 36LLU] = 2423LLU;
29295	29361	// arguments for call to printnr
29296	29362	stack[base + 37LLU] = stack[base + 26]/elemindex/;
29297	29363	// set stack-base & callee-address

		@@ -29299,21 +29365,21 @@
29299	29365	label = 18446744073709551590LLU; // printnr
29300	29366	break;
29301	29367	}
29302		- case 2417LLU: // copy-back deleter (printnr to initfrom)
	29368	+ case 2422LLU: // copy-back deleter (printnr to initfrom)
29303	29369	{
29304	29370	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29305	29371	// copy mutable arguments back from call to printnr
29306		- label = 2410LLU; // continue to roll stack
	29372	+ label = 2415LLU; // continue to roll stack
29307	29373	break;
29308	29374	}
29309		- case 2418LLU: // return from printnr to initfrom
	29375	+ case 2423LLU: // return from printnr to initfrom
29310	29376	{
29311	29377	// copy mutable arguments back from call to printnr
29312	29378	printf("%s", "]) = ");
29313	29379	// call emitvar from initfrom
29314		- stack[base + 34LLU] = 2419LLU/throw to this address/;
	29380	+ stack[base + 34LLU] = 2424LLU/throw to this address/;
29315	29381	stack[base + 35LLU] = base;
29316		- stack[base + 36LLU] = 2420LLU;
	29382	+ stack[base + 36LLU] = 2425LLU;
29317	29383	// arguments for call to emitvar
29318	29384	stack[base + 37LLU] = stack[base + 0]/fnid/;
29319	29385	stack[base + 38LLU] = stack[base + 13]/content/;

		@@ -29324,27 +29390,27 @@
29324	29390	label = 695LLU; // emitvar
29325	29391	break;
29326	29392	}
29327		- case 2419LLU: // copy-back deleter (emitvar to initfrom)
	29393	+ case 2424LLU: // copy-back deleter (emitvar to initfrom)
29328	29394	{
29329	29395	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29330	29396	// copy mutable arguments back from call to emitvar
29331		- label = 2410LLU; // continue to roll stack
	29397	+ label = 2415LLU; // continue to roll stack
29332	29398	break;
29333	29399	}
29334		- case 2420LLU: // return from emitvar to initfrom
	29400	+ case 2425LLU: // return from emitvar to initfrom
29335	29401	{
29336	29402	// copy mutable arguments back from call to emitvar
29337	29403	printf("%s", ";");
29338		- label = 2414LLU; // consequent complete
	29404	+ label = 2419LLU; // consequent complete
29339	29405	break;
29340	29406	}
29341		- case 2413LLU: // alternative
	29407	+ case 2418LLU: // alternative
29342	29408	{
29343	29409	printf("%s", "\n INIT(&(((uint64_t **)(");
29344	29410	// call emitvaridx from initfrom
29345		- stack[base + 34LLU] = 2421LLU/throw to this address/;
	29411	+ stack[base + 34LLU] = 2426LLU/throw to this address/;
29346	29412	stack[base + 35LLU] = base;
29347		- stack[base + 36LLU] = 2422LLU;
	29413	+ stack[base + 36LLU] = 2427LLU;
29348	29414	// arguments for call to emitvaridx
29349	29415	stack[base + 37LLU] = stack[base + 3]/dstindex/;
29350	29416	// set stack-base & callee-address

		@@ -29352,21 +29418,21 @@
29352	29418	label = 691LLU; // emitvaridx
29353	29419	break;
29354	29420	}
29355		- case 2421LLU: // copy-back deleter (emitvaridx to initfrom)
	29421	+ case 2426LLU: // copy-back deleter (emitvaridx to initfrom)
29356	29422	{
29357	29423	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29358	29424	// copy mutable arguments back from call to emitvaridx
29359		- label = 2410LLU; // continue to roll stack
	29425	+ label = 2415LLU; // continue to roll stack
29360	29426	break;
29361	29427	}
29362		- case 2422LLU: // return from emitvaridx to initfrom
	29428	+ case 2427LLU: // return from emitvaridx to initfrom
29363	29429	{
29364	29430	// copy mutable arguments back from call to emitvaridx
29365	29431	printf("%s", "))[1][");
29366	29432	// call printnr from initfrom
29367		- stack[base + 34LLU] = 2423LLU/throw to this address/;
	29433	+ stack[base + 34LLU] = 2428LLU/throw to this address/;
29368	29434	stack[base + 35LLU] = base;
29369		- stack[base + 36LLU] = 2424LLU;
	29435	+ stack[base + 36LLU] = 2429LLU;
29370	29436	// arguments for call to printnr
29371	29437	stack[base + 37LLU] = stack[base + 26]/elemindex/;
29372	29438	// set stack-base & callee-address

		@@ -29374,21 +29440,21 @@
29374	29440	label = 18446744073709551590LLU; // printnr
29375	29441	break;
29376	29442	}
29377		- case 2423LLU: // copy-back deleter (printnr to initfrom)
	29443	+ case 2428LLU: // copy-back deleter (printnr to initfrom)
29378	29444	{
29379	29445	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29380	29446	// copy mutable arguments back from call to printnr
29381		- label = 2410LLU; // continue to roll stack
	29447	+ label = 2415LLU; // continue to roll stack
29382	29448	break;
29383	29449	}
29384		- case 2424LLU: // return from printnr to initfrom
	29450	+ case 2429LLU: // return from printnr to initfrom
29385	29451	{
29386	29452	// copy mutable arguments back from call to printnr
29387	29453	printf("%s", "]), &");
29388	29454	// call emitvar from initfrom
29389		- stack[base + 34LLU] = 2425LLU/throw to this address/;
	29455	+ stack[base + 34LLU] = 2430LLU/throw to this address/;
29390	29456	stack[base + 35LLU] = base;
29391		- stack[base + 36LLU] = 2426LLU;
	29457	+ stack[base + 36LLU] = 2431LLU;
29392	29458	// arguments for call to emitvar
29393	29459	stack[base + 37LLU] = stack[base + 0]/fnid/;
29394	29460	stack[base + 38LLU] = stack[base + 13]/content/;

		@@ -29399,21 +29465,21 @@
29399	29465	label = 695LLU; // emitvar
29400	29466	break;
29401	29467	}
29402		- case 2425LLU: // copy-back deleter (emitvar to initfrom)
	29468	+ case 2430LLU: // copy-back deleter (emitvar to initfrom)
29403	29469	{
29404	29470	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29405	29471	// copy mutable arguments back from call to emitvar
29406		- label = 2410LLU; // continue to roll stack
	29472	+ label = 2415LLU; // continue to roll stack
29407	29473	break;
29408	29474	}
29409		- case 2426LLU: // return from emitvar to initfrom
	29475	+ case 2431LLU: // return from emitvar to initfrom
29410	29476	{
29411	29477	// copy mutable arguments back from call to emitvar
29412	29478	printf("%s", ");");
29413	29479	// call unscopelet from initfrom
29414		- stack[base + 34LLU] = 2427LLU/throw to this address/;
	29480	+ stack[base + 34LLU] = 2432LLU/throw to this address/;
29415	29481	stack[base + 35LLU] = base;
29416		- stack[base + 36LLU] = 2428LLU;
	29482	+ stack[base + 36LLU] = 2433LLU;
29417	29483	// arguments for call to unscopelet
29418	29484	stack[base + 37LLU] = stack[base + 0]/fnid/;
29419	29485	stack[base + 38LLU] = stack[base + 6]/scope/;

		@@ -29423,41 +29489,41 @@
29423	29489	label = 761LLU; // unscopelet
29424	29490	break;
29425	29491	}
29426		- case 2427LLU: // copy-back deleter (unscopelet to initfrom)
	29492	+ case 2432LLU: // copy-back deleter (unscopelet to initfrom)
29427	29493	{
29428	29494	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
29429	29495	// copy mutable arguments back from call to unscopelet
29430	29496	stack[base + 6]/scope/ = stack[base + 38LLU];
29431		- label = 2410LLU; // continue to roll stack
	29497	+ label = 2415LLU; // continue to roll stack
29432	29498	break;
29433	29499	}
29434		- case 2428LLU: // return from unscopelet to initfrom
	29500	+ case 2433LLU: // return from unscopelet to initfrom
29435	29501	{
29436	29502	// copy mutable arguments back from call to unscopelet
29437	29503	stack[base + 6]/scope/ = stack[base + 38LLU];
29438		- label = 2414LLU; // alternative complete
	29504	+ label = 2419LLU; // alternative complete
29439	29505	break;
29440	29506	}
29441		- case 2414LLU: // completed if-then-else
	29507	+ case 2419LLU: // completed if-then-else
29442	29508	{
29443	29509	((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29444		- label = 2408LLU; // case complete
	29510	+ label = 2413LLU; // case complete
29445	29511	break;
29446	29512	}
29447		- case 2410LLU: // copy-back deleter (switch)
	29513	+ case 2415LLU: // copy-back deleter (switch)
29448	29514	{
29449	29515	((uint64_t **)(stack[base + 30]))[1][0] = stack[base + 33];
29450		- label = 2389LLU; // continue to unroll stack
	29516	+ label = 2394LLU; // continue to unroll stack
29451	29517	break;
29452	29518	}
29453		- case 2409LLU: // try next case
	29519	+ case 2414LLU: // try next case
29454	29520	{
29455	29521	// default
29456	29522	printf("%s", "\n INIT(&(((uint64_t **)(");
29457	29523	// call emitvaridx from initfrom
29458		- stack[base + 33LLU] = 2429LLU/throw to this address/;
	29524	+ stack[base + 33LLU] = 2434LLU/throw to this address/;
29459	29525	stack[base + 34LLU] = base;
29460		- stack[base + 35LLU] = 2430LLU;
	29526	+ stack[base + 35LLU] = 2435LLU;
29461	29527	// arguments for call to emitvaridx
29462	29528	stack[base + 36LLU] = stack[base + 3]/dstindex/;
29463	29529	// set stack-base & callee-address

		@@ -29465,21 +29531,21 @@
29465	29531	label = 691LLU; // emitvaridx
29466	29532	break;
29467	29533	}
29468		- case 2429LLU: // copy-back deleter (emitvaridx to initfrom)
	29534	+ case 2434LLU: // copy-back deleter (emitvaridx to initfrom)
29469	29535	{
29470	29536	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29471	29537	// copy mutable arguments back from call to emitvaridx
29472		- label = 2389LLU; // continue to roll stack
	29538	+ label = 2394LLU; // continue to roll stack
29473	29539	break;
29474	29540	}
29475		- case 2430LLU: // return from emitvaridx to initfrom
	29541	+ case 2435LLU: // return from emitvaridx to initfrom
29476	29542	{
29477	29543	// copy mutable arguments back from call to emitvaridx
29478	29544	printf("%s", "))[1][");
29479	29545	// call printnr from initfrom
29480		- stack[base + 33LLU] = 2431LLU/throw to this address/;
	29546	+ stack[base + 33LLU] = 2436LLU/throw to this address/;
29481	29547	stack[base + 34LLU] = base;
29482		- stack[base + 35LLU] = 2432LLU;
	29548	+ stack[base + 35LLU] = 2437LLU;
29483	29549	// arguments for call to printnr
29484	29550	stack[base + 36LLU] = stack[base + 26]/elemindex/;
29485	29551	// set stack-base & callee-address

		@@ -29487,21 +29553,21 @@
29487	29553	label = 18446744073709551590LLU; // printnr
29488	29554	break;
29489	29555	}
29490		- case 2431LLU: // copy-back deleter (printnr to initfrom)
	29556	+ case 2436LLU: // copy-back deleter (printnr to initfrom)
29491	29557	{
29492	29558	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29493	29559	// copy mutable arguments back from call to printnr
29494		- label = 2389LLU; // continue to roll stack
	29560	+ label = 2394LLU; // continue to roll stack
29495	29561	break;
29496	29562	}
29497		- case 2432LLU: // return from printnr to initfrom
	29563	+ case 2437LLU: // return from printnr to initfrom
29498	29564	{
29499	29565	// copy mutable arguments back from call to printnr
29500	29566	printf("%s", "]), &");
29501	29567	// call emitvar from initfrom
29502		- stack[base + 33LLU] = 2433LLU/throw to this address/;
	29568	+ stack[base + 33LLU] = 2438LLU/throw to this address/;
29503	29569	stack[base + 34LLU] = base;
29504		- stack[base + 35LLU] = 2434LLU;
	29570	+ stack[base + 35LLU] = 2439LLU;
29505	29571	// arguments for call to emitvar
29506	29572	stack[base + 36LLU] = stack[base + 0]/fnid/;
29507	29573	stack[base + 37LLU] = stack[base + 13]/content/;

		@@ -29512,21 +29578,21 @@
29512	29578	label = 695LLU; // emitvar
29513	29579	break;
29514	29580	}
29515		- case 2433LLU: // copy-back deleter (emitvar to initfrom)
	29581	+ case 2438LLU: // copy-back deleter (emitvar to initfrom)
29516	29582	{
29517	29583	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29518	29584	// copy mutable arguments back from call to emitvar
29519		- label = 2389LLU; // continue to roll stack
	29585	+ label = 2394LLU; // continue to roll stack
29520	29586	break;
29521	29587	}
29522		- case 2434LLU: // return from emitvar to initfrom
	29588	+ case 2439LLU: // return from emitvar to initfrom
29523	29589	{
29524	29590	// copy mutable arguments back from call to emitvar
29525	29591	printf("%s", ");");
29526	29592	// call unscopelet from initfrom
29527		- stack[base + 33LLU] = 2435LLU/throw to this address/;
	29593	+ stack[base + 33LLU] = 2440LLU/throw to this address/;
29528	29594	stack[base + 34LLU] = base;
29529		- stack[base + 35LLU] = 2436LLU;
	29595	+ stack[base + 35LLU] = 2441LLU;
29530	29596	// arguments for call to unscopelet
29531	29597	stack[base + 36LLU] = stack[base + 0]/fnid/;
29532	29598	stack[base + 37LLU] = stack[base + 6]/scope/;

		@@ -29536,33 +29602,33 @@
29536	29602	label = 761LLU; // unscopelet
29537	29603	break;
29538	29604	}
29539		- case 2435LLU: // copy-back deleter (unscopelet to initfrom)
	29605	+ case 2440LLU: // copy-back deleter (unscopelet to initfrom)
29540	29606	{
29541	29607	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
29542	29608	// copy mutable arguments back from call to unscopelet
29543	29609	stack[base + 6]/scope/ = stack[base + 37LLU];
29544		- label = 2389LLU; // continue to roll stack
	29610	+ label = 2394LLU; // continue to roll stack
29545	29611	break;
29546	29612	}
29547		- case 2436LLU: // return from unscopelet to initfrom
	29613	+ case 2441LLU: // return from unscopelet to initfrom
29548	29614	{
29549	29615	// copy mutable arguments back from call to unscopelet
29550	29616	stack[base + 6]/scope/ = stack[base + 37LLU];
29551		- label = 2408LLU; // default complete
	29617	+ label = 2413LLU; // default complete
29552	29618	break;
29553	29619	}
29554		- case 2408LLU: // completed switch
	29620	+ case 2413LLU: // completed switch
29555	29621	{
29556		- label = 2407LLU; // consequent complete
	29622	+ label = 2412LLU; // consequent complete
29557	29623	break;
29558	29624	}
29559		- case 2406LLU: // alternative
	29625	+ case 2411LLU: // alternative
29560	29626	{
29561	29627	fprintf(stderr, "%s", "in function ");
29562	29628	// call reportid from initfrom
29563		- stack[base + 33LLU] = 2437LLU/throw to this address/;
	29629	+ stack[base + 33LLU] = 2442LLU/throw to this address/;
29564	29630	stack[base + 34LLU] = base;
29565		- stack[base + 35LLU] = 2438LLU;
	29631	+ stack[base + 35LLU] = 2443LLU;
29566	29632	// arguments for call to reportid
29567	29633	stack[base + 36LLU] = stack[base + 0]/fnid/;
29568	29634	// set stack-base & callee-address

		@@ -29570,14 +29636,14 @@
29570	29636	label = 18446744073709551586LLU; // reportid
29571	29637	break;
29572	29638	}
29573		- case 2437LLU: // copy-back deleter (reportid to initfrom)
	29639	+ case 2442LLU: // copy-back deleter (reportid to initfrom)
29574	29640	{
29575	29641	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
29576	29642	// copy mutable arguments back from call to reportid
29577		- label = 2389LLU; // continue to roll stack
	29643	+ label = 2394LLU; // continue to roll stack
29578	29644	break;
29579	29645	}
29580		- case 2438LLU: // return from reportid to initfrom
	29646	+ case 2443LLU: // return from reportid to initfrom
29581	29647	{
29582	29648	// copy mutable arguments back from call to reportid
29583	29649	fprintf(stderr, "%s", ": constructor of type ");

		@@ -29584,7 +29650,7 @@
29584	29650	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
29585	29651	if(!newstack)
29586	29652	{
29587		- label = 2389LLU; // throw: begin to unroll stack
	29653	+ label = 2394LLU; // throw: begin to unroll stack
29588	29654	break;
29589	29655	}
29590	29656

		@@ -29591,9 +29657,9 @@
29591	29657	newstack[10LLU] = 9876543210LLU; // overflow-marker
29592	29658	// call reporttype from initfrom
29593	29659	newstack[0] = (uint64_t)stack; // backup stack location
29594		- newstack[1] = 2439LLU;
	29660	+ newstack[1] = 2444LLU;
29595	29661	newstack[2] = base;
29596		- newstack[3] = 2440LLU;
	29662	+ newstack[3] = 2445LLU;
29597	29663	// arguments for call to reporttype
29598	29664	newstack[4LLU] = stack[base + 30]/dsttype/;
29599	29665	stack = newstack;

		@@ -29602,7 +29668,7 @@
29602	29668	label = 316LLU; // reporttype
29603	29669	break;
29604	29670	}
29605		- case 2439LLU: // copy-back deleter (reporttype to initfrom)
	29671	+ case 2444LLU: // copy-back deleter (reporttype to initfrom)
29606	29672	{
29607	29673	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
29608	29674	uint64_t oldstack = (uint64_t )stack[0];

		@@ -29614,10 +29680,10 @@
29614	29680	}
29615	29681	Free(10LLU + 1, sizeof(uint64_t), stack);
29616	29682	stack = oldstack;
29617		- label = 2389LLU; // continue to unroll stack
	29683	+ label = 2394LLU; // continue to unroll stack
29618	29684	break;
29619	29685	}
29620		- case 2440LLU: // return from reporttype to initfrom
	29686	+ case 2445LLU: // return from reporttype to initfrom
29621	29687	{
29622	29688	uint64_t oldstack = (uint64_t )stack[0];
29623	29689	// copy mutable arguments back from call to reporttype

		@@ -29632,7 +29698,7 @@
29632	29698	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
29633	29699	if(!newstack)
29634	29700	{
29635		- label = 2389LLU; // throw: begin to unroll stack
	29701	+ label = 2394LLU; // throw: begin to unroll stack
29636	29702	break;
29637	29703	}
29638	29704

		@@ -29639,9 +29705,9 @@
29639	29705	newstack[10LLU] = 9876543210LLU; // overflow-marker
29640	29706	// call reporttype from initfrom
29641	29707	newstack[0] = (uint64_t)stack; // backup stack location
29642		- newstack[1] = 2441LLU;
	29708	+ newstack[1] = 2446LLU;
29643	29709	newstack[2] = base;
29644		- newstack[3] = 2442LLU;
	29710	+ newstack[3] = 2447LLU;
29645	29711	// arguments for call to reporttype
29646	29712	newstack[4LLU] = stack[base + 30]/dsttype/;
29647	29713	stack = newstack;

		@@ -29650,7 +29716,7 @@
29650	29716	label = 316LLU; // reporttype
29651	29717	break;
29652	29718	}
29653		- case 2441LLU: // copy-back deleter (reporttype to initfrom)
	29719	+ case 2446LLU: // copy-back deleter (reporttype to initfrom)
29654	29720	{
29655	29721	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
29656	29722	uint64_t oldstack = (uint64_t )stack[0];

		@@ -29662,10 +29728,10 @@
29662	29728	}
29663	29729	Free(10LLU + 1, sizeof(uint64_t), stack);
29664	29730	stack = oldstack;
29665		- label = 2389LLU; // continue to unroll stack
	29731	+ label = 2394LLU; // continue to unroll stack
29666	29732	break;
29667	29733	}
29668		- case 2442LLU: // return from reporttype to initfrom
	29734	+ case 2447LLU: // return from reporttype to initfrom
29669	29735	{
29670	29736	uint64_t oldstack = (uint64_t )stack[0];
29671	29737	// copy mutable arguments back from call to reporttype

		@@ -29680,7 +29746,7 @@
29680	29746	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
29681	29747	if(!newstack)
29682	29748	{
29683		- label = 2389LLU; // throw: begin to unroll stack
	29749	+ label = 2394LLU; // throw: begin to unroll stack
29684	29750	break;
29685	29751	}
29686	29752

		@@ -29687,9 +29753,9 @@
29687	29753	newstack[10LLU] = 9876543210LLU; // overflow-marker
29688	29754	// call reporttype from initfrom
29689	29755	newstack[0] = (uint64_t)stack; // backup stack location
29690		- newstack[1] = 2443LLU;
	29756	+ newstack[1] = 2448LLU;
29691	29757	newstack[2] = base;
29692		- newstack[3] = 2444LLU;
	29758	+ newstack[3] = 2449LLU;
29693	29759	// arguments for call to reporttype
29694	29760	newstack[4LLU] = stack[base + 32]/srctype/;
29695	29761	stack = newstack;

		@@ -29698,7 +29764,7 @@
29698	29764	label = 316LLU; // reporttype
29699	29765	break;
29700	29766	}
29701		- case 2443LLU: // copy-back deleter (reporttype to initfrom)
	29767	+ case 2448LLU: // copy-back deleter (reporttype to initfrom)
29702	29768	{
29703	29769	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
29704	29770	uint64_t oldstack = (uint64_t )stack[0];

		@@ -29710,10 +29776,10 @@
29710	29776	}
29711	29777	Free(10LLU + 1, sizeof(uint64_t), stack);
29712	29778	stack = oldstack;
29713		- label = 2389LLU; // continue to unroll stack
	29779	+ label = 2394LLU; // continue to unroll stack
29714	29780	break;
29715	29781	}
29716		- case 2444LLU: // return from reporttype to initfrom
	29782	+ case 2449LLU: // return from reporttype to initfrom
29717	29783	{
29718	29784	uint64_t oldstack = (uint64_t )stack[0];
29719	29785	// copy mutable arguments back from call to reporttype

		@@ -29726,9 +29792,9 @@
29726	29792	stack = oldstack;
29727	29793	fprintf(stderr, "%s", " ");
29728	29794	// call reportid from initfrom
29729		- stack[base + 33LLU] = 2445LLU/throw to this address/;
	29795	+ stack[base + 33LLU] = 2450LLU/throw to this address/;
29730	29796	stack[base + 34LLU] = base;
29731		- stack[base + 35LLU] = 2446LLU;
	29797	+ stack[base + 35LLU] = 2451LLU;
29732	29798	// arguments for call to reportid
29733	29799	stack[base + 36LLU] = stack[base + 13]/content/;
29734	29800	// set stack-base & callee-address

		@@ -29736,22 +29802,22 @@
29736	29802	label = 18446744073709551586LLU; // reportid
29737	29803	break;
29738	29804	}
29739		- case 2445LLU: // copy-back deleter (reportid to initfrom)
	29805	+ case 2450LLU: // copy-back deleter (reportid to initfrom)
29740	29806	{
29741	29807	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
29742	29808	// copy mutable arguments back from call to reportid
29743		- label = 2389LLU; // continue to roll stack
	29809	+ label = 2394LLU; // continue to roll stack
29744	29810	break;
29745	29811	}
29746		- case 2446LLU: // return from reportid to initfrom
	29812	+ case 2451LLU: // return from reportid to initfrom
29747	29813	{
29748	29814	// copy mutable arguments back from call to reportid
29749	29815	fprintf(stderr, "%s", "\n");
29750	29816	exit(-1);
29751		- label = 2407LLU; // alternative complete
	29817	+ label = 2412LLU; // alternative complete
29752	29818	break;
29753	29819	}
29754		- case 2407LLU: // completed if-then-else
	29820	+ case 2412LLU: // completed if-then-else
29755	29821	{
29756	29822
29757	29823	uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);

		@@ -29759,7 +29825,7 @@
29759	29825	newstack[0] = (uint64_t)stack; // backup stack location
29760	29826	newstack[1] = 1234567890;
29761	29827	newstack[2] = base;
29762		- newstack[3] = 2447LLU;
	29828	+ newstack[3] = 2452LLU;
29763	29829	stack = newstack;
29764	29830	// set stack-base & callee-address
29765	29831	base = 4/deloffset/;

		@@ -29766,7 +29832,7 @@
29766	29832	label = 296LLU; // ~type
29767	29833	break;
29768	29834	}
29769		- case 2447LLU: // return from ~type to initfrom
	29835	+ case 2452LLU: // return from ~type to initfrom
29770	29836	{
29771	29837	stack = (uint64_t *)stack[0];
29772	29838	// releasing toplevel container

		@@ -29774,27 +29840,27 @@
29774	29840
29775	29841	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
29776	29842	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29777		- label = 2387LLU; // case complete
	29843	+ label = 2392LLU; // case complete
29778	29844	break;
29779	29845	}
29780		- case 2389LLU: // copy-back deleter (switch)
	29846	+ case 2394LLU: // copy-back deleter (switch)
29781	29847	{
29782	29848	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 31];
29783	29849	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 30];
29784		- label = 2386LLU; // continue to unroll stack
	29850	+ label = 2391LLU; // continue to unroll stack
29785	29851	break;
29786	29852	}
29787		- case 2388LLU: // try next case
	29853	+ case 2393LLU: // try next case
29788	29854	{
29789	29855	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
29790	29856	exit(-1);
29791	29857	}
29792		- case 2387LLU: // completed switch
	29858	+ case 2392LLU: // completed switch
29793	29859	{
29794	29860	// call add from initfrom
29795		- stack[base + 30LLU] = 2448LLU/throw to this address/;
	29861	+ stack[base + 30LLU] = 2453LLU/throw to this address/;
29796	29862	stack[base + 31LLU] = base;
29797		- stack[base + 32LLU] = 2449LLU;
	29863	+ stack[base + 32LLU] = 2454LLU;
29798	29864	// arguments for call to add
29799	29865	stack[base + 34LLU] = stack[base + 26]/elemindex/;
29800	29866	stack[base + 35LLU] = 1LLU;

		@@ -29803,34 +29869,34 @@
29803	29869	label = 18446744073709551605LLU; // add
29804	29870	break;
29805	29871	}
29806		- case 2448LLU: // copy-back deleter (add to initfrom)
	29872	+ case 2453LLU: // copy-back deleter (add to initfrom)
29807	29873	{
29808	29874	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
29809	29875	// copy mutable arguments back from call to add
29810		- label = 2386LLU; // continue to roll stack
	29876	+ label = 2391LLU; // continue to roll stack
29811	29877	break;
29812	29878	}
29813		- case 2449LLU: // return from add to initfrom
	29879	+ case 2454LLU: // return from add to initfrom
29814	29880	{
29815	29881	// copy mutable arguments back from call to add
29816	29882	// copy back results provided by call to add
29817	29883	stack[base + 26] = stack[base + 33LLU];
29818	29884	((struct listnode )(stack[base + 29]/previous*/))->data = stack[base + 28];
29819		- label = 2384LLU; // repeat
	29885	+ label = 2389LLU; // repeat
29820	29886	break;
29821	29887	}
29822		- case 2386LLU: // copy-back deleter for while next
	29888	+ case 2391LLU: // copy-back deleter for while next
29823	29889	{
29824	29890	((struct listnode )(stack[base + 29]/previous*/))->data = stack[base + 28];
29825		- label = 2382LLU; // continue to unroll stack
	29891	+ label = 2387LLU; // continue to unroll stack
29826	29892	break;
29827	29893	}
29828		- case 2385LLU: // loop finished
	29894	+ case 2390LLU: // loop finished
29829	29895	{
29830	29896	// call matchsym from initfrom
29831		- stack[base + 30LLU] = 2450LLU/throw to this address/;
	29897	+ stack[base + 30LLU] = 2455LLU/throw to this address/;
29832	29898	stack[base + 31LLU] = base;
29833		- stack[base + 32LLU] = 2451LLU;
	29899	+ stack[base + 32LLU] = 2456LLU;
29834	29900	// arguments for call to matchsym
29835	29901	stack[base + 33LLU] = stack[base + 0]/fnid/;
29836	29902	stack[base + 34LLU] = 41LLU;

		@@ -29840,36 +29906,36 @@
29840	29906	label = 212LLU; // matchsym
29841	29907	break;
29842	29908	}
29843		- case 2450LLU: // copy-back deleter (matchsym to initfrom)
	29909	+ case 2455LLU: // copy-back deleter (matchsym to initfrom)
29844	29910	{
29845	29911	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
29846	29912	// copy mutable arguments back from call to matchsym
29847	29913	stack[base + 7]/lookahead/ = stack[base + 35LLU];
29848		- label = 2382LLU; // continue to roll stack
	29914	+ label = 2387LLU; // continue to roll stack
29849	29915	break;
29850	29916	}
29851		- case 2451LLU: // return from matchsym to initfrom
	29917	+ case 2456LLU: // return from matchsym to initfrom
29852	29918	{
29853	29919	// copy mutable arguments back from call to matchsym
29854	29920	stack[base + 7]/lookahead/ = stack[base + 35LLU];
29855	29921	((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
29856	29922	((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29857		- label = 2359LLU; // case complete
	29923	+ label = 2364LLU; // case complete
29858	29924	break;
29859	29925	}
29860		- case 2361LLU: // copy-back deleter (switch)
	29926	+ case 2366LLU: // copy-back deleter (switch)
29861	29927	{
29862	29928	((uint64_t **)(stack[base + 22]))[1][1] = stack[base + 24];
29863	29929	((uint64_t **)(stack[base + 22]))[1][0] = stack[base + 23];
29864		- label = 2356LLU; // continue to unroll stack
	29930	+ label = 2361LLU; // continue to unroll stack
29865	29931	break;
29866	29932	}
29867		- case 2360LLU: // try next case
	29933	+ case 2365LLU: // try next case
29868	29934	{
29869	29935	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
29870	29936	exit(-1);
29871	29937	}
29872		- case 2359LLU: // completed switch
	29938	+ case 2364LLU: // completed switch
29873	29939	{
29874	29940
29875	29941	uint64_t newstack = (uint64_t )(stack[base + 22] - sizeof(uint64_t) * 4);

		@@ -29877,7 +29943,7 @@
29877	29943	newstack[0] = (uint64_t)stack; // backup stack location
29878	29944	newstack[1] = 1234567890;
29879	29945	newstack[2] = base;
29880		- newstack[3] = 2452LLU;
	29946	+ newstack[3] = 2457LLU;
29881	29947	stack = newstack;
29882	29948	// set stack-base & callee-address
29883	29949	base = 4/deloffset/;

		@@ -29884,7 +29950,7 @@
29884	29950	label = 870LLU; // ~variant
29885	29951	break;
29886	29952	}
29887		- case 2452LLU: // return from ~variant to initfrom
	29953	+ case 2457LLU: // return from ~variant to initfrom
29888	29954	{
29889	29955	stack = (uint64_t *)stack[0];
29890	29956	// releasing toplevel container

		@@ -29893,23 +29959,23 @@
29893	29959	((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
29894	29960	((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
29895	29961	((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29896		- label = 2354LLU; // case complete
	29962	+ label = 2359LLU; // case complete
29897	29963	break;
29898	29964	}
29899		- case 2356LLU: // copy-back deleter (switch)
	29965	+ case 2361LLU: // copy-back deleter (switch)
29900	29966	{
29901	29967	((uint64_t **)(stack[base + 17]))[1][2] = stack[base + 20];
29902	29968	((uint64_t **)(stack[base + 17]))[1][1] = stack[base + 19];
29903	29969	((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
29904		- label = 2316LLU; // continue to unroll stack
	29970	+ label = 2321LLU; // continue to unroll stack
29905	29971	break;
29906	29972	}
29907		- case 2355LLU: // try next case
	29973	+ case 2360LLU: // try next case
29908	29974	{
29909	29975	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
29910	29976	exit(-1);
29911	29977	}
29912		- case 2354LLU: // completed switch
	29978	+ case 2359LLU: // completed switch
29913	29979	{
29914	29980
29915	29981	uint64_t newstack = (uint64_t )(stack[base + 17] - sizeof(uint64_t) * 4);

		@@ -29917,7 +29983,7 @@
29917	29983	newstack[0] = (uint64_t)stack; // backup stack location
29918	29984	newstack[1] = 1234567890;
29919	29985	newstack[2] = base;
29920		- newstack[3] = 2453LLU;
	29986	+ newstack[3] = 2458LLU;
29921	29987	stack = newstack;
29922	29988	// set stack-base & callee-address
29923	29989	base = 4/deloffset/;

		@@ -29924,21 +29990,21 @@
29924	29990	label = 945LLU; // ~datadef
29925	29991	break;
29926	29992	}
29927		- case 2453LLU: // return from ~datadef to initfrom
	29993	+ case 2458LLU: // return from ~datadef to initfrom
29928	29994	{
29929	29995	stack = (uint64_t *)stack[0];
29930	29996	// releasing toplevel container
29931	29997	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 17] - sizeof(uint64_t) 4));
29932	29998
29933		- label = 2315LLU; // consequent complete
	29999	+ label = 2320LLU; // consequent complete
29934	30000	break;
29935	30001	}
29936		- case 2314LLU: // alternative
	30002	+ case 2319LLU: // alternative
29937	30003	{
29938	30004	// call equ from initfrom
29939		- stack[base + 17LLU] = 2454LLU/throw to this address/;
	30005	+ stack[base + 17LLU] = 2459LLU/throw to this address/;
29940	30006	stack[base + 18LLU] = base;
29941		- stack[base + 19LLU] = 2455LLU;
	30007	+ stack[base + 19LLU] = 2460LLU;
29942	30008	// arguments for call to equ
29943	30009	stack[base + 21LLU] = stack[base + 7]/lookahead/;
29944	30010	stack[base + 22LLU] = 40LLU;

		@@ -29947,14 +30013,14 @@
29947	30013	label = 18446744073709551600LLU; // equ
29948	30014	break;
29949	30015	}
29950		- case 2454LLU: // copy-back deleter (equ to initfrom)
	30016	+ case 2459LLU: // copy-back deleter (equ to initfrom)
29951	30017	{
29952	30018	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
29953	30019	// copy mutable arguments back from call to equ
29954		- label = 2259LLU; // continue to roll stack
	30020	+ label = 2295LLU; // continue to roll stack
29955	30021	break;
29956	30022	}
29957		- case 2455LLU: // return from equ to initfrom
	30023	+ case 2460LLU: // return from equ to initfrom
29958	30024	{
29959	30025	// copy mutable arguments back from call to equ
29960	30026	// copy back results provided by call to equ

		@@ -29961,7 +30027,7 @@
29961	30027	stack[base + 16] = stack[base + 20LLU];
29962	30028	if(!stack[base + 16]/construct/)
29963	30029	{
29964		- label = 2456LLU; // jump to alternative
	30030	+ label = 2461LLU; // jump to alternative
29965	30031	break;
29966	30032	}
29967	30033

		@@ -29968,7 +30034,7 @@
29968	30034	// consequent
29969	30035	if(/typename/0 != ((uint64_t )(stack[base + 1]/dsttype*/))[0])
29970	30036	{
29971		- label = 2459LLU; // jump to alternative
	30037	+ label = 2464LLU; // jump to alternative
29972	30038	break;
29973	30039	}
29974	30040

		@@ -29977,21 +30043,21 @@
29977	30043	// case
29978	30044	if(!stack[base + 9]/fncanthrow/)
29979	30045	{
29980		- label = 2461LLU; // jump to alternative
	30046	+ label = 2466LLU; // jump to alternative
29981	30047	break;
29982	30048	}
29983	30049
29984	30050	// consequent
29985		- label = 2462LLU; // consequent complete
	30051	+ label = 2467LLU; // consequent complete
29986	30052	break;
29987	30053	}
29988		- case 2461LLU: // alternative
	30054	+ case 2466LLU: // alternative
29989	30055	{
29990	30056	fprintf(stderr, "%s", "in function ");
29991	30057	// call reportid from initfrom
29992		- stack[base + 18LLU] = 2463LLU/throw to this address/;
	30058	+ stack[base + 18LLU] = 2468LLU/throw to this address/;
29993	30059	stack[base + 19LLU] = base;
29994		- stack[base + 20LLU] = 2464LLU;
	30060	+ stack[base + 20LLU] = 2469LLU;
29995	30061	// arguments for call to reportid
29996	30062	stack[base + 21LLU] = stack[base + 0]/fnid/;
29997	30063	// set stack-base & callee-address

		@@ -29999,21 +30065,21 @@
29999	30065	label = 18446744073709551586LLU; // reportid
30000	30066	break;
30001	30067	}
30002		- case 2463LLU: // copy-back deleter (reportid to initfrom)
	30068	+ case 2468LLU: // copy-back deleter (reportid to initfrom)
30003	30069	{
30004	30070	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
30005	30071	// copy mutable arguments back from call to reportid
30006		- label = 2460LLU; // continue to roll stack
	30072	+ label = 2465LLU; // continue to roll stack
30007	30073	break;
30008	30074	}
30009		- case 2464LLU: // return from reportid to initfrom
	30075	+ case 2469LLU: // return from reportid to initfrom
30010	30076	{
30011	30077	// copy mutable arguments back from call to reportid
30012	30078	fprintf(stderr, "%s", ": construction of data ");
30013	30079	// call reportid from initfrom
30014		- stack[base + 18LLU] = 2465LLU/throw to this address/;
	30080	+ stack[base + 18LLU] = 2470LLU/throw to this address/;
30015	30081	stack[base + 19LLU] = base;
30016		- stack[base + 20LLU] = 2466LLU;
	30082	+ stack[base + 20LLU] = 2471LLU;
30017	30083	// arguments for call to reportid
30018	30084	stack[base + 21LLU] = stack[base + 17]/typename/;
30019	30085	// set stack-base & callee-address

		@@ -30021,28 +30087,28 @@
30021	30087	label = 18446744073709551586LLU; // reportid
30022	30088	break;
30023	30089	}
30024		- case 2465LLU: // copy-back deleter (reportid to initfrom)
	30090	+ case 2470LLU: // copy-back deleter (reportid to initfrom)
30025	30091	{
30026	30092	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
30027	30093	// copy mutable arguments back from call to reportid
30028		- label = 2460LLU; // continue to roll stack
	30094	+ label = 2465LLU; // continue to roll stack
30029	30095	break;
30030	30096	}
30031		- case 2466LLU: // return from reportid to initfrom
	30097	+ case 2471LLU: // return from reportid to initfrom
30032	30098	{
30033	30099	// copy mutable arguments back from call to reportid
30034	30100	fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
30035	30101	exit(-1);
30036		- label = 2462LLU; // alternative complete
	30102	+ label = 2467LLU; // alternative complete
30037	30103	break;
30038	30104	}
30039		- case 2462LLU: // completed if-then-else
	30105	+ case 2467LLU: // completed if-then-else
30040	30106	{
30041	30107	printf("%s", "\n // construct ");
30042	30108	// call printid from initfrom
30043		- stack[base + 18LLU] = 2467LLU/throw to this address/;
	30109	+ stack[base + 18LLU] = 2472LLU/throw to this address/;
30044	30110	stack[base + 19LLU] = base;
30045		- stack[base + 20LLU] = 2468LLU;
	30111	+ stack[base + 20LLU] = 2473LLU;
30046	30112	// arguments for call to printid
30047	30113	stack[base + 21LLU] = stack[base + 17]/typename/;
30048	30114	// set stack-base & callee-address

		@@ -30050,21 +30116,21 @@
30050	30116	label = 18446744073709551587LLU; // printid
30051	30117	break;
30052	30118	}
30053		- case 2467LLU: // copy-back deleter (printid to initfrom)
	30119	+ case 2472LLU: // copy-back deleter (printid to initfrom)
30054	30120	{
30055	30121	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
30056	30122	// copy mutable arguments back from call to printid
30057		- label = 2460LLU; // continue to roll stack
	30123	+ label = 2465LLU; // continue to roll stack
30058	30124	break;
30059	30125	}
30060		- case 2468LLU: // return from printid to initfrom
	30126	+ case 2473LLU: // return from printid to initfrom
30061	30127	{
30062	30128	// copy mutable arguments back from call to printid
30063	30129	printf("%s", ".");
30064	30130	// call printid from initfrom
30065		- stack[base + 18LLU] = 2469LLU/throw to this address/;
	30131	+ stack[base + 18LLU] = 2474LLU/throw to this address/;
30066	30132	stack[base + 19LLU] = base;
30067		- stack[base + 20LLU] = 2470LLU;
	30133	+ stack[base + 20LLU] = 2475LLU;
30068	30134	// arguments for call to printid
30069	30135	stack[base + 21LLU] = stack[base + 13]/content/;
30070	30136	// set stack-base & callee-address

		@@ -30072,20 +30138,20 @@
30072	30138	label = 18446744073709551587LLU; // printid
30073	30139	break;
30074	30140	}
30075		- case 2469LLU: // copy-back deleter (printid to initfrom)
	30141	+ case 2474LLU: // copy-back deleter (printid to initfrom)
30076	30142	{
30077	30143	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
30078	30144	// copy mutable arguments back from call to printid
30079		- label = 2460LLU; // continue to roll stack
	30145	+ label = 2465LLU; // continue to roll stack
30080	30146	break;
30081	30147	}
30082		- case 2470LLU: // return from printid to initfrom
	30148	+ case 2475LLU: // return from printid to initfrom
30083	30149	{
30084	30150	// copy mutable arguments back from call to printid
30085	30151	// call FindData from initfrom
30086		- stack[base + 19LLU] = 2471LLU/throw to this address/;
	30152	+ stack[base + 19LLU] = 2476LLU/throw to this address/;
30087	30153	stack[base + 20LLU] = base;
30088		- stack[base + 21LLU] = 2472LLU;
	30154	+ stack[base + 21LLU] = 2477LLU;
30089	30155	// arguments for call to FindData
30090	30156	stack[base + 23LLU] = stack[base + 4]/typedefs/;
30091	30157	stack[base + 24LLU] = stack[base + 17]/typename/;

		@@ -30094,14 +30160,14 @@
30094	30160	label = 1004LLU; // FindData
30095	30161	break;
30096	30162	}
30097		- case 2471LLU: // copy-back deleter (FindData to initfrom)
	30163	+ case 2476LLU: // copy-back deleter (FindData to initfrom)
30098	30164	{
30099	30165	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
30100	30166	// copy mutable arguments back from call to FindData
30101		- label = 2460LLU; // continue to roll stack
	30167	+ label = 2465LLU; // continue to roll stack
30102	30168	break;
30103	30169	}
30104		- case 2472LLU: // return from FindData to initfrom
	30170	+ case 2477LLU: // return from FindData to initfrom
30105	30171	{
30106	30172	// copy mutable arguments back from call to FindData
30107	30173	// copy back results provided by call to FindData

		@@ -30108,7 +30174,7 @@
30108	30174	stack[base + 18] = stack[base + 22LLU];
30109	30175	if(/datadef/0 != ((uint64_t )(stack[base + 18]/reftypedef*/))[0])
30110	30176	{
30111		- label = 2474LLU; // jump to alternative
	30177	+ label = 2479LLU; // jump to alternative
30112	30178	break;
30113	30179	}
30114	30180

		@@ -30118,9 +30184,9 @@
30118	30184
30119	30185	// case
30120	30186	// call GetVariant from initfrom
30121		- stack[base + 24LLU] = 2476LLU/throw to this address/;
	30187	+ stack[base + 24LLU] = 2481LLU/throw to this address/;
30122	30188	stack[base + 25LLU] = base;
30123		- stack[base + 26LLU] = 2477LLU;
	30189	+ stack[base + 26LLU] = 2482LLU;
30124	30190	// arguments for call to GetVariant
30125	30191	stack[base + 29LLU] = stack[base + 0]/fnid/;
30126	30192	stack[base + 30LLU] = stack[base + 20]/variants/;

		@@ -30130,14 +30196,14 @@
30130	30196	label = 907LLU; // GetVariant
30131	30197	break;
30132	30198	}
30133		- case 2476LLU: // copy-back deleter (GetVariant to initfrom)
	30199	+ case 2481LLU: // copy-back deleter (GetVariant to initfrom)
30134	30200	{
30135	30201	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
30136	30202	// copy mutable arguments back from call to GetVariant
30137		- label = 2475LLU; // continue to roll stack
	30203	+ label = 2480LLU; // continue to roll stack
30138	30204	break;
30139	30205	}
30140		- case 2477LLU: // return from GetVariant to initfrom
	30206	+ case 2482LLU: // return from GetVariant to initfrom
30141	30207	{
30142	30208	// copy mutable arguments back from call to GetVariant
30143	30209	// copy back results provided by call to GetVariant

		@@ -30145,7 +30211,7 @@
30145	30211	stack[base + 23] = stack[base + 28LLU];
30146	30212	if(/variant/0 != ((uint64_t )(stack[base + 23]/constr*/))[0])
30147	30213	{
30148		- label = 2479LLU; // jump to alternative
	30214	+ label = 2484LLU; // jump to alternative
30149	30215	break;
30150	30216	}
30151	30217

		@@ -30153,29 +30219,29 @@
30153	30219	/TYPEIDS/stack[base + 25] = ((uint64_t *)(stack[base + 23]/constr/))[1][1]/elements*/;
30154	30220
30155	30221	// case
30156		- label = 2482LLU; // skip deleter
	30222	+ label = 2487LLU; // skip deleter
30157	30223	break;
30158	30224	}
30159		- case 2481LLU: // deleter
	30225	+ case 2486LLU: // deleter
30160	30226	{
30161	30227	// throw from initfrom
30162	30228	if(!stack[base + 26])
30163	30229	{
30164	30230	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 size\n");
30165		- label = 2480LLU; // skip, variable already deleted/unscoped
	30231	+ label = 2485LLU; // skip, variable already deleted/unscoped
30166	30232	break;
30167	30233	}
30168	30234	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 size\n");
30169		- label = 2480LLU; // continue unrolling stack, delete next variable
	30235	+ label = 2485LLU; // continue unrolling stack, delete next variable
30170	30236	break;
30171	30237	}
30172		- case 2482LLU: // skipped deleter
	30238	+ case 2487LLU: // skipped deleter
30173	30239	{
30174	30240	stack[base + 26] = 0;
30175	30241	stack[base + 26]/size/ = list_size(((struct listnode )(stack[base + 25]/TYPEIDS*/)));
30176	30242	if(!stack[base + 14]/forceerror/)
30177	30243	{
30178		- label = 2483LLU; // jump to alternative
	30244	+ label = 2488LLU; // jump to alternative
30179	30245	break;
30180	30246	}
30181	30247

		@@ -30182,9 +30248,9 @@
30182	30248	// consequent
30183	30249	printf("%s", "\n // if(!(");
30184	30250	// call emitvaridx from initfrom
30185		- stack[base + 27LLU] = 2485LLU/throw to this address/;
	30251	+ stack[base + 27LLU] = 2490LLU/throw to this address/;
30186	30252	stack[base + 28LLU] = base;
30187		- stack[base + 29LLU] = 2486LLU;
	30253	+ stack[base + 29LLU] = 2491LLU;
30188	30254	// arguments for call to emitvaridx
30189	30255	stack[base + 30LLU] = stack[base + 3]/dstindex/;
30190	30256	// set stack-base & callee-address

		@@ -30192,21 +30258,21 @@
30192	30258	label = 691LLU; // emitvaridx
30193	30259	break;
30194	30260	}
30195		- case 2485LLU: // copy-back deleter (emitvaridx to initfrom)
	30261	+ case 2490LLU: // copy-back deleter (emitvaridx to initfrom)
30196	30262	{
30197	30263	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30198	30264	// copy mutable arguments back from call to emitvaridx
30199		- label = 2481LLU; // continue to roll stack
	30265	+ label = 2486LLU; // continue to roll stack
30200	30266	break;
30201	30267	}
30202		- case 2486LLU: // return from emitvaridx to initfrom
	30268	+ case 2491LLU: // return from emitvaridx to initfrom
30203	30269	{
30204	30270	// copy mutable arguments back from call to emitvaridx
30205	30271	printf("%s", " = construct(");
30206	30272	// call printnr from initfrom
30207		- stack[base + 27LLU] = 2487LLU/throw to this address/;
	30273	+ stack[base + 27LLU] = 2492LLU/throw to this address/;
30208	30274	stack[base + 28LLU] = base;
30209		- stack[base + 29LLU] = 2488LLU;
	30275	+ stack[base + 29LLU] = 2493LLU;
30210	30276	// arguments for call to printnr
30211	30277	stack[base + 30LLU] = stack[base + 26]/size/;
30212	30278	// set stack-base & callee-address

		@@ -30214,27 +30280,27 @@
30214	30280	label = 18446744073709551590LLU; // printnr
30215	30281	break;
30216	30282	}
30217		- case 2487LLU: // copy-back deleter (printnr to initfrom)
	30283	+ case 2492LLU: // copy-back deleter (printnr to initfrom)
30218	30284	{
30219	30285	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30220	30286	// copy mutable arguments back from call to printnr
30221		- label = 2481LLU; // continue to roll stack
	30287	+ label = 2486LLU; // continue to roll stack
30222	30288	break;
30223	30289	}
30224		- case 2488LLU: // return from printnr to initfrom
	30290	+ case 2493LLU: // return from printnr to initfrom
30225	30291	{
30226	30292	// copy mutable arguments back from call to printnr
30227	30293	printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
30228		- label = 2484LLU; // consequent complete
	30294	+ label = 2489LLU; // consequent complete
30229	30295	break;
30230	30296	}
30231		- case 2483LLU: // alternative
	30297	+ case 2488LLU: // alternative
30232	30298	{
30233	30299	printf("%s", "\n if(!(");
30234	30300	// call emitvaridx from initfrom
30235		- stack[base + 27LLU] = 2489LLU/throw to this address/;
	30301	+ stack[base + 27LLU] = 2494LLU/throw to this address/;
30236	30302	stack[base + 28LLU] = base;
30237		- stack[base + 29LLU] = 2490LLU;
	30303	+ stack[base + 29LLU] = 2495LLU;
30238	30304	// arguments for call to emitvaridx
30239	30305	stack[base + 30LLU] = stack[base + 3]/dstindex/;
30240	30306	// set stack-base & callee-address

		@@ -30242,21 +30308,21 @@
30242	30308	label = 691LLU; // emitvaridx
30243	30309	break;
30244	30310	}
30245		- case 2489LLU: // copy-back deleter (emitvaridx to initfrom)
	30311	+ case 2494LLU: // copy-back deleter (emitvaridx to initfrom)
30246	30312	{
30247	30313	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30248	30314	// copy mutable arguments back from call to emitvaridx
30249		- label = 2481LLU; // continue to roll stack
	30315	+ label = 2486LLU; // continue to roll stack
30250	30316	break;
30251	30317	}
30252		- case 2490LLU: // return from emitvaridx to initfrom
	30318	+ case 2495LLU: // return from emitvaridx to initfrom
30253	30319	{
30254	30320	// copy mutable arguments back from call to emitvaridx
30255	30321	printf("%s", " = construct(");
30256	30322	// call printnr from initfrom
30257		- stack[base + 27LLU] = 2491LLU/throw to this address/;
	30323	+ stack[base + 27LLU] = 2496LLU/throw to this address/;
30258	30324	stack[base + 28LLU] = base;
30259		- stack[base + 29LLU] = 2492LLU;
	30325	+ stack[base + 29LLU] = 2497LLU;
30260	30326	// arguments for call to printnr
30261	30327	stack[base + 30LLU] = stack[base + 26]/size/;
30262	30328	// set stack-base & callee-address

		@@ -30264,26 +30330,26 @@
30264	30330	label = 18446744073709551590LLU; // printnr
30265	30331	break;
30266	30332	}
30267		- case 2491LLU: // copy-back deleter (printnr to initfrom)
	30333	+ case 2496LLU: // copy-back deleter (printnr to initfrom)
30268	30334	{
30269	30335	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30270	30336	// copy mutable arguments back from call to printnr
30271		- label = 2481LLU; // continue to roll stack
	30337	+ label = 2486LLU; // continue to roll stack
30272	30338	break;
30273	30339	}
30274		- case 2492LLU: // return from printnr to initfrom
	30340	+ case 2497LLU: // return from printnr to initfrom
30275	30341	{
30276	30342	// copy mutable arguments back from call to printnr
30277	30343	printf("%s", ")))");
30278		- label = 2484LLU; // alternative complete
	30344	+ label = 2489LLU; // alternative complete
30279	30345	break;
30280	30346	}
30281		- case 2484LLU: // completed if-then-else
	30347	+ case 2489LLU: // completed if-then-else
30282	30348	{
30283	30349	// call emitthrow from initfrom
30284		- stack[base + 27LLU] = 2493LLU/throw to this address/;
	30350	+ stack[base + 27LLU] = 2498LLU/throw to this address/;
30285	30351	stack[base + 28LLU] = base;
30286		- stack[base + 29LLU] = 2494LLU;
	30352	+ stack[base + 29LLU] = 2499LLU;
30287	30353	// arguments for call to emitthrow
30288	30354	stack[base + 30LLU] = stack[base + 6]/scope/;
30289	30355	// set stack-base & callee-address

		@@ -30291,22 +30357,22 @@
30291	30357	label = 1559LLU; // emitthrow
30292	30358	break;
30293	30359	}
30294		- case 2493LLU: // copy-back deleter (emitthrow to initfrom)
	30360	+ case 2498LLU: // copy-back deleter (emitthrow to initfrom)
30295	30361	{
30296	30362	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
30297	30363	// copy mutable arguments back from call to emitthrow
30298		- label = 2481LLU; // continue to roll stack
	30364	+ label = 2486LLU; // continue to roll stack
30299	30365	break;
30300	30366	}
30301		- case 2494LLU: // return from emitthrow to initfrom
	30367	+ case 2499LLU: // return from emitthrow to initfrom
30302	30368	{
30303	30369	// copy mutable arguments back from call to emitthrow
30304	30370	printf("%s", "\n // consequent");
30305	30371	printf("%s", "\n ((uint64_t *)");
30306	30372	// call emitvaridx from initfrom
30307		- stack[base + 27LLU] = 2495LLU/throw to this address/;
	30373	+ stack[base + 27LLU] = 2500LLU/throw to this address/;
30308	30374	stack[base + 28LLU] = base;
30309		- stack[base + 29LLU] = 2496LLU;
	30375	+ stack[base + 29LLU] = 2501LLU;
30310	30376	// arguments for call to emitvaridx
30311	30377	stack[base + 30LLU] = stack[base + 3]/dstindex/;
30312	30378	// set stack-base & callee-address

		@@ -30314,21 +30380,21 @@
30314	30380	label = 691LLU; // emitvaridx
30315	30381	break;
30316	30382	}
30317		- case 2495LLU: // copy-back deleter (emitvaridx to initfrom)
	30383	+ case 2500LLU: // copy-back deleter (emitvaridx to initfrom)
30318	30384	{
30319	30385	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30320	30386	// copy mutable arguments back from call to emitvaridx
30321		- label = 2481LLU; // continue to roll stack
	30387	+ label = 2486LLU; // continue to roll stack
30322	30388	break;
30323	30389	}
30324		- case 2496LLU: // return from emitvaridx to initfrom
	30390	+ case 2501LLU: // return from emitvaridx to initfrom
30325	30391	{
30326	30392	// copy mutable arguments back from call to emitvaridx
30327	30393	printf("%s", ")[0] = ");
30328	30394	// call printnr from initfrom
30329		- stack[base + 27LLU] = 2497LLU/throw to this address/;
	30395	+ stack[base + 27LLU] = 2502LLU/throw to this address/;
30330	30396	stack[base + 28LLU] = base;
30331		- stack[base + 29LLU] = 2498LLU;
	30397	+ stack[base + 29LLU] = 2503LLU;
30332	30398	// arguments for call to printnr
30333	30399	stack[base + 30LLU] = stack[base + 22]/varnr/;
30334	30400	// set stack-base & callee-address

		@@ -30336,21 +30402,21 @@
30336	30402	label = 18446744073709551590LLU; // printnr
30337	30403	break;
30338	30404	}
30339		- case 2497LLU: // copy-back deleter (printnr to initfrom)
	30405	+ case 2502LLU: // copy-back deleter (printnr to initfrom)
30340	30406	{
30341	30407	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30342	30408	// copy mutable arguments back from call to printnr
30343		- label = 2481LLU; // continue to roll stack
	30409	+ label = 2486LLU; // continue to roll stack
30344	30410	break;
30345	30411	}
30346		- case 2498LLU: // return from printnr to initfrom
	30412	+ case 2503LLU: // return from printnr to initfrom
30347	30413	{
30348	30414	// copy mutable arguments back from call to printnr
30349	30415	printf("%s", ";");
30350	30416	// call matchsym from initfrom
30351		- stack[base + 27LLU] = 2499LLU/throw to this address/;
	30417	+ stack[base + 27LLU] = 2504LLU/throw to this address/;
30352	30418	stack[base + 28LLU] = base;
30353		- stack[base + 29LLU] = 2500LLU;
	30419	+ stack[base + 29LLU] = 2505LLU;
30354	30420	// arguments for call to matchsym
30355	30421	stack[base + 30LLU] = stack[base + 0]/fnid/;
30356	30422	stack[base + 31LLU] = 40LLU;

		@@ -30360,46 +30426,46 @@
30360	30426	label = 212LLU; // matchsym
30361	30427	break;
30362	30428	}
30363		- case 2499LLU: // copy-back deleter (matchsym to initfrom)
	30429	+ case 2504LLU: // copy-back deleter (matchsym to initfrom)
30364	30430	{
30365	30431	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
30366	30432	// copy mutable arguments back from call to matchsym
30367	30433	stack[base + 7]/lookahead/ = stack[base + 32LLU];
30368		- label = 2481LLU; // continue to roll stack
	30434	+ label = 2486LLU; // continue to roll stack
30369	30435	break;
30370	30436	}
30371		- case 2500LLU: // return from matchsym to initfrom
	30437	+ case 2505LLU: // return from matchsym to initfrom
30372	30438	{
30373	30439	// copy mutable arguments back from call to matchsym
30374	30440	stack[base + 7]/lookahead/ = stack[base + 32LLU];
30375		- label = 2502LLU; // skip deleter
	30441	+ label = 2507LLU; // skip deleter
30376	30442	break;
30377	30443	}
30378		- case 2501LLU: // deleter
	30444	+ case 2506LLU: // deleter
30379	30445	{
30380	30446	// throw from initfrom
30381	30447	if(!stack[base + 27])
30382	30448	{
30383	30449	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 elemindex\n");
30384		- label = 2481LLU; // skip, variable already deleted/unscoped
	30450	+ label = 2486LLU; // skip, variable already deleted/unscoped
30385	30451	break;
30386	30452	}
30387	30453	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 elemindex\n");
30388		- label = 2481LLU; // continue unrolling stack, delete next variable
	30454	+ label = 2486LLU; // continue unrolling stack, delete next variable
30389	30455	break;
30390	30456	}
30391		- case 2502LLU: // skipped deleter
	30457	+ case 2507LLU: // skipped deleter
30392	30458	{
30393	30459	stack[base + 27] = 0;
30394	30460	flippedassign(stack[base + 25]/TYPEIDS/, &stack[base + 28]);
30395		- label = 2503LLU; // start to repeat
	30461	+ label = 2508LLU; // start to repeat
30396	30462	break;
30397	30463	}
30398		- case 2503LLU: // repeat from here
	30464	+ case 2508LLU: // repeat from here
30399	30465	{
30400	30466	if(!stack[base + 28])
30401	30467	{
30402		- label = 2504LLU; // break loop
	30468	+ label = 2509LLU; // break loop
30403	30469	break;
30404	30470	}
30405	30471

		@@ -30409,7 +30475,7 @@
30409	30475	stack[base + 28] = (uint64_t)(((const struct listnode *)(stack[base + 28]))->next);
30410	30476	if(/typeid/0 != ((uint64_t )(stack[base + 29]/typeid*/))[0])
30411	30477	{
30412		- label = 2507LLU; // jump to alternative
	30478	+ label = 2512LLU; // jump to alternative
30413	30479	break;
30414	30480	}
30415	30481

		@@ -30419,15 +30485,15 @@
30419	30485	// case
30420	30486	if(!stack[base + 27]/elemindex/)
30421	30487	{
30422		- label = 2509LLU; // jump to alternative
	30488	+ label = 2514LLU; // jump to alternative
30423	30489	break;
30424	30490	}
30425	30491
30426	30492	// consequent
30427	30493	// call matchsym from initfrom
30428		- stack[base + 33LLU] = 2511LLU/throw to this address/;
	30494	+ stack[base + 33LLU] = 2516LLU/throw to this address/;
30429	30495	stack[base + 34LLU] = base;
30430		- stack[base + 35LLU] = 2512LLU;
	30496	+ stack[base + 35LLU] = 2517LLU;
30431	30497	// arguments for call to matchsym
30432	30498	stack[base + 36LLU] = stack[base + 0]/fnid/;
30433	30499	stack[base + 37LLU] = 44LLU;

		@@ -30437,32 +30503,32 @@
30437	30503	label = 212LLU; // matchsym
30438	30504	break;
30439	30505	}
30440		- case 2511LLU: // copy-back deleter (matchsym to initfrom)
	30506	+ case 2516LLU: // copy-back deleter (matchsym to initfrom)
30441	30507	{
30442	30508	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
30443	30509	// copy mutable arguments back from call to matchsym
30444	30510	stack[base + 7]/lookahead/ = stack[base + 38LLU];
30445		- label = 2508LLU; // continue to roll stack
	30511	+ label = 2513LLU; // continue to roll stack
30446	30512	break;
30447	30513	}
30448		- case 2512LLU: // return from matchsym to initfrom
	30514	+ case 2517LLU: // return from matchsym to initfrom
30449	30515	{
30450	30516	// copy mutable arguments back from call to matchsym
30451	30517	stack[base + 7]/lookahead/ = stack[base + 38LLU];
30452		- label = 2510LLU; // consequent complete
	30518	+ label = 2515LLU; // consequent complete
30453	30519	break;
30454	30520	}
30455		- case 2509LLU: // alternative
	30521	+ case 2514LLU: // alternative
30456	30522	{
30457		- label = 2510LLU; // alternative complete
	30523	+ label = 2515LLU; // alternative complete
30458	30524	break;
30459	30525	}
30460		- case 2510LLU: // completed if-then-else
	30526	+ case 2515LLU: // completed if-then-else
30461	30527	{
30462	30528	// call ParseToken from initfrom
30463		- stack[base + 33LLU] = 2513LLU/throw to this address/;
	30529	+ stack[base + 33LLU] = 2518LLU/throw to this address/;
30464	30530	stack[base + 34LLU] = base;
30465		- stack[base + 35LLU] = 2514LLU;
	30531	+ stack[base + 35LLU] = 2519LLU;
30466	30532	// arguments for call to ParseToken
30467	30533	stack[base + 38LLU] = stack[base + 7]/lookahead/;
30468	30534	// set stack-base & callee-address

		@@ -30470,15 +30536,15 @@
30470	30536	label = 3LLU; // ParseToken
30471	30537	break;
30472	30538	}
30473		- case 2513LLU: // copy-back deleter (ParseToken to initfrom)
	30539	+ case 2518LLU: // copy-back deleter (ParseToken to initfrom)
30474	30540	{
30475	30541	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
30476	30542	// copy mutable arguments back from call to ParseToken
30477	30543	stack[base + 7]/lookahead/ = stack[base + 38LLU];
30478		- label = 2508LLU; // continue to roll stack
	30544	+ label = 2513LLU; // continue to roll stack
30479	30545	break;
30480	30546	}
30481		- case 2514LLU: // return from ParseToken to initfrom
	30547	+ case 2519LLU: // return from ParseToken to initfrom
30482	30548	{
30483	30549	// copy mutable arguments back from call to ParseToken
30484	30550	stack[base + 7]/lookahead/ = stack[base + 38LLU];

		@@ -30486,9 +30552,9 @@
30486	30552	stack[base + 12] = stack[base + 36LLU];
30487	30553	stack[base + 13] = stack[base + 37LLU];
30488	30554	// call equ from initfrom
30489		- stack[base + 33LLU] = 2515LLU/throw to this address/;
	30555	+ stack[base + 33LLU] = 2520LLU/throw to this address/;
30490	30556	stack[base + 34LLU] = base;
30491		- stack[base + 35LLU] = 2516LLU;
	30557	+ stack[base + 35LLU] = 2521LLU;
30492	30558	// arguments for call to equ
30493	30559	stack[base + 37LLU] = stack[base + 12]/variant/;
30494	30560	stack[base + 38LLU] = 4LLU;

		@@ -30497,14 +30563,14 @@
30497	30563	label = 18446744073709551600LLU; // equ
30498	30564	break;
30499	30565	}
30500		- case 2515LLU: // copy-back deleter (equ to initfrom)
	30566	+ case 2520LLU: // copy-back deleter (equ to initfrom)
30501	30567	{
30502	30568	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
30503	30569	// copy mutable arguments back from call to equ
30504		- label = 2508LLU; // continue to roll stack
	30570	+ label = 2513LLU; // continue to roll stack
30505	30571	break;
30506	30572	}
30507		- case 2516LLU: // return from equ to initfrom
	30573	+ case 2521LLU: // return from equ to initfrom
30508	30574	{
30509	30575	// copy mutable arguments back from call to equ
30510	30576	// copy back results provided by call to equ

		@@ -30511,21 +30577,21 @@
30511	30577	stack[base + 10] = stack[base + 36LLU];
30512	30578	if(!stack[base + 10]/isequal/)
30513	30579	{
30514		- label = 2517LLU; // jump to alternative
	30580	+ label = 2522LLU; // jump to alternative
30515	30581	break;
30516	30582	}
30517	30583
30518	30584	// consequent
30519		- label = 2518LLU; // consequent complete
	30585	+ label = 2523LLU; // consequent complete
30520	30586	break;
30521	30587	}
30522		- case 2517LLU: // alternative
	30588	+ case 2522LLU: // alternative
30523	30589	{
30524	30590	fprintf(stderr, "%s", "constructor requires variables but found ");
30525	30591	// call reporttok from initfrom
30526		- stack[base + 33LLU] = 2519LLU/throw to this address/;
	30592	+ stack[base + 33LLU] = 2524LLU/throw to this address/;
30527	30593	stack[base + 34LLU] = base;
30528		- stack[base + 35LLU] = 2520LLU;
	30594	+ stack[base + 35LLU] = 2525LLU;
30529	30595	// arguments for call to reporttok
30530	30596	stack[base + 36LLU] = stack[base + 12]/variant/;
30531	30597	stack[base + 37LLU] = stack[base + 13]/content/;

		@@ -30534,27 +30600,27 @@
30534	30600	label = 18446744073709551582LLU; // reporttok
30535	30601	break;
30536	30602	}
30537		- case 2519LLU: // copy-back deleter (reporttok to initfrom)
	30603	+ case 2524LLU: // copy-back deleter (reporttok to initfrom)
30538	30604	{
30539	30605	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
30540	30606	// copy mutable arguments back from call to reporttok
30541		- label = 2508LLU; // continue to roll stack
	30607	+ label = 2513LLU; // continue to roll stack
30542	30608	break;
30543	30609	}
30544		- case 2520LLU: // return from reporttok to initfrom
	30610	+ case 2525LLU: // return from reporttok to initfrom
30545	30611	{
30546	30612	// copy mutable arguments back from call to reporttok
30547	30613	fprintf(stderr, "%s", "\n");
30548	30614	exit(-1);
30549		- label = 2518LLU; // alternative complete
	30615	+ label = 2523LLU; // alternative complete
30550	30616	break;
30551	30617	}
30552		- case 2518LLU: // completed if-then-else
	30618	+ case 2523LLU: // completed if-then-else
30553	30619	{
30554	30620	// call getlettype from initfrom
30555		- stack[base + 34LLU] = 2521LLU/throw to this address/;
	30621	+ stack[base + 34LLU] = 2526LLU/throw to this address/;
30556	30622	stack[base + 35LLU] = base;
30557		- stack[base + 36LLU] = 2522LLU;
	30623	+ stack[base + 36LLU] = 2527LLU;
30558	30624	// arguments for call to getlettype
30559	30625	stack[base + 38LLU] = stack[base + 0]/fnid/;
30560	30626	stack[base + 39LLU] = stack[base + 13]/content/;

		@@ -30565,14 +30631,14 @@
30565	30631	label = 651LLU; // getlettype
30566	30632	break;
30567	30633	}
30568		- case 2521LLU: // copy-back deleter (getlettype to initfrom)
	30634	+ case 2526LLU: // copy-back deleter (getlettype to initfrom)
30569	30635	{
30570	30636	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
30571	30637	// copy mutable arguments back from call to getlettype
30572		- label = 2508LLU; // continue to roll stack
	30638	+ label = 2513LLU; // continue to roll stack
30573	30639	break;
30574	30640	}
30575		- case 2522LLU: // return from getlettype to initfrom
	30641	+ case 2527LLU: // return from getlettype to initfrom
30576	30642	{
30577	30643	// copy mutable arguments back from call to getlettype
30578	30644	// copy back results provided by call to getlettype

		@@ -30580,7 +30646,7 @@
30580	30646	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
30581	30647	if(!newstack)
30582	30648	{
30583		- label = 2508LLU; // throw: begin to unroll stack
	30649	+ label = 2513LLU; // throw: begin to unroll stack
30584	30650	break;
30585	30651	}
30586	30652

		@@ -30587,9 +30653,9 @@
30587	30653	newstack[15LLU] = 9876543210LLU; // overflow-marker
30588	30654	// call equtype from initfrom
30589	30655	newstack[0] = (uint64_t)stack; // backup stack location
30590		- newstack[1] = 2523LLU;
	30656	+ newstack[1] = 2528LLU;
30591	30657	newstack[2] = base;
30592		- newstack[3] = 2524LLU;
	30658	+ newstack[3] = 2529LLU;
30593	30659	// arguments for call to equtype
30594	30660	newstack[5LLU] = stack[base + 31]/dsttype/;
30595	30661	newstack[6LLU] = stack[base + 33]/srctype/;

		@@ -30599,7 +30665,7 @@
30599	30665	label = 342LLU; // equtype
30600	30666	break;
30601	30667	}
30602		- case 2523LLU: // copy-back deleter (equtype to initfrom)
	30668	+ case 2528LLU: // copy-back deleter (equtype to initfrom)
30603	30669	{
30604	30670	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
30605	30671	uint64_t oldstack = (uint64_t )stack[0];

		@@ -30611,10 +30677,10 @@
30611	30677	}
30612	30678	Free(15LLU + 1, sizeof(uint64_t), stack);
30613	30679	stack = oldstack;
30614		- label = 2508LLU; // continue to unroll stack
	30680	+ label = 2513LLU; // continue to unroll stack
30615	30681	break;
30616	30682	}
30617		- case 2524LLU: // return from equtype to initfrom
	30683	+ case 2529LLU: // return from equtype to initfrom
30618	30684	{
30619	30685	uint64_t oldstack = (uint64_t )stack[0];
30620	30686	// copy mutable arguments back from call to equtype

		@@ -30629,7 +30695,7 @@
30629	30695	stack = oldstack;
30630	30696	if(!stack[base + 10]/isequal/)
30631	30697	{
30632		- label = 2525LLU; // jump to alternative
	30698	+ label = 2530LLU; // jump to alternative
30633	30699	break;
30634	30700	}
30635	30701

		@@ -30636,7 +30702,7 @@
30636	30702	// consequent
30637	30703	if(/typename/0 != ((uint64_t )(stack[base + 31]/dsttype*/))[0])
30638	30704	{
30639		- label = 2528LLU; // jump to alternative
	30705	+ label = 2533LLU; // jump to alternative
30640	30706	break;
30641	30707	}
30642	30708

		@@ -30644,9 +30710,9 @@
30644	30710
30645	30711	// case
30646	30712	// call equ from initfrom
30647		- stack[base + 35LLU] = 2530LLU/throw to this address/;
	30713	+ stack[base + 35LLU] = 2535LLU/throw to this address/;
30648	30714	stack[base + 36LLU] = base;
30649		- stack[base + 37LLU] = 2531LLU;
	30715	+ stack[base + 37LLU] = 2536LLU;
30650	30716	// arguments for call to equ
30651	30717	stack[base + 39LLU] = 881834713755418624LLU;
30652	30718	stack[base + 40LLU] = stack[base + 34]/name/;

		@@ -30655,14 +30721,14 @@
30655	30721	label = 18446744073709551600LLU; // equ
30656	30722	break;
30657	30723	}
30658		- case 2530LLU: // copy-back deleter (equ to initfrom)
	30724	+ case 2535LLU: // copy-back deleter (equ to initfrom)
30659	30725	{
30660	30726	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
30661	30727	// copy mutable arguments back from call to equ
30662		- label = 2529LLU; // continue to roll stack
	30728	+ label = 2534LLU; // continue to roll stack
30663	30729	break;
30664	30730	}
30665		- case 2531LLU: // return from equ to initfrom
	30731	+ case 2536LLU: // return from equ to initfrom
30666	30732	{
30667	30733	// copy mutable arguments back from call to equ
30668	30734	// copy back results provided by call to equ

		@@ -30669,7 +30735,7 @@
30669	30735	stack[base + 10] = stack[base + 38LLU];
30670	30736	if(!stack[base + 10]/isequal/)
30671	30737	{
30672		- label = 2532LLU; // jump to alternative
	30738	+ label = 2537LLU; // jump to alternative
30673	30739	break;
30674	30740	}
30675	30741

		@@ -30676,9 +30742,9 @@
30676	30742	// consequent
30677	30743	printf("%s", "\n (((uint64_t **)(");
30678	30744	// call emitvaridx from initfrom
30679		- stack[base + 35LLU] = 2534LLU/throw to this address/;
	30745	+ stack[base + 35LLU] = 2539LLU/throw to this address/;
30680	30746	stack[base + 36LLU] = base;
30681		- stack[base + 37LLU] = 2535LLU;
	30747	+ stack[base + 37LLU] = 2540LLU;
30682	30748	// arguments for call to emitvaridx
30683	30749	stack[base + 38LLU] = stack[base + 3]/dstindex/;
30684	30750	// set stack-base & callee-address

		@@ -30686,21 +30752,21 @@
30686	30752	label = 691LLU; // emitvaridx
30687	30753	break;
30688	30754	}
30689		- case 2534LLU: // copy-back deleter (emitvaridx to initfrom)
	30755	+ case 2539LLU: // copy-back deleter (emitvaridx to initfrom)
30690	30756	{
30691	30757	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30692	30758	// copy mutable arguments back from call to emitvaridx
30693		- label = 2529LLU; // continue to roll stack
	30759	+ label = 2534LLU; // continue to roll stack
30694	30760	break;
30695	30761	}
30696		- case 2535LLU: // return from emitvaridx to initfrom
	30762	+ case 2540LLU: // return from emitvaridx to initfrom
30697	30763	{
30698	30764	// copy mutable arguments back from call to emitvaridx
30699	30765	printf("%s", "))[1][");
30700	30766	// call printnr from initfrom
30701		- stack[base + 35LLU] = 2536LLU/throw to this address/;
	30767	+ stack[base + 35LLU] = 2541LLU/throw to this address/;
30702	30768	stack[base + 36LLU] = base;
30703		- stack[base + 37LLU] = 2537LLU;
	30769	+ stack[base + 37LLU] = 2542LLU;
30704	30770	// arguments for call to printnr
30705	30771	stack[base + 38LLU] = stack[base + 27]/elemindex/;
30706	30772	// set stack-base & callee-address

		@@ -30708,21 +30774,21 @@
30708	30774	label = 18446744073709551590LLU; // printnr
30709	30775	break;
30710	30776	}
30711		- case 2536LLU: // copy-back deleter (printnr to initfrom)
	30777	+ case 2541LLU: // copy-back deleter (printnr to initfrom)
30712	30778	{
30713	30779	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30714	30780	// copy mutable arguments back from call to printnr
30715		- label = 2529LLU; // continue to roll stack
	30781	+ label = 2534LLU; // continue to roll stack
30716	30782	break;
30717	30783	}
30718		- case 2537LLU: // return from printnr to initfrom
	30784	+ case 2542LLU: // return from printnr to initfrom
30719	30785	{
30720	30786	// copy mutable arguments back from call to printnr
30721	30787	printf("%s", "]) = ");
30722	30788	// call emitvar from initfrom
30723		- stack[base + 35LLU] = 2538LLU/throw to this address/;
	30789	+ stack[base + 35LLU] = 2543LLU/throw to this address/;
30724	30790	stack[base + 36LLU] = base;
30725		- stack[base + 37LLU] = 2539LLU;
	30791	+ stack[base + 37LLU] = 2544LLU;
30726	30792	// arguments for call to emitvar
30727	30793	stack[base + 38LLU] = stack[base + 0]/fnid/;
30728	30794	stack[base + 39LLU] = stack[base + 13]/content/;

		@@ -30733,27 +30799,27 @@
30733	30799	label = 695LLU; // emitvar
30734	30800	break;
30735	30801	}
30736		- case 2538LLU: // copy-back deleter (emitvar to initfrom)
	30802	+ case 2543LLU: // copy-back deleter (emitvar to initfrom)
30737	30803	{
30738	30804	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
30739	30805	// copy mutable arguments back from call to emitvar
30740		- label = 2529LLU; // continue to roll stack
	30806	+ label = 2534LLU; // continue to roll stack
30741	30807	break;
30742	30808	}
30743		- case 2539LLU: // return from emitvar to initfrom
	30809	+ case 2544LLU: // return from emitvar to initfrom
30744	30810	{
30745	30811	// copy mutable arguments back from call to emitvar
30746	30812	printf("%s", ";");
30747		- label = 2533LLU; // consequent complete
	30813	+ label = 2538LLU; // consequent complete
30748	30814	break;
30749	30815	}
30750		- case 2532LLU: // alternative
	30816	+ case 2537LLU: // alternative
30751	30817	{
30752	30818	printf("%s", "\n INIT(&(((uint64_t **)(");
30753	30819	// call emitvaridx from initfrom
30754		- stack[base + 35LLU] = 2540LLU/throw to this address/;
	30820	+ stack[base + 35LLU] = 2545LLU/throw to this address/;
30755	30821	stack[base + 36LLU] = base;
30756		- stack[base + 37LLU] = 2541LLU;
	30822	+ stack[base + 37LLU] = 2546LLU;
30757	30823	// arguments for call to emitvaridx
30758	30824	stack[base + 38LLU] = stack[base + 3]/dstindex/;
30759	30825	// set stack-base & callee-address

		@@ -30761,21 +30827,21 @@
30761	30827	label = 691LLU; // emitvaridx
30762	30828	break;
30763	30829	}
30764		- case 2540LLU: // copy-back deleter (emitvaridx to initfrom)
	30830	+ case 2545LLU: // copy-back deleter (emitvaridx to initfrom)
30765	30831	{
30766	30832	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30767	30833	// copy mutable arguments back from call to emitvaridx
30768		- label = 2529LLU; // continue to roll stack
	30834	+ label = 2534LLU; // continue to roll stack
30769	30835	break;
30770	30836	}
30771		- case 2541LLU: // return from emitvaridx to initfrom
	30837	+ case 2546LLU: // return from emitvaridx to initfrom
30772	30838	{
30773	30839	// copy mutable arguments back from call to emitvaridx
30774	30840	printf("%s", "))[1][");
30775	30841	// call printnr from initfrom
30776		- stack[base + 35LLU] = 2542LLU/throw to this address/;
	30842	+ stack[base + 35LLU] = 2547LLU/throw to this address/;
30777	30843	stack[base + 36LLU] = base;
30778		- stack[base + 37LLU] = 2543LLU;
	30844	+ stack[base + 37LLU] = 2548LLU;
30779	30845	// arguments for call to printnr
30780	30846	stack[base + 38LLU] = stack[base + 27]/elemindex/;
30781	30847	// set stack-base & callee-address

		@@ -30783,21 +30849,21 @@
30783	30849	label = 18446744073709551590LLU; // printnr
30784	30850	break;
30785	30851	}
30786		- case 2542LLU: // copy-back deleter (printnr to initfrom)
	30852	+ case 2547LLU: // copy-back deleter (printnr to initfrom)
30787	30853	{
30788	30854	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30789	30855	// copy mutable arguments back from call to printnr
30790		- label = 2529LLU; // continue to roll stack
	30856	+ label = 2534LLU; // continue to roll stack
30791	30857	break;
30792	30858	}
30793		- case 2543LLU: // return from printnr to initfrom
	30859	+ case 2548LLU: // return from printnr to initfrom
30794	30860	{
30795	30861	// copy mutable arguments back from call to printnr
30796	30862	printf("%s", "]), &");
30797	30863	// call emitvar from initfrom
30798		- stack[base + 35LLU] = 2544LLU/throw to this address/;
	30864	+ stack[base + 35LLU] = 2549LLU/throw to this address/;
30799	30865	stack[base + 36LLU] = base;
30800		- stack[base + 37LLU] = 2545LLU;
	30866	+ stack[base + 37LLU] = 2550LLU;
30801	30867	// arguments for call to emitvar
30802	30868	stack[base + 38LLU] = stack[base + 0]/fnid/;
30803	30869	stack[base + 39LLU] = stack[base + 13]/content/;

		@@ -30808,21 +30874,21 @@
30808	30874	label = 695LLU; // emitvar
30809	30875	break;
30810	30876	}
30811		- case 2544LLU: // copy-back deleter (emitvar to initfrom)
	30877	+ case 2549LLU: // copy-back deleter (emitvar to initfrom)
30812	30878	{
30813	30879	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
30814	30880	// copy mutable arguments back from call to emitvar
30815		- label = 2529LLU; // continue to roll stack
	30881	+ label = 2534LLU; // continue to roll stack
30816	30882	break;
30817	30883	}
30818		- case 2545LLU: // return from emitvar to initfrom
	30884	+ case 2550LLU: // return from emitvar to initfrom
30819	30885	{
30820	30886	// copy mutable arguments back from call to emitvar
30821	30887	printf("%s", ");");
30822	30888	// call unscopelet from initfrom
30823		- stack[base + 35LLU] = 2546LLU/throw to this address/;
	30889	+ stack[base + 35LLU] = 2551LLU/throw to this address/;
30824	30890	stack[base + 36LLU] = base;
30825		- stack[base + 37LLU] = 2547LLU;
	30891	+ stack[base + 37LLU] = 2552LLU;
30826	30892	// arguments for call to unscopelet
30827	30893	stack[base + 38LLU] = stack[base + 0]/fnid/;
30828	30894	stack[base + 39LLU] = stack[base + 6]/scope/;

		@@ -30832,41 +30898,41 @@
30832	30898	label = 761LLU; // unscopelet
30833	30899	break;
30834	30900	}
30835		- case 2546LLU: // copy-back deleter (unscopelet to initfrom)
	30901	+ case 2551LLU: // copy-back deleter (unscopelet to initfrom)
30836	30902	{
30837	30903	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
30838	30904	// copy mutable arguments back from call to unscopelet
30839	30905	stack[base + 6]/scope/ = stack[base + 39LLU];
30840		- label = 2529LLU; // continue to roll stack
	30906	+ label = 2534LLU; // continue to roll stack
30841	30907	break;
30842	30908	}
30843		- case 2547LLU: // return from unscopelet to initfrom
	30909	+ case 2552LLU: // return from unscopelet to initfrom
30844	30910	{
30845	30911	// copy mutable arguments back from call to unscopelet
30846	30912	stack[base + 6]/scope/ = stack[base + 39LLU];
30847		- label = 2533LLU; // alternative complete
	30913	+ label = 2538LLU; // alternative complete
30848	30914	break;
30849	30915	}
30850		- case 2533LLU: // completed if-then-else
	30916	+ case 2538LLU: // completed if-then-else
30851	30917	{
30852	30918	((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30853		- label = 2527LLU; // case complete
	30919	+ label = 2532LLU; // case complete
30854	30920	break;
30855	30921	}
30856		- case 2529LLU: // copy-back deleter (switch)
	30922	+ case 2534LLU: // copy-back deleter (switch)
30857	30923	{
30858	30924	((uint64_t **)(stack[base + 31]))[1][0] = stack[base + 34];
30859		- label = 2508LLU; // continue to unroll stack
	30925	+ label = 2513LLU; // continue to unroll stack
30860	30926	break;
30861	30927	}
30862		- case 2528LLU: // try next case
	30928	+ case 2533LLU: // try next case
30863	30929	{
30864	30930	// default
30865	30931	printf("%s", "\n INIT(&(((uint64_t **)(");
30866	30932	// call emitvaridx from initfrom
30867		- stack[base + 34LLU] = 2548LLU/throw to this address/;
	30933	+ stack[base + 34LLU] = 2553LLU/throw to this address/;
30868	30934	stack[base + 35LLU] = base;
30869		- stack[base + 36LLU] = 2549LLU;
	30935	+ stack[base + 36LLU] = 2554LLU;
30870	30936	// arguments for call to emitvaridx
30871	30937	stack[base + 37LLU] = stack[base + 3]/dstindex/;
30872	30938	// set stack-base & callee-address

		@@ -30874,21 +30940,21 @@
30874	30940	label = 691LLU; // emitvaridx
30875	30941	break;
30876	30942	}
30877		- case 2548LLU: // copy-back deleter (emitvaridx to initfrom)
	30943	+ case 2553LLU: // copy-back deleter (emitvaridx to initfrom)
30878	30944	{
30879	30945	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
30880	30946	// copy mutable arguments back from call to emitvaridx
30881		- label = 2508LLU; // continue to roll stack
	30947	+ label = 2513LLU; // continue to roll stack
30882	30948	break;
30883	30949	}
30884		- case 2549LLU: // return from emitvaridx to initfrom
	30950	+ case 2554LLU: // return from emitvaridx to initfrom
30885	30951	{
30886	30952	// copy mutable arguments back from call to emitvaridx
30887	30953	printf("%s", "))[1][");
30888	30954	// call printnr from initfrom
30889		- stack[base + 34LLU] = 2550LLU/throw to this address/;
	30955	+ stack[base + 34LLU] = 2555LLU/throw to this address/;
30890	30956	stack[base + 35LLU] = base;
30891		- stack[base + 36LLU] = 2551LLU;
	30957	+ stack[base + 36LLU] = 2556LLU;
30892	30958	// arguments for call to printnr
30893	30959	stack[base + 37LLU] = stack[base + 27]/elemindex/;
30894	30960	// set stack-base & callee-address

		@@ -30896,21 +30962,21 @@
30896	30962	label = 18446744073709551590LLU; // printnr
30897	30963	break;
30898	30964	}
30899		- case 2550LLU: // copy-back deleter (printnr to initfrom)
	30965	+ case 2555LLU: // copy-back deleter (printnr to initfrom)
30900	30966	{
30901	30967	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
30902	30968	// copy mutable arguments back from call to printnr
30903		- label = 2508LLU; // continue to roll stack
	30969	+ label = 2513LLU; // continue to roll stack
30904	30970	break;
30905	30971	}
30906		- case 2551LLU: // return from printnr to initfrom
	30972	+ case 2556LLU: // return from printnr to initfrom
30907	30973	{
30908	30974	// copy mutable arguments back from call to printnr
30909	30975	printf("%s", "]), &");
30910	30976	// call emitvar from initfrom
30911		- stack[base + 34LLU] = 2552LLU/throw to this address/;
	30977	+ stack[base + 34LLU] = 2557LLU/throw to this address/;
30912	30978	stack[base + 35LLU] = base;
30913		- stack[base + 36LLU] = 2553LLU;
	30979	+ stack[base + 36LLU] = 2558LLU;
30914	30980	// arguments for call to emitvar
30915	30981	stack[base + 37LLU] = stack[base + 0]/fnid/;
30916	30982	stack[base + 38LLU] = stack[base + 13]/content/;

		@@ -30921,21 +30987,21 @@
30921	30987	label = 695LLU; // emitvar
30922	30988	break;
30923	30989	}
30924		- case 2552LLU: // copy-back deleter (emitvar to initfrom)
	30990	+ case 2557LLU: // copy-back deleter (emitvar to initfrom)
30925	30991	{
30926	30992	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
30927	30993	// copy mutable arguments back from call to emitvar
30928		- label = 2508LLU; // continue to roll stack
	30994	+ label = 2513LLU; // continue to roll stack
30929	30995	break;
30930	30996	}
30931		- case 2553LLU: // return from emitvar to initfrom
	30997	+ case 2558LLU: // return from emitvar to initfrom
30932	30998	{
30933	30999	// copy mutable arguments back from call to emitvar
30934	31000	printf("%s", ");");
30935	31001	// call unscopelet from initfrom
30936		- stack[base + 34LLU] = 2554LLU/throw to this address/;
	31002	+ stack[base + 34LLU] = 2559LLU/throw to this address/;
30937	31003	stack[base + 35LLU] = base;
30938		- stack[base + 36LLU] = 2555LLU;
	31004	+ stack[base + 36LLU] = 2560LLU;
30939	31005	// arguments for call to unscopelet
30940	31006	stack[base + 37LLU] = stack[base + 0]/fnid/;
30941	31007	stack[base + 38LLU] = stack[base + 6]/scope/;

		@@ -30945,33 +31011,33 @@
30945	31011	label = 761LLU; // unscopelet
30946	31012	break;
30947	31013	}
30948		- case 2554LLU: // copy-back deleter (unscopelet to initfrom)
	31014	+ case 2559LLU: // copy-back deleter (unscopelet to initfrom)
30949	31015	{
30950	31016	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
30951	31017	// copy mutable arguments back from call to unscopelet
30952	31018	stack[base + 6]/scope/ = stack[base + 38LLU];
30953		- label = 2508LLU; // continue to roll stack
	31019	+ label = 2513LLU; // continue to roll stack
30954	31020	break;
30955	31021	}
30956		- case 2555LLU: // return from unscopelet to initfrom
	31022	+ case 2560LLU: // return from unscopelet to initfrom
30957	31023	{
30958	31024	// copy mutable arguments back from call to unscopelet
30959	31025	stack[base + 6]/scope/ = stack[base + 38LLU];
30960		- label = 2527LLU; // default complete
	31026	+ label = 2532LLU; // default complete
30961	31027	break;
30962	31028	}
30963		- case 2527LLU: // completed switch
	31029	+ case 2532LLU: // completed switch
30964	31030	{
30965		- label = 2526LLU; // consequent complete
	31031	+ label = 2531LLU; // consequent complete
30966	31032	break;
30967	31033	}
30968		- case 2525LLU: // alternative
	31034	+ case 2530LLU: // alternative
30969	31035	{
30970	31036	fprintf(stderr, "%s", "in function ");
30971	31037	// call reportid from initfrom
30972		- stack[base + 34LLU] = 2556LLU/throw to this address/;
	31038	+ stack[base + 34LLU] = 2561LLU/throw to this address/;
30973	31039	stack[base + 35LLU] = base;
30974		- stack[base + 36LLU] = 2557LLU;
	31040	+ stack[base + 36LLU] = 2562LLU;
30975	31041	// arguments for call to reportid
30976	31042	stack[base + 37LLU] = stack[base + 0]/fnid/;
30977	31043	// set stack-base & callee-address

		@@ -30979,14 +31045,14 @@
30979	31045	label = 18446744073709551586LLU; // reportid
30980	31046	break;
30981	31047	}
30982		- case 2556LLU: // copy-back deleter (reportid to initfrom)
	31048	+ case 2561LLU: // copy-back deleter (reportid to initfrom)
30983	31049	{
30984	31050	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
30985	31051	// copy mutable arguments back from call to reportid
30986		- label = 2508LLU; // continue to roll stack
	31052	+ label = 2513LLU; // continue to roll stack
30987	31053	break;
30988	31054	}
30989		- case 2557LLU: // return from reportid to initfrom
	31055	+ case 2562LLU: // return from reportid to initfrom
30990	31056	{
30991	31057	// copy mutable arguments back from call to reportid
30992	31058	fprintf(stderr, "%s", ": constructor of type ");

		@@ -30993,7 +31059,7 @@
30993	31059	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
30994	31060	if(!newstack)
30995	31061	{
30996		- label = 2508LLU; // throw: begin to unroll stack
	31062	+ label = 2513LLU; // throw: begin to unroll stack
30997	31063	break;
30998	31064	}
30999	31065

		@@ -31000,9 +31066,9 @@
31000	31066	newstack[10LLU] = 9876543210LLU; // overflow-marker
31001	31067	// call reporttype from initfrom
31002	31068	newstack[0] = (uint64_t)stack; // backup stack location
31003		- newstack[1] = 2558LLU;
	31069	+ newstack[1] = 2563LLU;
31004	31070	newstack[2] = base;
31005		- newstack[3] = 2559LLU;
	31071	+ newstack[3] = 2564LLU;
31006	31072	// arguments for call to reporttype
31007	31073	newstack[4LLU] = stack[base + 31]/dsttype/;
31008	31074	stack = newstack;

		@@ -31011,7 +31077,7 @@
31011	31077	label = 316LLU; // reporttype
31012	31078	break;
31013	31079	}
31014		- case 2558LLU: // copy-back deleter (reporttype to initfrom)
	31080	+ case 2563LLU: // copy-back deleter (reporttype to initfrom)
31015	31081	{
31016	31082	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
31017	31083	uint64_t oldstack = (uint64_t )stack[0];

		@@ -31023,10 +31089,10 @@
31023	31089	}
31024	31090	Free(10LLU + 1, sizeof(uint64_t), stack);
31025	31091	stack = oldstack;
31026		- label = 2508LLU; // continue to unroll stack
	31092	+ label = 2513LLU; // continue to unroll stack
31027	31093	break;
31028	31094	}
31029		- case 2559LLU: // return from reporttype to initfrom
	31095	+ case 2564LLU: // return from reporttype to initfrom
31030	31096	{
31031	31097	uint64_t oldstack = (uint64_t )stack[0];
31032	31098	// copy mutable arguments back from call to reporttype

		@@ -31041,7 +31107,7 @@
31041	31107	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
31042	31108	if(!newstack)
31043	31109	{
31044		- label = 2508LLU; // throw: begin to unroll stack
	31110	+ label = 2513LLU; // throw: begin to unroll stack
31045	31111	break;
31046	31112	}
31047	31113

		@@ -31048,9 +31114,9 @@
31048	31114	newstack[10LLU] = 9876543210LLU; // overflow-marker
31049	31115	// call reporttype from initfrom
31050	31116	newstack[0] = (uint64_t)stack; // backup stack location
31051		- newstack[1] = 2560LLU;
	31117	+ newstack[1] = 2565LLU;
31052	31118	newstack[2] = base;
31053		- newstack[3] = 2561LLU;
	31119	+ newstack[3] = 2566LLU;
31054	31120	// arguments for call to reporttype
31055	31121	newstack[4LLU] = stack[base + 31]/dsttype/;
31056	31122	stack = newstack;

		@@ -31059,7 +31125,7 @@
31059	31125	label = 316LLU; // reporttype
31060	31126	break;
31061	31127	}
31062		- case 2560LLU: // copy-back deleter (reporttype to initfrom)
	31128	+ case 2565LLU: // copy-back deleter (reporttype to initfrom)
31063	31129	{
31064	31130	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
31065	31131	uint64_t oldstack = (uint64_t )stack[0];

		@@ -31071,10 +31137,10 @@
31071	31137	}
31072	31138	Free(10LLU + 1, sizeof(uint64_t), stack);
31073	31139	stack = oldstack;
31074		- label = 2508LLU; // continue to unroll stack
	31140	+ label = 2513LLU; // continue to unroll stack
31075	31141	break;
31076	31142	}
31077		- case 2561LLU: // return from reporttype to initfrom
	31143	+ case 2566LLU: // return from reporttype to initfrom
31078	31144	{
31079	31145	uint64_t oldstack = (uint64_t )stack[0];
31080	31146	// copy mutable arguments back from call to reporttype

		@@ -31089,7 +31155,7 @@
31089	31155	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
31090	31156	if(!newstack)
31091	31157	{
31092		- label = 2508LLU; // throw: begin to unroll stack
	31158	+ label = 2513LLU; // throw: begin to unroll stack
31093	31159	break;
31094	31160	}
31095	31161

		@@ -31096,9 +31162,9 @@
31096	31162	newstack[10LLU] = 9876543210LLU; // overflow-marker
31097	31163	// call reporttype from initfrom
31098	31164	newstack[0] = (uint64_t)stack; // backup stack location
31099		- newstack[1] = 2562LLU;
	31165	+ newstack[1] = 2567LLU;
31100	31166	newstack[2] = base;
31101		- newstack[3] = 2563LLU;
	31167	+ newstack[3] = 2568LLU;
31102	31168	// arguments for call to reporttype
31103	31169	newstack[4LLU] = stack[base + 33]/srctype/;
31104	31170	stack = newstack;

		@@ -31107,7 +31173,7 @@
31107	31173	label = 316LLU; // reporttype
31108	31174	break;
31109	31175	}
31110		- case 2562LLU: // copy-back deleter (reporttype to initfrom)
	31176	+ case 2567LLU: // copy-back deleter (reporttype to initfrom)
31111	31177	{
31112	31178	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
31113	31179	uint64_t oldstack = (uint64_t )stack[0];

		@@ -31119,10 +31185,10 @@
31119	31185	}
31120	31186	Free(10LLU + 1, sizeof(uint64_t), stack);
31121	31187	stack = oldstack;
31122		- label = 2508LLU; // continue to unroll stack
	31188	+ label = 2513LLU; // continue to unroll stack
31123	31189	break;
31124	31190	}
31125		- case 2563LLU: // return from reporttype to initfrom
	31191	+ case 2568LLU: // return from reporttype to initfrom
31126	31192	{
31127	31193	uint64_t oldstack = (uint64_t )stack[0];
31128	31194	// copy mutable arguments back from call to reporttype

		@@ -31135,9 +31201,9 @@
31135	31201	stack = oldstack;
31136	31202	fprintf(stderr, "%s", " ");
31137	31203	// call reportid from initfrom
31138		- stack[base + 34LLU] = 2564LLU/throw to this address/;
	31204	+ stack[base + 34LLU] = 2569LLU/throw to this address/;
31139	31205	stack[base + 35LLU] = base;
31140		- stack[base + 36LLU] = 2565LLU;
	31206	+ stack[base + 36LLU] = 2570LLU;
31141	31207	// arguments for call to reportid
31142	31208	stack[base + 37LLU] = stack[base + 13]/content/;
31143	31209	// set stack-base & callee-address

		@@ -31145,22 +31211,22 @@
31145	31211	label = 18446744073709551586LLU; // reportid
31146	31212	break;
31147	31213	}
31148		- case 2564LLU: // copy-back deleter (reportid to initfrom)
	31214	+ case 2569LLU: // copy-back deleter (reportid to initfrom)
31149	31215	{
31150	31216	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
31151	31217	// copy mutable arguments back from call to reportid
31152		- label = 2508LLU; // continue to roll stack
	31218	+ label = 2513LLU; // continue to roll stack
31153	31219	break;
31154	31220	}
31155		- case 2565LLU: // return from reportid to initfrom
	31221	+ case 2570LLU: // return from reportid to initfrom
31156	31222	{
31157	31223	// copy mutable arguments back from call to reportid
31158	31224	fprintf(stderr, "%s", "\n");
31159	31225	exit(-1);
31160		- label = 2526LLU; // alternative complete
	31226	+ label = 2531LLU; // alternative complete
31161	31227	break;
31162	31228	}
31163		- case 2526LLU: // completed if-then-else
	31229	+ case 2531LLU: // completed if-then-else
31164	31230	{
31165	31231
31166	31232	uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);

		@@ -31168,7 +31234,7 @@
31168	31234	newstack[0] = (uint64_t)stack; // backup stack location
31169	31235	newstack[1] = 1234567890;
31170	31236	newstack[2] = base;
31171		- newstack[3] = 2566LLU;
	31237	+ newstack[3] = 2571LLU;
31172	31238	stack = newstack;
31173	31239	// set stack-base & callee-address
31174	31240	base = 4/deloffset/;

		@@ -31175,7 +31241,7 @@
31175	31241	label = 296LLU; // ~type
31176	31242	break;
31177	31243	}
31178		- case 2566LLU: // return from ~type to initfrom
	31244	+ case 2571LLU: // return from ~type to initfrom
31179	31245	{
31180	31246	stack = (uint64_t *)stack[0];
31181	31247	// releasing toplevel container

		@@ -31183,27 +31249,27 @@
31183	31249
31184	31250	((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
31185	31251	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31186		- label = 2506LLU; // case complete
	31252	+ label = 2511LLU; // case complete
31187	31253	break;
31188	31254	}
31189		- case 2508LLU: // copy-back deleter (switch)
	31255	+ case 2513LLU: // copy-back deleter (switch)
31190	31256	{
31191	31257	((uint64_t **)(stack[base + 29]))[1][1] = stack[base + 32];
31192	31258	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 31];
31193		- label = 2505LLU; // continue to unroll stack
	31259	+ label = 2510LLU; // continue to unroll stack
31194	31260	break;
31195	31261	}
31196		- case 2507LLU: // try next case
	31262	+ case 2512LLU: // try next case
31197	31263	{
31198	31264	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
31199	31265	exit(-1);
31200	31266	}
31201		- case 2506LLU: // completed switch
	31267	+ case 2511LLU: // completed switch
31202	31268	{
31203	31269	// call add from initfrom
31204		- stack[base + 31LLU] = 2567LLU/throw to this address/;
	31270	+ stack[base + 31LLU] = 2572LLU/throw to this address/;
31205	31271	stack[base + 32LLU] = base;
31206		- stack[base + 33LLU] = 2568LLU;
	31272	+ stack[base + 33LLU] = 2573LLU;
31207	31273	// arguments for call to add
31208	31274	stack[base + 35LLU] = stack[base + 27]/elemindex/;
31209	31275	stack[base + 36LLU] = 1LLU;

		@@ -31212,34 +31278,34 @@
31212	31278	label = 18446744073709551605LLU; // add
31213	31279	break;
31214	31280	}
31215		- case 2567LLU: // copy-back deleter (add to initfrom)
	31281	+ case 2572LLU: // copy-back deleter (add to initfrom)
31216	31282	{
31217	31283	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
31218	31284	// copy mutable arguments back from call to add
31219		- label = 2505LLU; // continue to roll stack
	31285	+ label = 2510LLU; // continue to roll stack
31220	31286	break;
31221	31287	}
31222		- case 2568LLU: // return from add to initfrom
	31288	+ case 2573LLU: // return from add to initfrom
31223	31289	{
31224	31290	// copy mutable arguments back from call to add
31225	31291	// copy back results provided by call to add
31226	31292	stack[base + 27] = stack[base + 34LLU];
31227	31293	((struct listnode )(stack[base + 30]/previous*/))->data = stack[base + 29];
31228		- label = 2503LLU; // repeat
	31294	+ label = 2508LLU; // repeat
31229	31295	break;
31230	31296	}
31231		- case 2505LLU: // copy-back deleter for while next
	31297	+ case 2510LLU: // copy-back deleter for while next
31232	31298	{
31233	31299	((struct listnode )(stack[base + 30]/previous*/))->data = stack[base + 29];
31234		- label = 2501LLU; // continue to unroll stack
	31300	+ label = 2506LLU; // continue to unroll stack
31235	31301	break;
31236	31302	}
31237		- case 2504LLU: // loop finished
	31303	+ case 2509LLU: // loop finished
31238	31304	{
31239	31305	// call matchsym from initfrom
31240		- stack[base + 31LLU] = 2569LLU/throw to this address/;
	31306	+ stack[base + 31LLU] = 2574LLU/throw to this address/;
31241	31307	stack[base + 32LLU] = base;
31242		- stack[base + 33LLU] = 2570LLU;
	31308	+ stack[base + 33LLU] = 2575LLU;
31243	31309	// arguments for call to matchsym
31244	31310	stack[base + 34LLU] = stack[base + 0]/fnid/;
31245	31311	stack[base + 35LLU] = 41LLU;

		@@ -31249,36 +31315,36 @@
31249	31315	label = 212LLU; // matchsym
31250	31316	break;
31251	31317	}
31252		- case 2569LLU: // copy-back deleter (matchsym to initfrom)
	31318	+ case 2574LLU: // copy-back deleter (matchsym to initfrom)
31253	31319	{
31254	31320	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
31255	31321	// copy mutable arguments back from call to matchsym
31256	31322	stack[base + 7]/lookahead/ = stack[base + 36LLU];
31257		- label = 2501LLU; // continue to roll stack
	31323	+ label = 2506LLU; // continue to roll stack
31258	31324	break;
31259	31325	}
31260		- case 2570LLU: // return from matchsym to initfrom
	31326	+ case 2575LLU: // return from matchsym to initfrom
31261	31327	{
31262	31328	// copy mutable arguments back from call to matchsym
31263	31329	stack[base + 7]/lookahead/ = stack[base + 36LLU];
31264	31330	((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
31265	31331	((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31266		- label = 2478LLU; // case complete
	31332	+ label = 2483LLU; // case complete
31267	31333	break;
31268	31334	}
31269		- case 2480LLU: // copy-back deleter (switch)
	31335	+ case 2485LLU: // copy-back deleter (switch)
31270	31336	{
31271	31337	((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
31272	31338	((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
31273		- label = 2475LLU; // continue to unroll stack
	31339	+ label = 2480LLU; // continue to unroll stack
31274	31340	break;
31275	31341	}
31276		- case 2479LLU: // try next case
	31342	+ case 2484LLU: // try next case
31277	31343	{
31278	31344	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
31279	31345	exit(-1);
31280	31346	}
31281		- case 2478LLU: // completed switch
	31347	+ case 2483LLU: // completed switch
31282	31348	{
31283	31349
31284	31350	uint64_t newstack = (uint64_t )(stack[base + 23] - sizeof(uint64_t) * 4);

		@@ -31286,7 +31352,7 @@
31286	31352	newstack[0] = (uint64_t)stack; // backup stack location
31287	31353	newstack[1] = 1234567890;
31288	31354	newstack[2] = base;
31289		- newstack[3] = 2571LLU;
	31355	+ newstack[3] = 2576LLU;
31290	31356	stack = newstack;
31291	31357	// set stack-base & callee-address
31292	31358	base = 4/deloffset/;

		@@ -31293,7 +31359,7 @@
31293	31359	label = 870LLU; // ~variant
31294	31360	break;
31295	31361	}
31296		- case 2571LLU: // return from ~variant to initfrom
	31362	+ case 2576LLU: // return from ~variant to initfrom
31297	31363	{
31298	31364	stack = (uint64_t *)stack[0];
31299	31365	// releasing toplevel container

		@@ -31302,23 +31368,23 @@
31302	31368	((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
31303	31369	((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
31304	31370	((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31305		- label = 2473LLU; // case complete
	31371	+ label = 2478LLU; // case complete
31306	31372	break;
31307	31373	}
31308		- case 2475LLU: // copy-back deleter (switch)
	31374	+ case 2480LLU: // copy-back deleter (switch)
31309	31375	{
31310	31376	((uint64_t **)(stack[base + 18]))[1][2] = stack[base + 21];
31311	31377	((uint64_t **)(stack[base + 18]))[1][1] = stack[base + 20];
31312	31378	((uint64_t **)(stack[base + 18]))[1][0] = stack[base + 19];
31313		- label = 2460LLU; // continue to unroll stack
	31379	+ label = 2465LLU; // continue to unroll stack
31314	31380	break;
31315	31381	}
31316		- case 2474LLU: // try next case
	31382	+ case 2479LLU: // try next case
31317	31383	{
31318	31384	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
31319	31385	exit(-1);
31320	31386	}
31321		- case 2473LLU: // completed switch
	31387	+ case 2478LLU: // completed switch
31322	31388	{
31323	31389
31324	31390	uint64_t newstack = (uint64_t )(stack[base + 18] - sizeof(uint64_t) * 4);

		@@ -31326,7 +31392,7 @@
31326	31392	newstack[0] = (uint64_t)stack; // backup stack location
31327	31393	newstack[1] = 1234567890;
31328	31394	newstack[2] = base;
31329		- newstack[3] = 2572LLU;
	31395	+ newstack[3] = 2577LLU;
31330	31396	stack = newstack;
31331	31397	// set stack-base & callee-address
31332	31398	base = 4/deloffset/;

		@@ -31333,7 +31399,7 @@
31333	31399	label = 945LLU; // ~datadef
31334	31400	break;
31335	31401	}
31336		- case 2572LLU: // return from ~datadef to initfrom
	31402	+ case 2577LLU: // return from ~datadef to initfrom
31337	31403	{
31338	31404	stack = (uint64_t *)stack[0];
31339	31405	// releasing toplevel container

		@@ -31340,23 +31406,23 @@
31340	31406	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 18] - sizeof(uint64_t) 4));
31341	31407
31342	31408	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31343		- label = 2458LLU; // case complete
	31409	+ label = 2463LLU; // case complete
31344	31410	break;
31345	31411	}
31346		- case 2460LLU: // copy-back deleter (switch)
	31412	+ case 2465LLU: // copy-back deleter (switch)
31347	31413	{
31348	31414	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 17];
31349		- label = 2259LLU; // continue to unroll stack
	31415	+ label = 2295LLU; // continue to unroll stack
31350	31416	break;
31351	31417	}
31352		- case 2459LLU: // try next case
	31418	+ case 2464LLU: // try next case
31353	31419	{
31354	31420	// default
31355	31421	fprintf(stderr, "%s", "in function ");
31356	31422	// call reportid from initfrom
31357		- stack[base + 17LLU] = 2573LLU/throw to this address/;
	31423	+ stack[base + 17LLU] = 2578LLU/throw to this address/;
31358	31424	stack[base + 18LLU] = base;
31359		- stack[base + 19LLU] = 2574LLU;
	31425	+ stack[base + 19LLU] = 2579LLU;
31360	31426	// arguments for call to reportid
31361	31427	stack[base + 20LLU] = stack[base + 0]/fnid/;
31362	31428	// set stack-base & callee-address

		@@ -31364,14 +31430,14 @@
31364	31430	label = 18446744073709551586LLU; // reportid
31365	31431	break;
31366	31432	}
31367		- case 2573LLU: // copy-back deleter (reportid to initfrom)
	31433	+ case 2578LLU: // copy-back deleter (reportid to initfrom)
31368	31434	{
31369	31435	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
31370	31436	// copy mutable arguments back from call to reportid
31371		- label = 2259LLU; // continue to roll stack
	31437	+ label = 2295LLU; // continue to roll stack
31372	31438	break;
31373	31439	}
31374		- case 2574LLU: // return from reportid to initfrom
	31440	+ case 2579LLU: // return from reportid to initfrom
31375	31441	{
31376	31442	// copy mutable arguments back from call to reportid
31377	31443	fprintf(stderr, "%s", ": type ");

		@@ -31378,7 +31444,7 @@
31378	31444	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
31379	31445	if(!newstack)
31380	31446	{
31381		- label = 2259LLU; // throw: begin to unroll stack
	31447	+ label = 2295LLU; // throw: begin to unroll stack
31382	31448	break;
31383	31449	}
31384	31450

		@@ -31385,9 +31451,9 @@
31385	31451	newstack[10LLU] = 9876543210LLU; // overflow-marker
31386	31452	// call reporttype from initfrom
31387	31453	newstack[0] = (uint64_t)stack; // backup stack location
31388		- newstack[1] = 2575LLU;
	31454	+ newstack[1] = 2580LLU;
31389	31455	newstack[2] = base;
31390		- newstack[3] = 2576LLU;
	31456	+ newstack[3] = 2581LLU;
31391	31457	// arguments for call to reporttype
31392	31458	newstack[4LLU] = stack[base + 1]/dsttype/;
31393	31459	stack = newstack;

		@@ -31396,7 +31462,7 @@
31396	31462	label = 316LLU; // reporttype
31397	31463	break;
31398	31464	}
31399		- case 2575LLU: // copy-back deleter (reporttype to initfrom)
	31465	+ case 2580LLU: // copy-back deleter (reporttype to initfrom)
31400	31466	{
31401	31467	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
31402	31468	uint64_t oldstack = (uint64_t )stack[0];

		@@ -31408,10 +31474,10 @@
31408	31474	}
31409	31475	Free(10LLU + 1, sizeof(uint64_t), stack);
31410	31476	stack = oldstack;
31411		- label = 2259LLU; // continue to unroll stack
	31477	+ label = 2295LLU; // continue to unroll stack
31412	31478	break;
31413	31479	}
31414		- case 2576LLU: // return from reporttype to initfrom
	31480	+ case 2581LLU: // return from reporttype to initfrom
31415	31481	{
31416	31482	uint64_t oldstack = (uint64_t )stack[0];
31417	31483	// copy mutable arguments back from call to reporttype

		@@ -31424,9 +31490,9 @@
31424	31490	stack = oldstack;
31425	31491	fprintf(stderr, "%s", " has no constructor ");
31426	31492	// call reportid from initfrom
31427		- stack[base + 17LLU] = 2577LLU/throw to this address/;
	31493	+ stack[base + 17LLU] = 2582LLU/throw to this address/;
31428	31494	stack[base + 18LLU] = base;
31429		- stack[base + 19LLU] = 2578LLU;
	31495	+ stack[base + 19LLU] = 2583LLU;
31430	31496	// arguments for call to reportid
31431	31497	stack[base + 20LLU] = stack[base + 13]/content/;
31432	31498	// set stack-base & callee-address

		@@ -31434,32 +31500,32 @@
31434	31500	label = 18446744073709551586LLU; // reportid
31435	31501	break;
31436	31502	}
31437		- case 2577LLU: // copy-back deleter (reportid to initfrom)
	31503	+ case 2582LLU: // copy-back deleter (reportid to initfrom)
31438	31504	{
31439	31505	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
31440	31506	// copy mutable arguments back from call to reportid
31441		- label = 2259LLU; // continue to roll stack
	31507	+ label = 2295LLU; // continue to roll stack
31442	31508	break;
31443	31509	}
31444		- case 2578LLU: // return from reportid to initfrom
	31510	+ case 2583LLU: // return from reportid to initfrom
31445	31511	{
31446	31512	// copy mutable arguments back from call to reportid
31447	31513	fprintf(stderr, "%s", " - if you mean call enclose type and variable-name in perentheses\n");
31448	31514	exit(-1);
31449		- label = 2458LLU; // default complete
	31515	+ label = 2463LLU; // default complete
31450	31516	break;
31451	31517	}
31452		- case 2458LLU: // completed switch
	31518	+ case 2463LLU: // completed switch
31453	31519	{
31454		- label = 2457LLU; // consequent complete
	31520	+ label = 2462LLU; // consequent complete
31455	31521	break;
31456	31522	}
31457		- case 2456LLU: // alternative
	31523	+ case 2461LLU: // alternative
31458	31524	{
31459	31525	// call getlettype from initfrom
31460		- stack[base + 18LLU] = 2579LLU/throw to this address/;
	31526	+ stack[base + 18LLU] = 2584LLU/throw to this address/;
31461	31527	stack[base + 19LLU] = base;
31462		- stack[base + 20LLU] = 2580LLU;
	31528	+ stack[base + 20LLU] = 2585LLU;
31463	31529	// arguments for call to getlettype
31464	31530	stack[base + 22LLU] = stack[base + 0]/fnid/;
31465	31531	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -31470,14 +31536,14 @@
31470	31536	label = 651LLU; // getlettype
31471	31537	break;
31472	31538	}
31473		- case 2579LLU: // copy-back deleter (getlettype to initfrom)
	31539	+ case 2584LLU: // copy-back deleter (getlettype to initfrom)
31474	31540	{
31475	31541	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
31476	31542	// copy mutable arguments back from call to getlettype
31477		- label = 2259LLU; // continue to roll stack
	31543	+ label = 2295LLU; // continue to roll stack
31478	31544	break;
31479	31545	}
31480		- case 2580LLU: // return from getlettype to initfrom
	31546	+ case 2585LLU: // return from getlettype to initfrom
31481	31547	{
31482	31548	// copy mutable arguments back from call to getlettype
31483	31549	// copy back results provided by call to getlettype

		@@ -31484,7 +31550,7 @@
31484	31550	stack[base + 17] = stack[base + 21LLU];
31485	31551	if(/typename/0 != ((uint64_t )(stack[base + 17]/dsttype*/))[0])
31486	31552	{
31487		- label = 2582LLU; // jump to alternative
	31553	+ label = 2587LLU; // jump to alternative
31488	31554	break;
31489	31555	}
31490	31556

		@@ -31492,9 +31558,9 @@
31492	31558
31493	31559	// case
31494	31560	// call equ from initfrom
31495		- stack[base + 19LLU] = 2584LLU/throw to this address/;
	31561	+ stack[base + 19LLU] = 2589LLU/throw to this address/;
31496	31562	stack[base + 20LLU] = base;
31497		- stack[base + 21LLU] = 2585LLU;
	31563	+ stack[base + 21LLU] = 2590LLU;
31498	31564	// arguments for call to equ
31499	31565	stack[base + 23LLU] = stack[base + 18]/name/;
31500	31566	stack[base + 24LLU] = 881834713755418624LLU;

		@@ -31503,14 +31569,14 @@
31503	31569	label = 18446744073709551600LLU; // equ
31504	31570	break;
31505	31571	}
31506		- case 2584LLU: // copy-back deleter (equ to initfrom)
	31572	+ case 2589LLU: // copy-back deleter (equ to initfrom)
31507	31573	{
31508	31574	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
31509	31575	// copy mutable arguments back from call to equ
31510		- label = 2583LLU; // continue to roll stack
	31576	+ label = 2588LLU; // continue to roll stack
31511	31577	break;
31512	31578	}
31513		- case 2585LLU: // return from equ to initfrom
	31579	+ case 2590LLU: // return from equ to initfrom
31514	31580	{
31515	31581	// copy mutable arguments back from call to equ
31516	31582	// copy back results provided by call to equ

		@@ -31517,7 +31583,7 @@
31517	31583	stack[base + 10] = stack[base + 22LLU];
31518	31584	if(!stack[base + 10]/isequal/)
31519	31585	{
31520		- label = 2586LLU; // jump to alternative
	31586	+ label = 2591LLU; // jump to alternative
31521	31587	break;
31522	31588	}
31523	31589

		@@ -31524,9 +31590,9 @@
31524	31590	// consequent
31525	31591	printf("%s", "\n ");
31526	31592	// call emitvaridx from initfrom
31527		- stack[base + 19LLU] = 2588LLU/throw to this address/;
	31593	+ stack[base + 19LLU] = 2593LLU/throw to this address/;
31528	31594	stack[base + 20LLU] = base;
31529		- stack[base + 21LLU] = 2589LLU;
	31595	+ stack[base + 21LLU] = 2594LLU;
31530	31596	// arguments for call to emitvaridx
31531	31597	stack[base + 22LLU] = stack[base + 3]/dstindex/;
31532	31598	// set stack-base & callee-address

		@@ -31534,21 +31600,21 @@
31534	31600	label = 691LLU; // emitvaridx
31535	31601	break;
31536	31602	}
31537		- case 2588LLU: // copy-back deleter (emitvaridx to initfrom)
	31603	+ case 2593LLU: // copy-back deleter (emitvaridx to initfrom)
31538	31604	{
31539	31605	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
31540	31606	// copy mutable arguments back from call to emitvaridx
31541		- label = 2583LLU; // continue to roll stack
	31607	+ label = 2588LLU; // continue to roll stack
31542	31608	break;
31543	31609	}
31544		- case 2589LLU: // return from emitvaridx to initfrom
	31610	+ case 2594LLU: // return from emitvaridx to initfrom
31545	31611	{
31546	31612	// copy mutable arguments back from call to emitvaridx
31547	31613	printf("%s", " = ");
31548	31614	// call emitvar from initfrom
31549		- stack[base + 19LLU] = 2590LLU/throw to this address/;
	31615	+ stack[base + 19LLU] = 2595LLU/throw to this address/;
31550	31616	stack[base + 20LLU] = base;
31551		- stack[base + 21LLU] = 2591LLU;
	31617	+ stack[base + 21LLU] = 2596LLU;
31552	31618	// arguments for call to emitvar
31553	31619	stack[base + 22LLU] = stack[base + 0]/fnid/;
31554	31620	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -31559,27 +31625,27 @@
31559	31625	label = 695LLU; // emitvar
31560	31626	break;
31561	31627	}
31562		- case 2590LLU: // copy-back deleter (emitvar to initfrom)
	31628	+ case 2595LLU: // copy-back deleter (emitvar to initfrom)
31563	31629	{
31564	31630	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
31565	31631	// copy mutable arguments back from call to emitvar
31566		- label = 2583LLU; // continue to roll stack
	31632	+ label = 2588LLU; // continue to roll stack
31567	31633	break;
31568	31634	}
31569		- case 2591LLU: // return from emitvar to initfrom
	31635	+ case 2596LLU: // return from emitvar to initfrom
31570	31636	{
31571	31637	// copy mutable arguments back from call to emitvar
31572	31638	printf("%s", ";");
31573		- label = 2587LLU; // consequent complete
	31639	+ label = 2592LLU; // consequent complete
31574	31640	break;
31575	31641	}
31576		- case 2586LLU: // alternative
	31642	+ case 2591LLU: // alternative
31577	31643	{
31578	31644	printf("%s", "\n INIT(&");
31579	31645	// call emitvaridx from initfrom
31580		- stack[base + 19LLU] = 2592LLU/throw to this address/;
	31646	+ stack[base + 19LLU] = 2597LLU/throw to this address/;
31581	31647	stack[base + 20LLU] = base;
31582		- stack[base + 21LLU] = 2593LLU;
	31648	+ stack[base + 21LLU] = 2598LLU;
31583	31649	// arguments for call to emitvaridx
31584	31650	stack[base + 22LLU] = stack[base + 3]/dstindex/;
31585	31651	// set stack-base & callee-address

		@@ -31587,21 +31653,21 @@
31587	31653	label = 691LLU; // emitvaridx
31588	31654	break;
31589	31655	}
31590		- case 2592LLU: // copy-back deleter (emitvaridx to initfrom)
	31656	+ case 2597LLU: // copy-back deleter (emitvaridx to initfrom)
31591	31657	{
31592	31658	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
31593	31659	// copy mutable arguments back from call to emitvaridx
31594		- label = 2583LLU; // continue to roll stack
	31660	+ label = 2588LLU; // continue to roll stack
31595	31661	break;
31596	31662	}
31597		- case 2593LLU: // return from emitvaridx to initfrom
	31663	+ case 2598LLU: // return from emitvaridx to initfrom
31598	31664	{
31599	31665	// copy mutable arguments back from call to emitvaridx
31600	31666	printf("%s", ", &");
31601	31667	// call emitvar from initfrom
31602		- stack[base + 19LLU] = 2594LLU/throw to this address/;
	31668	+ stack[base + 19LLU] = 2599LLU/throw to this address/;
31603	31669	stack[base + 20LLU] = base;
31604		- stack[base + 21LLU] = 2595LLU;
	31670	+ stack[base + 21LLU] = 2600LLU;
31605	31671	// arguments for call to emitvar
31606	31672	stack[base + 22LLU] = stack[base + 0]/fnid/;
31607	31673	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -31612,21 +31678,21 @@
31612	31678	label = 695LLU; // emitvar
31613	31679	break;
31614	31680	}
31615		- case 2594LLU: // copy-back deleter (emitvar to initfrom)
	31681	+ case 2599LLU: // copy-back deleter (emitvar to initfrom)
31616	31682	{
31617	31683	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
31618	31684	// copy mutable arguments back from call to emitvar
31619		- label = 2583LLU; // continue to roll stack
	31685	+ label = 2588LLU; // continue to roll stack
31620	31686	break;
31621	31687	}
31622		- case 2595LLU: // return from emitvar to initfrom
	31688	+ case 2600LLU: // return from emitvar to initfrom
31623	31689	{
31624	31690	// copy mutable arguments back from call to emitvar
31625	31691	printf("%s", ");");
31626	31692	// call unscopelet from initfrom
31627		- stack[base + 19LLU] = 2596LLU/throw to this address/;
	31693	+ stack[base + 19LLU] = 2601LLU/throw to this address/;
31628	31694	stack[base + 20LLU] = base;
31629		- stack[base + 21LLU] = 2597LLU;
	31695	+ stack[base + 21LLU] = 2602LLU;
31630	31696	// arguments for call to unscopelet
31631	31697	stack[base + 22LLU] = stack[base + 0]/fnid/;
31632	31698	stack[base + 23LLU] = stack[base + 6]/scope/;

		@@ -31636,41 +31702,41 @@
31636	31702	label = 761LLU; // unscopelet
31637	31703	break;
31638	31704	}
31639		- case 2596LLU: // copy-back deleter (unscopelet to initfrom)
	31705	+ case 2601LLU: // copy-back deleter (unscopelet to initfrom)
31640	31706	{
31641	31707	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
31642	31708	// copy mutable arguments back from call to unscopelet
31643	31709	stack[base + 6]/scope/ = stack[base + 23LLU];
31644		- label = 2583LLU; // continue to roll stack
	31710	+ label = 2588LLU; // continue to roll stack
31645	31711	break;
31646	31712	}
31647		- case 2597LLU: // return from unscopelet to initfrom
	31713	+ case 2602LLU: // return from unscopelet to initfrom
31648	31714	{
31649	31715	// copy mutable arguments back from call to unscopelet
31650	31716	stack[base + 6]/scope/ = stack[base + 23LLU];
31651		- label = 2587LLU; // alternative complete
	31717	+ label = 2592LLU; // alternative complete
31652	31718	break;
31653	31719	}
31654		- case 2587LLU: // completed if-then-else
	31720	+ case 2592LLU: // completed if-then-else
31655	31721	{
31656	31722	((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31657		- label = 2581LLU; // case complete
	31723	+ label = 2586LLU; // case complete
31658	31724	break;
31659	31725	}
31660		- case 2583LLU: // copy-back deleter (switch)
	31726	+ case 2588LLU: // copy-back deleter (switch)
31661	31727	{
31662	31728	((uint64_t **)(stack[base + 17]))[1][0] = stack[base + 18];
31663		- label = 2259LLU; // continue to unroll stack
	31729	+ label = 2295LLU; // continue to unroll stack
31664	31730	break;
31665	31731	}
31666		- case 2582LLU: // try next case
	31732	+ case 2587LLU: // try next case
31667	31733	{
31668	31734	// default
31669	31735	printf("%s", "\n INIT(&");
31670	31736	// call emitvaridx from initfrom
31671		- stack[base + 18LLU] = 2598LLU/throw to this address/;
	31737	+ stack[base + 18LLU] = 2603LLU/throw to this address/;
31672	31738	stack[base + 19LLU] = base;
31673		- stack[base + 20LLU] = 2599LLU;
	31739	+ stack[base + 20LLU] = 2604LLU;
31674	31740	// arguments for call to emitvaridx
31675	31741	stack[base + 21LLU] = stack[base + 3]/dstindex/;
31676	31742	// set stack-base & callee-address

		@@ -31678,21 +31744,21 @@
31678	31744	label = 691LLU; // emitvaridx
31679	31745	break;
31680	31746	}
31681		- case 2598LLU: // copy-back deleter (emitvaridx to initfrom)
	31747	+ case 2603LLU: // copy-back deleter (emitvaridx to initfrom)
31682	31748	{
31683	31749	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
31684	31750	// copy mutable arguments back from call to emitvaridx
31685		- label = 2259LLU; // continue to roll stack
	31751	+ label = 2295LLU; // continue to roll stack
31686	31752	break;
31687	31753	}
31688		- case 2599LLU: // return from emitvaridx to initfrom
	31754	+ case 2604LLU: // return from emitvaridx to initfrom
31689	31755	{
31690	31756	// copy mutable arguments back from call to emitvaridx
31691	31757	printf("%s", ", &");
31692	31758	// call emitvar from initfrom
31693		- stack[base + 18LLU] = 2600LLU/throw to this address/;
	31759	+ stack[base + 18LLU] = 2605LLU/throw to this address/;
31694	31760	stack[base + 19LLU] = base;
31695		- stack[base + 20LLU] = 2601LLU;
	31761	+ stack[base + 20LLU] = 2606LLU;
31696	31762	// arguments for call to emitvar
31697	31763	stack[base + 21LLU] = stack[base + 0]/fnid/;
31698	31764	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -31703,21 +31769,21 @@
31703	31769	label = 695LLU; // emitvar
31704	31770	break;
31705	31771	}
31706		- case 2600LLU: // copy-back deleter (emitvar to initfrom)
	31772	+ case 2605LLU: // copy-back deleter (emitvar to initfrom)
31707	31773	{
31708	31774	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
31709	31775	// copy mutable arguments back from call to emitvar
31710		- label = 2259LLU; // continue to roll stack
	31776	+ label = 2295LLU; // continue to roll stack
31711	31777	break;
31712	31778	}
31713		- case 2601LLU: // return from emitvar to initfrom
	31779	+ case 2606LLU: // return from emitvar to initfrom
31714	31780	{
31715	31781	// copy mutable arguments back from call to emitvar
31716	31782	printf("%s", ");");
31717	31783	// call unscopelet from initfrom
31718		- stack[base + 18LLU] = 2602LLU/throw to this address/;
	31784	+ stack[base + 18LLU] = 2607LLU/throw to this address/;
31719	31785	stack[base + 19LLU] = base;
31720		- stack[base + 20LLU] = 2603LLU;
	31786	+ stack[base + 20LLU] = 2608LLU;
31721	31787	// arguments for call to unscopelet
31722	31788	stack[base + 21LLU] = stack[base + 0]/fnid/;
31723	31789	stack[base + 22LLU] = stack[base + 6]/scope/;

		@@ -31727,22 +31793,22 @@
31727	31793	label = 761LLU; // unscopelet
31728	31794	break;
31729	31795	}
31730		- case 2602LLU: // copy-back deleter (unscopelet to initfrom)
	31796	+ case 2607LLU: // copy-back deleter (unscopelet to initfrom)
31731	31797	{
31732	31798	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
31733	31799	// copy mutable arguments back from call to unscopelet
31734	31800	stack[base + 6]/scope/ = stack[base + 22LLU];
31735		- label = 2259LLU; // continue to roll stack
	31801	+ label = 2295LLU; // continue to roll stack
31736	31802	break;
31737	31803	}
31738		- case 2603LLU: // return from unscopelet to initfrom
	31804	+ case 2608LLU: // return from unscopelet to initfrom
31739	31805	{
31740	31806	// copy mutable arguments back from call to unscopelet
31741	31807	stack[base + 6]/scope/ = stack[base + 22LLU];
31742		- label = 2581LLU; // default complete
	31808	+ label = 2586LLU; // default complete
31743	31809	break;
31744	31810	}
31745		- case 2581LLU: // completed switch
	31811	+ case 2586LLU: // completed switch
31746	31812	{
31747	31813
31748	31814	uint64_t newstack = (uint64_t )(stack[base + 17] - sizeof(uint64_t) * 4);

		@@ -31750,7 +31816,7 @@
31750	31816	newstack[0] = (uint64_t)stack; // backup stack location
31751	31817	newstack[1] = 1234567890;
31752	31818	newstack[2] = base;
31753		- newstack[3] = 2604LLU;
	31819	+ newstack[3] = 2609LLU;
31754	31820	stack = newstack;
31755	31821	// set stack-base & callee-address
31756	31822	base = 4/deloffset/;

		@@ -31757,30 +31823,30 @@
31757	31823	label = 296LLU; // ~type
31758	31824	break;
31759	31825	}
31760		- case 2604LLU: // return from ~type to initfrom
	31826	+ case 2609LLU: // return from ~type to initfrom
31761	31827	{
31762	31828	stack = (uint64_t *)stack[0];
31763	31829	// releasing toplevel container
31764	31830	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 17] - sizeof(uint64_t) 4));
31765	31831
31766		- label = 2457LLU; // alternative complete
	31832	+ label = 2462LLU; // alternative complete
31767	31833	break;
31768	31834	}
31769		- case 2457LLU: // completed if-then-else
	31835	+ case 2462LLU: // completed if-then-else
31770	31836	{
31771		- label = 2315LLU; // alternative complete
	31837	+ label = 2320LLU; // alternative complete
31772	31838	break;
31773	31839	}
31774		- case 2315LLU: // completed if-then-else
	31840	+ case 2320LLU: // completed if-then-else
31775	31841	{
31776		- label = 2309LLU; // consequent complete
	31842	+ label = 2314LLU; // consequent complete
31777	31843	break;
31778	31844	}
31779		- case 2308LLU: // alternative
	31845	+ case 2313LLU: // alternative
31780	31846	{
31781	31847	if(/typename/0 != ((uint64_t )(stack[base + 1]/dsttype*/))[0])
31782	31848	{
31783		- label = 2606LLU; // jump to alternative
	31849	+ label = 2611LLU; // jump to alternative
31784	31850	break;
31785	31851	}
31786	31852

		@@ -31788,9 +31854,9 @@
31788	31854
31789	31855	// case
31790	31856	// call equ from initfrom
31791		- stack[base + 16LLU] = 2608LLU/throw to this address/;
	31857	+ stack[base + 16LLU] = 2613LLU/throw to this address/;
31792	31858	stack[base + 17LLU] = base;
31793		- stack[base + 18LLU] = 2609LLU;
	31859	+ stack[base + 18LLU] = 2614LLU;
31794	31860	// arguments for call to equ
31795	31861	stack[base + 20LLU] = 881834713755418624LLU;
31796	31862	stack[base + 21LLU] = stack[base + 15]/name/;

		@@ -31799,14 +31865,14 @@
31799	31865	label = 18446744073709551600LLU; // equ
31800	31866	break;
31801	31867	}
31802		- case 2608LLU: // copy-back deleter (equ to initfrom)
	31868	+ case 2613LLU: // copy-back deleter (equ to initfrom)
31803	31869	{
31804	31870	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
31805	31871	// copy mutable arguments back from call to equ
31806		- label = 2607LLU; // continue to roll stack
	31872	+ label = 2612LLU; // continue to roll stack
31807	31873	break;
31808	31874	}
31809		- case 2609LLU: // return from equ to initfrom
	31875	+ case 2614LLU: // return from equ to initfrom
31810	31876	{
31811	31877	// copy mutable arguments back from call to equ
31812	31878	// copy back results provided by call to equ

		@@ -31813,15 +31879,15 @@
31813	31879	stack[base + 10] = stack[base + 19LLU];
31814	31880	if(!stack[base + 10]/isequal/)
31815	31881	{
31816		- label = 2610LLU; // jump to alternative
	31882	+ label = 2615LLU; // jump to alternative
31817	31883	break;
31818	31884	}
31819	31885
31820	31886	// consequent
31821	31887	// call isncs from initfrom
31822		- stack[base + 16LLU] = 2612LLU/throw to this address/;
	31888	+ stack[base + 16LLU] = 2617LLU/throw to this address/;
31823	31889	stack[base + 17LLU] = base;
31824		- stack[base + 18LLU] = 2613LLU;
	31890	+ stack[base + 18LLU] = 2618LLU;
31825	31891	// arguments for call to isncs
31826	31892	stack[base + 20LLU] = stack[base + 12]/variant/;
31827	31893	// set stack-base & callee-address

		@@ -31829,14 +31895,14 @@
31829	31895	label = 272LLU; // isncs
31830	31896	break;
31831	31897	}
31832		- case 2612LLU: // copy-back deleter (isncs to initfrom)
	31898	+ case 2617LLU: // copy-back deleter (isncs to initfrom)
31833	31899	{
31834	31900	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (isncs to initfrom)\n");
31835	31901	// copy mutable arguments back from call to isncs
31836		- label = 2607LLU; // continue to roll stack
	31902	+ label = 2612LLU; // continue to roll stack
31837	31903	break;
31838	31904	}
31839		- case 2613LLU: // return from isncs to initfrom
	31905	+ case 2618LLU: // return from isncs to initfrom
31840	31906	{
31841	31907	// copy mutable arguments back from call to isncs
31842	31908	// copy back results provided by call to isncs

		@@ -31843,7 +31909,7 @@
31843	31909	stack[base + 10] = stack[base + 19LLU];
31844	31910	if(!stack[base + 10]/isequal/)
31845	31911	{
31846		- label = 2614LLU; // jump to alternative
	31912	+ label = 2619LLU; // jump to alternative
31847	31913	break;
31848	31914	}
31849	31915

		@@ -31850,9 +31916,9 @@
31850	31916	// consequent
31851	31917	printf("%s", "\n ");
31852	31918	// call emitvaridx from initfrom
31853		- stack[base + 16LLU] = 2616LLU/throw to this address/;
	31919	+ stack[base + 16LLU] = 2621LLU/throw to this address/;
31854	31920	stack[base + 17LLU] = base;
31855		- stack[base + 18LLU] = 2617LLU;
	31921	+ stack[base + 18LLU] = 2622LLU;
31856	31922	// arguments for call to emitvaridx
31857	31923	stack[base + 19LLU] = stack[base + 3]/dstindex/;
31858	31924	// set stack-base & callee-address

		@@ -31860,21 +31926,21 @@
31860	31926	label = 691LLU; // emitvaridx
31861	31927	break;
31862	31928	}
31863		- case 2616LLU: // copy-back deleter (emitvaridx to initfrom)
	31929	+ case 2621LLU: // copy-back deleter (emitvaridx to initfrom)
31864	31930	{
31865	31931	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
31866	31932	// copy mutable arguments back from call to emitvaridx
31867		- label = 2607LLU; // continue to roll stack
	31933	+ label = 2612LLU; // continue to roll stack
31868	31934	break;
31869	31935	}
31870		- case 2617LLU: // return from emitvaridx to initfrom
	31936	+ case 2622LLU: // return from emitvaridx to initfrom
31871	31937	{
31872	31938	// copy mutable arguments back from call to emitvaridx
31873	31939	printf("%s", " = ");
31874	31940	// call printnr from initfrom
31875		- stack[base + 16LLU] = 2618LLU/throw to this address/;
	31941	+ stack[base + 16LLU] = 2623LLU/throw to this address/;
31876	31942	stack[base + 17LLU] = base;
31877		- stack[base + 18LLU] = 2619LLU;
	31943	+ stack[base + 18LLU] = 2624LLU;
31878	31944	// arguments for call to printnr
31879	31945	stack[base + 19LLU] = stack[base + 13]/content/;
31880	31946	// set stack-base & callee-address

		@@ -31882,21 +31948,21 @@
31882	31948	label = 18446744073709551590LLU; // printnr
31883	31949	break;
31884	31950	}
31885		- case 2618LLU: // copy-back deleter (printnr to initfrom)
	31951	+ case 2623LLU: // copy-back deleter (printnr to initfrom)
31886	31952	{
31887	31953	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
31888	31954	// copy mutable arguments back from call to printnr
31889		- label = 2607LLU; // continue to roll stack
	31955	+ label = 2612LLU; // continue to roll stack
31890	31956	break;
31891	31957	}
31892		- case 2619LLU: // return from printnr to initfrom
	31958	+ case 2624LLU: // return from printnr to initfrom
31893	31959	{
31894	31960	// copy mutable arguments back from call to printnr
31895	31961	printf("%s", ";");
31896		- label = 2615LLU; // consequent complete
	31962	+ label = 2620LLU; // consequent complete
31897	31963	break;
31898	31964	}
31899		- case 2614LLU: // alternative
	31965	+ case 2619LLU: // alternative
31900	31966	{
31901	31967	fprintf(stderr, "%s", "expected number/character/string or identifier (u64 variable) in ");
31902	31968	fprintf(stderr, "%s", "initializing type ");

		@@ -31903,7 +31969,7 @@
31903	31969	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
31904	31970	if(!newstack)
31905	31971	{
31906		- label = 2607LLU; // throw: begin to unroll stack
	31972	+ label = 2612LLU; // throw: begin to unroll stack
31907	31973	break;
31908	31974	}
31909	31975

		@@ -31910,9 +31976,9 @@
31910	31976	newstack[10LLU] = 9876543210LLU; // overflow-marker
31911	31977	// call reporttype from initfrom
31912	31978	newstack[0] = (uint64_t)stack; // backup stack location
31913		- newstack[1] = 2620LLU;
	31979	+ newstack[1] = 2625LLU;
31914	31980	newstack[2] = base;
31915		- newstack[3] = 2621LLU;
	31981	+ newstack[3] = 2626LLU;
31916	31982	// arguments for call to reporttype
31917	31983	newstack[4LLU] = stack[base + 1]/dsttype/;
31918	31984	stack = newstack;

		@@ -31921,7 +31987,7 @@
31921	31987	label = 316LLU; // reporttype
31922	31988	break;
31923	31989	}
31924		- case 2620LLU: // copy-back deleter (reporttype to initfrom)
	31990	+ case 2625LLU: // copy-back deleter (reporttype to initfrom)
31925	31991	{
31926	31992	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
31927	31993	uint64_t oldstack = (uint64_t )stack[0];

		@@ -31933,10 +31999,10 @@
31933	31999	}
31934	32000	Free(10LLU + 1, sizeof(uint64_t), stack);
31935	32001	stack = oldstack;
31936		- label = 2607LLU; // continue to unroll stack
	32002	+ label = 2612LLU; // continue to unroll stack
31937	32003	break;
31938	32004	}
31939		- case 2621LLU: // return from reporttype to initfrom
	32005	+ case 2626LLU: // return from reporttype to initfrom
31940	32006	{
31941	32007	uint64_t oldstack = (uint64_t )stack[0];
31942	32008	// copy mutable arguments back from call to reporttype

		@@ -31949,9 +32015,9 @@
31949	32015	stack = oldstack;
31950	32016	fprintf(stderr, "%s", " with ");
31951	32017	// call reporttok from initfrom
31952		- stack[base + 16LLU] = 2622LLU/throw to this address/;
	32018	+ stack[base + 16LLU] = 2627LLU/throw to this address/;
31953	32019	stack[base + 17LLU] = base;
31954		- stack[base + 18LLU] = 2623LLU;
	32020	+ stack[base + 18LLU] = 2628LLU;
31955	32021	// arguments for call to reporttok
31956	32022	stack[base + 19LLU] = stack[base + 12]/variant/;
31957	32023	stack[base + 20LLU] = stack[base + 13]/content/;

		@@ -31960,33 +32026,33 @@
31960	32026	label = 18446744073709551582LLU; // reporttok
31961	32027	break;
31962	32028	}
31963		- case 2622LLU: // copy-back deleter (reporttok to initfrom)
	32029	+ case 2627LLU: // copy-back deleter (reporttok to initfrom)
31964	32030	{
31965	32031	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
31966	32032	// copy mutable arguments back from call to reporttok
31967		- label = 2607LLU; // continue to roll stack
	32033	+ label = 2612LLU; // continue to roll stack
31968	32034	break;
31969	32035	}
31970		- case 2623LLU: // return from reporttok to initfrom
	32036	+ case 2628LLU: // return from reporttok to initfrom
31971	32037	{
31972	32038	// copy mutable arguments back from call to reporttok
31973	32039	fprintf(stderr, "%s", "\n");
31974	32040	exit(-1);
31975		- label = 2615LLU; // alternative complete
	32041	+ label = 2620LLU; // alternative complete
31976	32042	break;
31977	32043	}
31978		- case 2615LLU: // completed if-then-else
	32044	+ case 2620LLU: // completed if-then-else
31979	32045	{
31980		- label = 2611LLU; // consequent complete
	32046	+ label = 2616LLU; // consequent complete
31981	32047	break;
31982	32048	}
31983		- case 2610LLU: // alternative
	32049	+ case 2615LLU: // alternative
31984	32050	{
31985	32051	fprintf(stderr, "%s", "in function ");
31986	32052	// call reportid from initfrom
31987		- stack[base + 16LLU] = 2624LLU/throw to this address/;
	32053	+ stack[base + 16LLU] = 2629LLU/throw to this address/;
31988	32054	stack[base + 17LLU] = base;
31989		- stack[base + 18LLU] = 2625LLU;
	32055	+ stack[base + 18LLU] = 2630LLU;
31990	32056	// arguments for call to reportid
31991	32057	stack[base + 19LLU] = stack[base + 0]/fnid/;
31992	32058	// set stack-base & callee-address

		@@ -31994,14 +32060,14 @@
31994	32060	label = 18446744073709551586LLU; // reportid
31995	32061	break;
31996	32062	}
31997		- case 2624LLU: // copy-back deleter (reportid to initfrom)
	32063	+ case 2629LLU: // copy-back deleter (reportid to initfrom)
31998	32064	{
31999	32065	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
32000	32066	// copy mutable arguments back from call to reportid
32001		- label = 2607LLU; // continue to roll stack
	32067	+ label = 2612LLU; // continue to roll stack
32002	32068	break;
32003	32069	}
32004		- case 2625LLU: // return from reportid to initfrom
	32070	+ case 2630LLU: // return from reportid to initfrom
32005	32071	{
32006	32072	// copy mutable arguments back from call to reportid
32007	32073	fprintf(stderr, "%s", ": can't initialize type ");

		@@ -32008,7 +32074,7 @@
32008	32074	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
32009	32075	if(!newstack)
32010	32076	{
32011		- label = 2607LLU; // throw: begin to unroll stack
	32077	+ label = 2612LLU; // throw: begin to unroll stack
32012	32078	break;
32013	32079	}
32014	32080

		@@ -32015,9 +32081,9 @@
32015	32081	newstack[10LLU] = 9876543210LLU; // overflow-marker
32016	32082	// call reporttype from initfrom
32017	32083	newstack[0] = (uint64_t)stack; // backup stack location
32018		- newstack[1] = 2626LLU;
	32084	+ newstack[1] = 2631LLU;
32019	32085	newstack[2] = base;
32020		- newstack[3] = 2627LLU;
	32086	+ newstack[3] = 2632LLU;
32021	32087	// arguments for call to reporttype
32022	32088	newstack[4LLU] = stack[base + 1]/dsttype/;
32023	32089	stack = newstack;

		@@ -32026,7 +32092,7 @@
32026	32092	label = 316LLU; // reporttype
32027	32093	break;
32028	32094	}
32029		- case 2626LLU: // copy-back deleter (reporttype to initfrom)
	32095	+ case 2631LLU: // copy-back deleter (reporttype to initfrom)
32030	32096	{
32031	32097	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
32032	32098	uint64_t oldstack = (uint64_t )stack[0];

		@@ -32038,10 +32104,10 @@
32038	32104	}
32039	32105	Free(10LLU + 1, sizeof(uint64_t), stack);
32040	32106	stack = oldstack;
32041		- label = 2607LLU; // continue to unroll stack
	32107	+ label = 2612LLU; // continue to unroll stack
32042	32108	break;
32043	32109	}
32044		- case 2627LLU: // return from reporttype to initfrom
	32110	+ case 2632LLU: // return from reporttype to initfrom
32045	32111	{
32046	32112	uint64_t oldstack = (uint64_t )stack[0];
32047	32113	// copy mutable arguments back from call to reporttype

		@@ -32054,9 +32120,9 @@
32054	32120	stack = oldstack;
32055	32121	fprintf(stderr, "%s", " with literal ");
32056	32122	// call reporttok from initfrom
32057		- stack[base + 16LLU] = 2628LLU/throw to this address/;
	32123	+ stack[base + 16LLU] = 2633LLU/throw to this address/;
32058	32124	stack[base + 17LLU] = base;
32059		- stack[base + 18LLU] = 2629LLU;
	32125	+ stack[base + 18LLU] = 2634LLU;
32060	32126	// arguments for call to reporttok
32061	32127	stack[base + 19LLU] = stack[base + 12]/variant/;
32062	32128	stack[base + 20LLU] = stack[base + 13]/content/;

		@@ -32065,38 +32131,38 @@
32065	32131	label = 18446744073709551582LLU; // reporttok
32066	32132	break;
32067	32133	}
32068		- case 2628LLU: // copy-back deleter (reporttok to initfrom)
	32134	+ case 2633LLU: // copy-back deleter (reporttok to initfrom)
32069	32135	{
32070	32136	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
32071	32137	// copy mutable arguments back from call to reporttok
32072		- label = 2607LLU; // continue to roll stack
	32138	+ label = 2612LLU; // continue to roll stack
32073	32139	break;
32074	32140	}
32075		- case 2629LLU: // return from reporttok to initfrom
	32141	+ case 2634LLU: // return from reporttok to initfrom
32076	32142	{
32077	32143	// copy mutable arguments back from call to reporttok
32078	32144	fprintf(stderr, "%s", " - use constructor instead\n");
32079	32145	exit(-1);
32080		- label = 2611LLU; // alternative complete
	32146	+ label = 2616LLU; // alternative complete
32081	32147	break;
32082	32148	}
32083		- case 2611LLU: // completed if-then-else
	32149	+ case 2616LLU: // completed if-then-else
32084	32150	{
32085	32151	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32086		- label = 2605LLU; // case complete
	32152	+ label = 2610LLU; // case complete
32087	32153	break;
32088	32154	}
32089		- case 2607LLU: // copy-back deleter (switch)
	32155	+ case 2612LLU: // copy-back deleter (switch)
32090	32156	{
32091	32157	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32092		- label = 2259LLU; // continue to unroll stack
	32158	+ label = 2295LLU; // continue to unroll stack
32093	32159	break;
32094	32160	}
32095		- case 2606LLU: // try next case
	32161	+ case 2611LLU: // try next case
32096	32162	{
32097	32163	if(/typelist/1 != ((uint64_t )(stack[base + 1]/dsttype*/))[0])
32098	32164	{
32099		- label = 2630LLU; // jump to alternative
	32165	+ label = 2635LLU; // jump to alternative
32100	32166	break;
32101	32167	}
32102	32168

		@@ -32104,9 +32170,9 @@
32104	32170
32105	32171	// case
32106	32172	// call issimple from initfrom
32107		- stack[base + 16LLU] = 2632LLU/throw to this address/;
	32173	+ stack[base + 16LLU] = 2637LLU/throw to this address/;
32108	32174	stack[base + 17LLU] = base;
32109		- stack[base + 18LLU] = 2633LLU;
	32175	+ stack[base + 18LLU] = 2638LLU;
32110	32176	// arguments for call to issimple
32111	32177	stack[base + 20LLU] = stack[base + 12]/variant/;
32112	32178	stack[base + 21LLU] = stack[base + 13]/content/;

		@@ -32116,14 +32182,14 @@
32116	32182	label = 158LLU; // issimple
32117	32183	break;
32118	32184	}
32119		- case 2632LLU: // copy-back deleter (issimple to initfrom)
	32185	+ case 2637LLU: // copy-back deleter (issimple to initfrom)
32120	32186	{
32121	32187	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
32122	32188	// copy mutable arguments back from call to issimple
32123		- label = 2631LLU; // continue to roll stack
	32189	+ label = 2636LLU; // continue to roll stack
32124	32190	break;
32125	32191	}
32126		- case 2633LLU: // return from issimple to initfrom
	32192	+ case 2638LLU: // return from issimple to initfrom
32127	32193	{
32128	32194	// copy mutable arguments back from call to issimple
32129	32195	// copy back results provided by call to issimple

		@@ -32130,15 +32196,15 @@
32130	32196	stack[base + 10] = stack[base + 19LLU];
32131	32197	if(!stack[base + 10]/isequal/)
32132	32198	{
32133		- label = 2634LLU; // jump to alternative
	32199	+ label = 2639LLU; // jump to alternative
32134	32200	break;
32135	32201	}
32136	32202
32137	32203	// consequent
32138	32204	// call matchsym from initfrom
32139		- stack[base + 16LLU] = 2636LLU/throw to this address/;
	32205	+ stack[base + 16LLU] = 2641LLU/throw to this address/;
32140	32206	stack[base + 17LLU] = base;
32141		- stack[base + 18LLU] = 2637LLU;
	32207	+ stack[base + 18LLU] = 2642LLU;
32142	32208	// arguments for call to matchsym
32143	32209	stack[base + 19LLU] = stack[base + 0]/fnid/;
32144	32210	stack[base + 20LLU] = 93LLU;

		@@ -32148,23 +32214,23 @@
32148	32214	label = 212LLU; // matchsym
32149	32215	break;
32150	32216	}
32151		- case 2636LLU: // copy-back deleter (matchsym to initfrom)
	32217	+ case 2641LLU: // copy-back deleter (matchsym to initfrom)
32152	32218	{
32153	32219	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
32154	32220	// copy mutable arguments back from call to matchsym
32155	32221	stack[base + 7]/lookahead/ = stack[base + 21LLU];
32156		- label = 2631LLU; // continue to roll stack
	32222	+ label = 2636LLU; // continue to roll stack
32157	32223	break;
32158	32224	}
32159		- case 2637LLU: // return from matchsym to initfrom
	32225	+ case 2642LLU: // return from matchsym to initfrom
32160	32226	{
32161	32227	// copy mutable arguments back from call to matchsym
32162	32228	stack[base + 7]/lookahead/ = stack[base + 21LLU];
32163	32229	printf("%s", "\n ");
32164	32230	// call emitvaridx from initfrom
32165		- stack[base + 16LLU] = 2638LLU/throw to this address/;
	32231	+ stack[base + 16LLU] = 2643LLU/throw to this address/;
32166	32232	stack[base + 17LLU] = base;
32167		- stack[base + 18LLU] = 2639LLU;
	32233	+ stack[base + 18LLU] = 2644LLU;
32168	32234	// arguments for call to emitvaridx
32169	32235	stack[base + 19LLU] = stack[base + 3]/dstindex/;
32170	32236	// set stack-base & callee-address

		@@ -32172,27 +32238,27 @@
32172	32238	label = 691LLU; // emitvaridx
32173	32239	break;
32174	32240	}
32175		- case 2638LLU: // copy-back deleter (emitvaridx to initfrom)
	32241	+ case 2643LLU: // copy-back deleter (emitvaridx to initfrom)
32176	32242	{
32177	32243	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
32178	32244	// copy mutable arguments back from call to emitvaridx
32179		- label = 2631LLU; // continue to roll stack
	32245	+ label = 2636LLU; // continue to roll stack
32180	32246	break;
32181	32247	}
32182		- case 2639LLU: // return from emitvaridx to initfrom
	32248	+ case 2644LLU: // return from emitvaridx to initfrom
32183	32249	{
32184	32250	// copy mutable arguments back from call to emitvaridx
32185	32251	printf("%s", " = 0;");
32186		- label = 2635LLU; // consequent complete
	32252	+ label = 2640LLU; // consequent complete
32187	32253	break;
32188	32254	}
32189		- case 2634LLU: // alternative
	32255	+ case 2639LLU: // alternative
32190	32256	{
32191	32257	fprintf(stderr, "%s", "in function ");
32192	32258	// call reportid from initfrom
32193		- stack[base + 16LLU] = 2640LLU/throw to this address/;
	32259	+ stack[base + 16LLU] = 2645LLU/throw to this address/;
32194	32260	stack[base + 17LLU] = base;
32195		- stack[base + 18LLU] = 2641LLU;
	32261	+ stack[base + 18LLU] = 2646LLU;
32196	32262	// arguments for call to reportid
32197	32263	stack[base + 19LLU] = stack[base + 0]/fnid/;
32198	32264	// set stack-base & callee-address

		@@ -32200,14 +32266,14 @@
32200	32266	label = 18446744073709551586LLU; // reportid
32201	32267	break;
32202	32268	}
32203		- case 2640LLU: // copy-back deleter (reportid to initfrom)
	32269	+ case 2645LLU: // copy-back deleter (reportid to initfrom)
32204	32270	{
32205	32271	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
32206	32272	// copy mutable arguments back from call to reportid
32207		- label = 2631LLU; // continue to roll stack
	32273	+ label = 2636LLU; // continue to roll stack
32208	32274	break;
32209	32275	}
32210		- case 2641LLU: // return from reportid to initfrom
	32276	+ case 2646LLU: // return from reportid to initfrom
32211	32277	{
32212	32278	// copy mutable arguments back from call to reportid
32213	32279	fprintf(stderr, "%s", ": can't initialize type ");

		@@ -32214,7 +32280,7 @@
32214	32280	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
32215	32281	if(!newstack)
32216	32282	{
32217		- label = 2631LLU; // throw: begin to unroll stack
	32283	+ label = 2636LLU; // throw: begin to unroll stack
32218	32284	break;
32219	32285	}
32220	32286

		@@ -32221,9 +32287,9 @@
32221	32287	newstack[10LLU] = 9876543210LLU; // overflow-marker
32222	32288	// call reporttype from initfrom
32223	32289	newstack[0] = (uint64_t)stack; // backup stack location
32224		- newstack[1] = 2642LLU;
	32290	+ newstack[1] = 2647LLU;
32225	32291	newstack[2] = base;
32226		- newstack[3] = 2643LLU;
	32292	+ newstack[3] = 2648LLU;
32227	32293	// arguments for call to reporttype
32228	32294	newstack[4LLU] = stack[base + 1]/dsttype/;
32229	32295	stack = newstack;

		@@ -32232,7 +32298,7 @@
32232	32298	label = 316LLU; // reporttype
32233	32299	break;
32234	32300	}
32235		- case 2642LLU: // copy-back deleter (reporttype to initfrom)
	32301	+ case 2647LLU: // copy-back deleter (reporttype to initfrom)
32236	32302	{
32237	32303	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
32238	32304	uint64_t oldstack = (uint64_t )stack[0];

		@@ -32244,10 +32310,10 @@
32244	32310	}
32245	32311	Free(10LLU + 1, sizeof(uint64_t), stack);
32246	32312	stack = oldstack;
32247		- label = 2631LLU; // continue to unroll stack
	32313	+ label = 2636LLU; // continue to unroll stack
32248	32314	break;
32249	32315	}
32250		- case 2643LLU: // return from reporttype to initfrom
	32316	+ case 2648LLU: // return from reporttype to initfrom
32251	32317	{
32252	32318	uint64_t oldstack = (uint64_t )stack[0];
32253	32319	// copy mutable arguments back from call to reporttype

		@@ -32260,9 +32326,9 @@
32260	32326	stack = oldstack;
32261	32327	fprintf(stderr, "%s", " with ");
32262	32328	// call reporttok from initfrom
32263		- stack[base + 16LLU] = 2644LLU/throw to this address/;
	32329	+ stack[base + 16LLU] = 2649LLU/throw to this address/;
32264	32330	stack[base + 17LLU] = base;
32265		- stack[base + 18LLU] = 2645LLU;
	32331	+ stack[base + 18LLU] = 2650LLU;
32266	32332	// arguments for call to reporttok
32267	32333	stack[base + 19LLU] = stack[base + 12]/variant/;
32268	32334	stack[base + 20LLU] = stack[base + 13]/content/;

		@@ -32271,49 +32337,49 @@
32271	32337	label = 18446744073709551582LLU; // reporttok
32272	32338	break;
32273	32339	}
32274		- case 2644LLU: // copy-back deleter (reporttok to initfrom)
	32340	+ case 2649LLU: // copy-back deleter (reporttok to initfrom)
32275	32341	{
32276	32342	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
32277	32343	// copy mutable arguments back from call to reporttok
32278		- label = 2631LLU; // continue to roll stack
	32344	+ label = 2636LLU; // continue to roll stack
32279	32345	break;
32280	32346	}
32281		- case 2645LLU: // return from reporttok to initfrom
	32347	+ case 2650LLU: // return from reporttok to initfrom
32282	32348	{
32283	32349	// copy mutable arguments back from call to reporttok
32284	32350	fprintf(stderr, "%s", "\n");
32285	32351	exit(-1);
32286		- label = 2635LLU; // alternative complete
	32352	+ label = 2640LLU; // alternative complete
32287	32353	break;
32288	32354	}
32289		- case 2635LLU: // completed if-then-else
	32355	+ case 2640LLU: // completed if-then-else
32290	32356	{
32291	32357	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32292		- label = 2605LLU; // case complete
	32358	+ label = 2610LLU; // case complete
32293	32359	break;
32294	32360	}
32295		- case 2631LLU: // copy-back deleter (switch)
	32361	+ case 2636LLU: // copy-back deleter (switch)
32296	32362	{
32297	32363	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 15];
32298		- label = 2259LLU; // continue to unroll stack
	32364	+ label = 2295LLU; // continue to unroll stack
32299	32365	break;
32300	32366	}
32301		- case 2630LLU: // try next case
	32367	+ case 2635LLU: // try next case
32302	32368	{
32303	32369	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
32304	32370	exit(-1);
32305	32371	}
32306		- case 2605LLU: // completed switch
	32372	+ case 2610LLU: // completed switch
32307	32373	{
32308		- label = 2309LLU; // alternative complete
	32374	+ label = 2314LLU; // alternative complete
32309	32375	break;
32310	32376	}
32311		- case 2309LLU: // completed if-then-else
	32377	+ case 2314LLU: // completed if-then-else
32312	32378	{
32313	32379	// call linkthrow from initfrom
32314		- stack[base + 15LLU] = 2646LLU/throw to this address/;
	32380	+ stack[base + 15LLU] = 2651LLU/throw to this address/;
32315	32381	stack[base + 16LLU] = base;
32316		- stack[base + 17LLU] = 2647LLU;
	32382	+ stack[base + 17LLU] = 2652LLU;
32317	32383	// arguments for call to linkthrow
32318	32384	stack[base + 18LLU] = stack[base + 6]/scope/;
32319	32385	stack[base + 19LLU] = stack[base + 11]/labelfail/;

		@@ -32322,15 +32388,15 @@
32322	32388	label = 1554LLU; // linkthrow
32323	32389	break;
32324	32390	}
32325		- case 2646LLU: // copy-back deleter (linkthrow to initfrom)
	32391	+ case 2651LLU: // copy-back deleter (linkthrow to initfrom)
32326	32392	{
32327	32393	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (linkthrow to initfrom)\n");
32328	32394	// copy mutable arguments back from call to linkthrow
32329	32395	stack[base + 6]/scope/ = stack[base + 18LLU];
32330		- label = 2259LLU; // continue to roll stack
	32396	+ label = 2295LLU; // continue to roll stack
32331	32397	break;
32332	32398	}
32333		- case 2647LLU: // return from linkthrow to initfrom
	32399	+ case 2652LLU: // return from linkthrow to initfrom
32334	32400	{
32335	32401	// copy mutable arguments back from call to linkthrow
32336	32402	stack[base + 6]/scope/ = stack[base + 18LLU];

		@@ -32339,7 +32405,7 @@
32339	32405	base = stack[base - 2];
32340	32406	break;
32341	32407	}
32342		- case 2649LLU: // function PROCRETURN failed
	32408	+ case 2654LLU: // function PROCRETURN failed
32343	32409	{
32344	32410	fprintf(stderr, "function PROCRETURN failed\n");
32345	32411	label = stack[base - 3];

		@@ -32346,7 +32412,7 @@
32346	32412	base = stack[base - 2];
32347	32413	break;
32348	32414	}
32349		- case 2648LLU: // PROCRETURN
	32415	+ case 2653LLU: // PROCRETURN
32350	32416	{
32351	32417	//#define arg0 0
32352	32418	//#define arg1 1

		@@ -32366,29 +32432,29 @@
32366	32432	//#define arg15 15
32367	32433	//#define arg16 16
32368	32434	//#define arg17 17
32369		- label = 2651LLU; // skip deleter
	32435	+ label = 2656LLU; // skip deleter
32370	32436	break;
32371	32437	}
32372		- case 2650LLU: // deleter
	32438	+ case 2655LLU: // deleter
32373	32439	{
32374	32440	// throw from PROCRETURN
32375	32441	if(!stack[base + 18])
32376	32442	{
32377	32443	fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
32378		- label = 2649LLU; // skip, variable already deleted/unscoped
	32444	+ label = 2654LLU; // skip, variable already deleted/unscoped
32379	32445	break;
32380	32446	}
32381	32447	fprintf(stderr, "in function PROCRETURN: unrolling stack, variable u64 isequal\n");
32382		- label = 2649LLU; // continue unrolling stack, delete next variable
	32448	+ label = 2654LLU; // continue unrolling stack, delete next variable
32383	32449	break;
32384	32450	}
32385		- case 2651LLU: // skipped deleter
	32451	+ case 2656LLU: // skipped deleter
32386	32452	{
32387	32453	stack[base + 18] = 0;
32388	32454	// call issimple from PROCRETURN
32389		- stack[base + 19LLU] = 2652LLU/throw to this address/;
	32455	+ stack[base + 19LLU] = 2657LLU/throw to this address/;
32390	32456	stack[base + 20LLU] = base;
32391		- stack[base + 21LLU] = 2653LLU;
	32457	+ stack[base + 21LLU] = 2658LLU;
32392	32458	// arguments for call to issimple
32393	32459	stack[base + 23LLU] = stack[base + 15]/variant/;
32394	32460	stack[base + 24LLU] = stack[base + 16]/content/;

		@@ -32398,14 +32464,14 @@
32398	32464	label = 158LLU; // issimple
32399	32465	break;
32400	32466	}
32401		- case 2652LLU: // copy-back deleter (issimple to PROCRETURN)
	32467	+ case 2657LLU: // copy-back deleter (issimple to PROCRETURN)
32402	32468	{
32403	32469	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (issimple to PROCRETURN)\n");
32404	32470	// copy mutable arguments back from call to issimple
32405		- label = 2650LLU; // continue to roll stack
	32471	+ label = 2655LLU; // continue to roll stack
32406	32472	break;
32407	32473	}
32408		- case 2653LLU: // return from issimple to PROCRETURN
	32474	+ case 2658LLU: // return from issimple to PROCRETURN
32409	32475	{
32410	32476	// copy mutable arguments back from call to issimple
32411	32477	// copy back results provided by call to issimple

		@@ -32412,20 +32478,20 @@
32412	32478	stack[base + 18] = stack[base + 22LLU];
32413	32479	if(!stack[base + 18]/isequal/)
32414	32480	{
32415		- label = 2654LLU; // jump to alternative
	32481	+ label = 2659LLU; // jump to alternative
32416	32482	break;
32417	32483	}
32418	32484
32419	32485	// consequent
32420	32486	flippedassign(stack[base + 4]/blkresults/, &stack[base + 19]);
32421		- label = 2656LLU; // start to repeat
	32487	+ label = 2661LLU; // start to repeat
32422	32488	break;
32423	32489	}
32424		- case 2656LLU: // repeat from here
	32490	+ case 2661LLU: // repeat from here
32425	32491	{
32426	32492	if(!stack[base + 19])
32427	32493	{
32428		- label = 2657LLU; // break loop
	32494	+ label = 2662LLU; // break loop
32429	32495	break;
32430	32496	}
32431	32497

		@@ -32435,7 +32501,7 @@
32435	32501	stack[base + 19] = (uint64_t)(((const struct listnode *)(stack[base + 19]))->next);
32436	32502	if(/typeidx/0 != ((uint64_t )(stack[base + 20]/typeidx*/))[0])
32437	32503	{
32438		- label = 2660LLU; // jump to alternative
	32504	+ label = 2665LLU; // jump to alternative
32439	32505	break;
32440	32506	}
32441	32507

		@@ -32444,9 +32510,9 @@
32444	32510
32445	32511	// case
32446	32512	// call initfrom from PROCRETURN
32447		- stack[base + 24LLU] = 2662LLU/throw to this address/;
	32513	+ stack[base + 24LLU] = 2667LLU/throw to this address/;
32448	32514	stack[base + 25LLU] = base;
32449		- stack[base + 26LLU] = 2663LLU;
	32515	+ stack[base + 26LLU] = 2668LLU;
32450	32516	// arguments for call to initfrom
32451	32517	stack[base + 27LLU] = stack[base + 9]/fnid/;
32452	32518	stack[base + 28LLU] = stack[base + 22]/type/;

		@@ -32460,10 +32526,10 @@
32460	32526	stack[base + 36LLU] = stack[base + 8]/fncanthrow/;
32461	32527	// set stack-base & callee-address
32462	32528	base += 27LLU;
32463		- label = 2253LLU; // initfrom
	32529	+ label = 2293LLU; // initfrom
32464	32530	break;
32465	32531	}
32466		- case 2662LLU: // copy-back deleter (initfrom to PROCRETURN)
	32532	+ case 2667LLU: // copy-back deleter (initfrom to PROCRETURN)
32467	32533	{
32468	32534	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (initfrom to PROCRETURN)\n");
32469	32535	// copy mutable arguments back from call to initfrom

		@@ -32470,10 +32536,10 @@
32470	32536	stack[base + 17]/label/ = stack[base + 35LLU];
32471	32537	stack[base + 14]/lookahead/ = stack[base + 34LLU];
32472	32538	stack[base + 3]/scope/ = stack[base + 33LLU];
32473		- label = 2661LLU; // continue to roll stack
	32539	+ label = 2666LLU; // continue to roll stack
32474	32540	break;
32475	32541	}
32476		- case 2663LLU: // return from initfrom to PROCRETURN
	32542	+ case 2668LLU: // return from initfrom to PROCRETURN
32477	32543	{
32478	32544	// copy mutable arguments back from call to initfrom
32479	32545	stack[base + 17]/label/ = stack[base + 35LLU];

		@@ -32481,15 +32547,15 @@
32481	32547	stack[base + 3]/scope/ = stack[base + 33LLU];
32482	32548	if(!stack[base + 19]/blkresults/)
32483	32549	{
32484		- label = 2664LLU; // jump to alternative
	32550	+ label = 2669LLU; // jump to alternative
32485	32551	break;
32486	32552	}
32487	32553
32488	32554	// consequent
32489	32555	// call matchsym from PROCRETURN
32490		- stack[base + 24LLU] = 2666LLU/throw to this address/;
	32556	+ stack[base + 24LLU] = 2671LLU/throw to this address/;
32491	32557	stack[base + 25LLU] = base;
32492		- stack[base + 26LLU] = 2667LLU;
	32558	+ stack[base + 26LLU] = 2672LLU;
32493	32559	// arguments for call to matchsym
32494	32560	stack[base + 27LLU] = stack[base + 9]/fnid/;
32495	32561	stack[base + 28LLU] = 44LLU;

		@@ -32499,63 +32565,63 @@
32499	32565	label = 212LLU; // matchsym
32500	32566	break;
32501	32567	}
32502		- case 2666LLU: // copy-back deleter (matchsym to PROCRETURN)
	32568	+ case 2671LLU: // copy-back deleter (matchsym to PROCRETURN)
32503	32569	{
32504	32570	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
32505	32571	// copy mutable arguments back from call to matchsym
32506	32572	stack[base + 14]/lookahead/ = stack[base + 29LLU];
32507		- label = 2661LLU; // continue to roll stack
	32573	+ label = 2666LLU; // continue to roll stack
32508	32574	break;
32509	32575	}
32510		- case 2667LLU: // return from matchsym to PROCRETURN
	32576	+ case 2672LLU: // return from matchsym to PROCRETURN
32511	32577	{
32512	32578	// copy mutable arguments back from call to matchsym
32513	32579	stack[base + 14]/lookahead/ = stack[base + 29LLU];
32514		- label = 2665LLU; // consequent complete
	32580	+ label = 2670LLU; // consequent complete
32515	32581	break;
32516	32582	}
32517		- case 2664LLU: // alternative
	32583	+ case 2669LLU: // alternative
32518	32584	{
32519		- label = 2665LLU; // alternative complete
	32585	+ label = 2670LLU; // alternative complete
32520	32586	break;
32521	32587	}
32522		- case 2665LLU: // completed if-then-else
	32588	+ case 2670LLU: // completed if-then-else
32523	32589	{
32524	32590	((uint64_t **)(stack[base + 20]))[1][1] = stack[base + 23];
32525	32591	((uint64_t **)(stack[base + 20]))[1][0] = stack[base + 22];
32526		- label = 2659LLU; // case complete
	32592	+ label = 2664LLU; // case complete
32527	32593	break;
32528	32594	}
32529		- case 2661LLU: // copy-back deleter (switch)
	32595	+ case 2666LLU: // copy-back deleter (switch)
32530	32596	{
32531	32597	((uint64_t **)(stack[base + 20]))[1][1] = stack[base + 23];
32532	32598	((uint64_t **)(stack[base + 20]))[1][0] = stack[base + 22];
32533		- label = 2658LLU; // continue to unroll stack
	32599	+ label = 2663LLU; // continue to unroll stack
32534	32600	break;
32535	32601	}
32536		- case 2660LLU: // try next case
	32602	+ case 2665LLU: // try next case
32537	32603	{
32538	32604	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
32539	32605	exit(-1);
32540	32606	}
32541		- case 2659LLU: // completed switch
	32607	+ case 2664LLU: // completed switch
32542	32608	{
32543	32609	((struct listnode )(stack[base + 21]/previous*/))->data = stack[base + 20];
32544		- label = 2656LLU; // repeat
	32610	+ label = 2661LLU; // repeat
32545	32611	break;
32546	32612	}
32547		- case 2658LLU: // copy-back deleter for while next
	32613	+ case 2663LLU: // copy-back deleter for while next
32548	32614	{
32549	32615	((struct listnode )(stack[base + 21]/previous*/))->data = stack[base + 20];
32550		- label = 2650LLU; // continue to unroll stack
	32616	+ label = 2655LLU; // continue to unroll stack
32551	32617	break;
32552	32618	}
32553		- case 2657LLU: // loop finished
	32619	+ case 2662LLU: // loop finished
32554	32620	{
32555	32621	// call matchsym from PROCRETURN
32556		- stack[base + 22LLU] = 2668LLU/throw to this address/;
	32622	+ stack[base + 22LLU] = 2673LLU/throw to this address/;
32557	32623	stack[base + 23LLU] = base;
32558		- stack[base + 24LLU] = 2669LLU;
	32624	+ stack[base + 24LLU] = 2674LLU;
32559	32625	// arguments for call to matchsym
32560	32626	stack[base + 25LLU] = stack[base + 9]/fnid/;
32561	32627	stack[base + 26LLU] = 41LLU;

		@@ -32565,45 +32631,45 @@
32565	32631	label = 212LLU; // matchsym
32566	32632	break;
32567	32633	}
32568		- case 2668LLU: // copy-back deleter (matchsym to PROCRETURN)
	32634	+ case 2673LLU: // copy-back deleter (matchsym to PROCRETURN)
32569	32635	{
32570	32636	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
32571	32637	// copy mutable arguments back from call to matchsym
32572	32638	stack[base + 14]/lookahead/ = stack[base + 27LLU];
32573		- label = 2650LLU; // continue to roll stack
	32639	+ label = 2655LLU; // continue to roll stack
32574	32640	break;
32575	32641	}
32576		- case 2669LLU: // return from matchsym to PROCRETURN
	32642	+ case 2674LLU: // return from matchsym to PROCRETURN
32577	32643	{
32578	32644	// copy mutable arguments back from call to matchsym
32579	32645	stack[base + 14]/lookahead/ = stack[base + 27LLU];
32580		- label = 2655LLU; // consequent complete
	32646	+ label = 2660LLU; // consequent complete
32581	32647	break;
32582	32648	}
32583		- case 2654LLU: // alternative
	32649	+ case 2659LLU: // alternative
32584	32650	{
32585		- label = 2671LLU; // skip deleter
	32651	+ label = 2676LLU; // skip deleter
32586	32652	break;
32587	32653	}
32588		- case 2670LLU: // deleter
	32654	+ case 2675LLU: // deleter
32589	32655	{
32590	32656	// throw from PROCRETURN
32591	32657	if(!stack[base + 19])
32592	32658	{
32593	32659	fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable [typeidx] dsttypeidx\n");
32594		- label = 2650LLU; // skip, variable already deleted/unscoped
	32660	+ label = 2655LLU; // skip, variable already deleted/unscoped
32595	32661	break;
32596	32662	}
32597	32663	fprintf(stderr, "in function PROCRETURN: unrolling stack, variable [typeidx] dsttypeidx\n");
32598	32664	// delete list
32599		- label = 2672LLU; // start to repeat
	32665	+ label = 2677LLU; // start to repeat
32600	32666	break;
32601	32667	}
32602		- case 2672LLU: // repeat from here
	32668	+ case 2677LLU: // repeat from here
32603	32669	{
32604	32670	if(!stack[base + 19])
32605	32671	{
32606		- label = 2673LLU; // break loop
	32672	+ label = 2678LLU; // break loop
32607	32673	break;
32608	32674	}
32609	32675

		@@ -32614,7 +32680,7 @@
32614	32680	newstack[0] = (uint64_t)stack; // backup stack location
32615	32681	newstack[1] = 1234567890;
32616	32682	newstack[2] = base;
32617		- newstack[3] = 2674LLU;
	32683	+ newstack[3] = 2679LLU;
32618	32684	stack = newstack;
32619	32685	// set stack-base & callee-address
32620	32686	base = 4/deloffset/;

		@@ -32621,7 +32687,7 @@
32621	32687	label = 379LLU; // ~typeidx
32622	32688	break;
32623	32689	}
32624		- case 2674LLU: // return from ~typeidx to PROCRETURN
	32690	+ case 2679LLU: // return from ~typeidx to PROCRETURN
32625	32691	{
32626	32692	stack = (uint64_t *)stack[0];
32627	32693	// releasing toplevel container

		@@ -32632,39 +32698,39 @@
32632	32698	stack[base + 19] = (uint64_t)list->next;
32633	32699	Free(1, sizeof(struct listnode), list);
32634	32700	}
32635		- label = 2672LLU; // repeat
	32701	+ label = 2677LLU; // repeat
32636	32702	break;
32637	32703	}
32638		- case 2673LLU: // loop finished
	32704	+ case 2678LLU: // loop finished
32639	32705	{
32640		- label = 2650LLU; // continue unrolling stack, delete next variable
	32706	+ label = 2655LLU; // continue unrolling stack, delete next variable
32641	32707	break;
32642	32708	}
32643		- case 2671LLU: // skipped deleter
	32709	+ case 2676LLU: // skipped deleter
32644	32710	{
32645	32711	stack[base + 19] = 0;
32646		- label = 2676LLU; // skip deleter
	32712	+ label = 2681LLU; // skip deleter
32647	32713	break;
32648	32714	}
32649		- case 2675LLU: // deleter
	32715	+ case 2680LLU: // deleter
32650	32716	{
32651	32717	// throw from PROCRETURN
32652	32718	if(!stack[base + 20])
32653	32719	{
32654	32720	fprintf(stderr, "in function PROCRETURN: unrolling stack, skipping already deleted/unscoped variable [typeidx] BLKRESULTS\n");
32655		- label = 2670LLU; // skip, variable already deleted/unscoped
	32721	+ label = 2675LLU; // skip, variable already deleted/unscoped
32656	32722	break;
32657	32723	}
32658	32724	fprintf(stderr, "in function PROCRETURN: unrolling stack, variable [typeidx] BLKRESULTS\n");
32659	32725	// delete list
32660		- label = 2677LLU; // start to repeat
	32726	+ label = 2682LLU; // start to repeat
32661	32727	break;
32662	32728	}
32663		- case 2677LLU: // repeat from here
	32729	+ case 2682LLU: // repeat from here
32664	32730	{
32665	32731	if(!stack[base + 20])
32666	32732	{
32667		- label = 2678LLU; // break loop
	32733	+ label = 2683LLU; // break loop
32668	32734	break;
32669	32735	}
32670	32736

		@@ -32675,7 +32741,7 @@
32675	32741	newstack[0] = (uint64_t)stack; // backup stack location
32676	32742	newstack[1] = 1234567890;
32677	32743	newstack[2] = base;
32678		- newstack[3] = 2679LLU;
	32744	+ newstack[3] = 2684LLU;
32679	32745	stack = newstack;
32680	32746	// set stack-base & callee-address
32681	32747	base = 4/deloffset/;

		@@ -32682,7 +32748,7 @@
32682	32748	label = 379LLU; // ~typeidx
32683	32749	break;
32684	32750	}
32685		- case 2679LLU: // return from ~typeidx to PROCRETURN
	32751	+ case 2684LLU: // return from ~typeidx to PROCRETURN
32686	32752	{
32687	32753	stack = (uint64_t *)stack[0];
32688	32754	// releasing toplevel container

		@@ -32693,26 +32759,26 @@
32693	32759	stack[base + 20] = (uint64_t)list->next;
32694	32760	Free(1, sizeof(struct listnode), list);
32695	32761	}
32696		- label = 2677LLU; // repeat
	32762	+ label = 2682LLU; // repeat
32697	32763	break;
32698	32764	}
32699		- case 2678LLU: // loop finished
	32765	+ case 2683LLU: // loop finished
32700	32766	{
32701		- label = 2670LLU; // continue unrolling stack, delete next variable
	32767	+ label = 2675LLU; // continue unrolling stack, delete next variable
32702	32768	break;
32703	32769	}
32704		- case 2676LLU: // skipped deleter
	32770	+ case 2681LLU: // skipped deleter
32705	32771	{
32706	32772	stack[base + 20] = 0;
32707	32773	flippedassign(stack[base + 4]/blkresults/, &stack[base + 21]);
32708		- label = 2680LLU; // start to repeat
	32774	+ label = 2685LLU; // start to repeat
32709	32775	break;
32710	32776	}
32711		- case 2680LLU: // repeat from here
	32777	+ case 2685LLU: // repeat from here
32712	32778	{
32713	32779	if(!stack[base + 21])
32714	32780	{
32715		- label = 2681LLU; // break loop
	32781	+ label = 2686LLU; // break loop
32716	32782	break;
32717	32783	}
32718	32784

		@@ -32721,9 +32787,9 @@
32721	32787	stack[base + 23]/previous/ = stack[base + 21];
32722	32788	stack[base + 21] = (uint64_t)(((const struct listnode *)(stack[base + 21]))->next);
32723	32789	// call cptypeidx from PROCRETURN
32724		- stack[base + 25LLU] = 2683LLU/throw to this address/;
	32790	+ stack[base + 25LLU] = 2688LLU/throw to this address/;
32725	32791	stack[base + 26LLU] = base;
32726		- stack[base + 27LLU] = 2684LLU;
	32792	+ stack[base + 27LLU] = 2689LLU;
32727	32793	// arguments for call to cptypeidx
32728	32794	stack[base + 29LLU] = stack[base + 22]/typeidx/;
32729	32795	// set stack-base & callee-address

		@@ -32731,14 +32797,14 @@
32731	32797	label = 382LLU; // cptypeidx
32732	32798	break;
32733	32799	}
32734		- case 2683LLU: // copy-back deleter (cptypeidx to PROCRETURN)
	32800	+ case 2688LLU: // copy-back deleter (cptypeidx to PROCRETURN)
32735	32801	{
32736	32802	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (cptypeidx to PROCRETURN)\n");
32737	32803	// copy mutable arguments back from call to cptypeidx
32738		- label = 2682LLU; // continue to roll stack
	32804	+ label = 2687LLU; // continue to roll stack
32739	32805	break;
32740	32806	}
32741		- case 2684LLU: // return from cptypeidx to PROCRETURN
	32807	+ case 2689LLU: // return from cptypeidx to PROCRETURN
32742	32808	{
32743	32809	// copy mutable arguments back from call to cptypeidx
32744	32810	// copy back results provided by call to cptypeidx

		@@ -32755,22 +32821,22 @@
32755	32821	MOVE(&list->data, &stack[base + 24]/copy/);
32756	32822	}
32757	32823	((struct listnode )(stack[base + 23]/previous*/))->data = stack[base + 22];
32758		- label = 2680LLU; // repeat
	32824	+ label = 2685LLU; // repeat
32759	32825	break;
32760	32826	}
32761		- case 2682LLU: // copy-back deleter for while next
	32827	+ case 2687LLU: // copy-back deleter for while next
32762	32828	{
32763	32829	((struct listnode )(stack[base + 23]/previous*/))->data = stack[base + 22];
32764		- label = 2675LLU; // continue to unroll stack
	32830	+ label = 2680LLU; // continue to unroll stack
32765	32831	break;
32766	32832	}
32767		- case 2681LLU: // loop finished
	32833	+ case 2686LLU: // loop finished
32768	32834	{
32769	32835	list_reverse(((struct listnode *)(&stack[base + 20]/BLKRESULTS*/)));
32770	32836	// call equ from PROCRETURN
32771		- stack[base + 24LLU] = 2685LLU/throw to this address/;
	32837	+ stack[base + 24LLU] = 2690LLU/throw to this address/;
32772	32838	stack[base + 25LLU] = base;
32773		- stack[base + 26LLU] = 2686LLU;
	32839	+ stack[base + 26LLU] = 2691LLU;
32774	32840	// arguments for call to equ
32775	32841	stack[base + 28LLU] = stack[base + 15]/variant/;
32776	32842	stack[base + 29LLU] = 4LLU;

		@@ -32779,14 +32845,14 @@
32779	32845	label = 18446744073709551600LLU; // equ
32780	32846	break;
32781	32847	}
32782		- case 2685LLU: // copy-back deleter (equ to PROCRETURN)
	32848	+ case 2690LLU: // copy-back deleter (equ to PROCRETURN)
32783	32849	{
32784	32850	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equ to PROCRETURN)\n");
32785	32851	// copy mutable arguments back from call to equ
32786		- label = 2675LLU; // continue to roll stack
	32852	+ label = 2680LLU; // continue to roll stack
32787	32853	break;
32788	32854	}
32789		- case 2686LLU: // return from equ to PROCRETURN
	32855	+ case 2691LLU: // return from equ to PROCRETURN
32790	32856	{
32791	32857	// copy mutable arguments back from call to equ
32792	32858	// copy back results provided by call to equ

		@@ -32793,21 +32859,21 @@
32793	32859	stack[base + 18] = stack[base + 27LLU];
32794	32860	if(!stack[base + 18]/isequal/)
32795	32861	{
32796		- label = 2687LLU; // jump to alternative
	32862	+ label = 2692LLU; // jump to alternative
32797	32863	break;
32798	32864	}
32799	32865
32800	32866	// consequent
32801		- label = 2688LLU; // consequent complete
	32867	+ label = 2693LLU; // consequent complete
32802	32868	break;
32803	32869	}
32804		- case 2687LLU: // alternative
	32870	+ case 2692LLU: // alternative
32805	32871	{
32806	32872	fprintf(stderr, "%s", "parsing function call expected identifier but found ");
32807	32873	// call reporttok from PROCRETURN
32808		- stack[base + 24LLU] = 2689LLU/throw to this address/;
	32874	+ stack[base + 24LLU] = 2694LLU/throw to this address/;
32809	32875	stack[base + 25LLU] = base;
32810		- stack[base + 26LLU] = 2690LLU;
	32876	+ stack[base + 26LLU] = 2695LLU;
32811	32877	// arguments for call to reporttok
32812	32878	stack[base + 27LLU] = stack[base + 15]/variant/;
32813	32879	stack[base + 28LLU] = stack[base + 16]/content/;

		@@ -32816,26 +32882,26 @@
32816	32882	label = 18446744073709551582LLU; // reporttok
32817	32883	break;
32818	32884	}
32819		- case 2689LLU: // copy-back deleter (reporttok to PROCRETURN)
	32885	+ case 2694LLU: // copy-back deleter (reporttok to PROCRETURN)
32820	32886	{
32821	32887	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttok to PROCRETURN)\n");
32822	32888	// copy mutable arguments back from call to reporttok
32823		- label = 2675LLU; // continue to roll stack
	32889	+ label = 2680LLU; // continue to roll stack
32824	32890	break;
32825	32891	}
32826		- case 2690LLU: // return from reporttok to PROCRETURN
	32892	+ case 2695LLU: // return from reporttok to PROCRETURN
32827	32893	{
32828	32894	// copy mutable arguments back from call to reporttok
32829	32895	exit(-1);
32830		- label = 2688LLU; // alternative complete
	32896	+ label = 2693LLU; // alternative complete
32831	32897	break;
32832	32898	}
32833		- case 2688LLU: // completed if-then-else
	32899	+ case 2693LLU: // completed if-then-else
32834	32900	{
32835	32901	// call FindFn from PROCRETURN
32836		- stack[base + 25LLU] = 2691LLU/throw to this address/;
	32902	+ stack[base + 25LLU] = 2696LLU/throw to this address/;
32837	32903	stack[base + 26LLU] = base;
32838		- stack[base + 27LLU] = 2692LLU;
	32904	+ stack[base + 27LLU] = 2697LLU;
32839	32905	// arguments for call to FindFn
32840	32906	stack[base + 29LLU] = stack[base + 9]/fnid/;
32841	32907	stack[base + 30LLU] = stack[base + 0]/fndefs/;

		@@ -32845,14 +32911,14 @@
32845	32911	label = 1411LLU; // FindFn
32846	32912	break;
32847	32913	}
32848		- case 2691LLU: // copy-back deleter (FindFn to PROCRETURN)
	32914	+ case 2696LLU: // copy-back deleter (FindFn to PROCRETURN)
32849	32915	{
32850	32916	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (FindFn to PROCRETURN)\n");
32851	32917	// copy mutable arguments back from call to FindFn
32852		- label = 2675LLU; // continue to roll stack
	32918	+ label = 2680LLU; // continue to roll stack
32853	32919	break;
32854	32920	}
32855		- case 2692LLU: // return from FindFn to PROCRETURN
	32921	+ case 2697LLU: // return from FindFn to PROCRETURN
32856	32922	{
32857	32923	// copy mutable arguments back from call to FindFn
32858	32924	// copy back results provided by call to FindFn

		@@ -32859,7 +32925,7 @@
32859	32925	stack[base + 24] = stack[base + 28LLU];
32860	32926	if(/fndef/0 != ((uint64_t )(stack[base + 24]/calleedef*/))[0])
32861	32927	{
32862		- label = 2694LLU; // jump to alternative
	32928	+ label = 2699LLU; // jump to alternative
32863	32929	break;
32864	32930	}
32865	32931

		@@ -32874,14 +32940,14 @@
32874	32940
32875	32941	// case
32876	32942	flippedassign(stack[base + 26]/cerestypes/, &stack[base + 33]);
32877		- label = 2696LLU; // start to repeat
	32943	+ label = 2701LLU; // start to repeat
32878	32944	break;
32879	32945	}
32880		- case 2696LLU: // repeat from here
	32946	+ case 2701LLU: // repeat from here
32881	32947	{
32882	32948	if(!stack[base + 33])
32883	32949	{
32884		- label = 2697LLU; // break loop
	32950	+ label = 2702LLU; // break loop
32885	32951	break;
32886	32952	}
32887	32953

		@@ -32893,7 +32959,7 @@
32893	32959	struct listnode list = (struct listnode )stack[base + 20]/BLKRESULTS/;
32894	32960	if(!list)
32895	32961	{
32896		- label = 2699LLU; // jump to alternative
	32962	+ label = 2704LLU; // jump to alternative
32897	32963	break;
32898	32964	}
32899	32965

		@@ -32905,7 +32971,7 @@
32905	32971	}
32906	32972	if(/typeidx/0 != ((uint64_t )(stack[base + 36]/typeidx*/))[0])
32907	32973	{
32908		- label = 2703LLU; // jump to alternative
	32974	+ label = 2708LLU; // jump to alternative
32909	32975	break;
32910	32976	}
32911	32977

		@@ -32915,7 +32981,7 @@
32915	32981	// case
32916	32982	if(/result/0 != ((uint64_t )(stack[base + 34]/result*/))[0])
32917	32983	{
32918		- label = 2706LLU; // jump to alternative
	32984	+ label = 2711LLU; // jump to alternative
32919	32985	break;
32920	32986	}
32921	32987

		@@ -32926,7 +32992,7 @@
32926	32992	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
32927	32993	if(!newstack)
32928	32994	{
32929		- label = 2707LLU; // throw: begin to unroll stack
	32995	+ label = 2712LLU; // throw: begin to unroll stack
32930	32996	break;
32931	32997	}
32932	32998

		@@ -32933,9 +32999,9 @@
32933	32999	newstack[15LLU] = 9876543210LLU; // overflow-marker
32934	33000	// call equtype from PROCRETURN
32935	33001	newstack[0] = (uint64_t)stack; // backup stack location
32936		- newstack[1] = 2708LLU;
	33002	+ newstack[1] = 2713LLU;
32937	33003	newstack[2] = base;
32938		- newstack[3] = 2709LLU;
	33004	+ newstack[3] = 2714LLU;
32939	33005	// arguments for call to equtype
32940	33006	newstack[5LLU] = stack[base + 37]/dsttype/;
32941	33007	newstack[6LLU] = stack[base + 39]/srctype/;

		@@ -32945,7 +33011,7 @@
32945	33011	label = 342LLU; // equtype
32946	33012	break;
32947	33013	}
32948		- case 2708LLU: // copy-back deleter (equtype to PROCRETURN)
	33014	+ case 2713LLU: // copy-back deleter (equtype to PROCRETURN)
32949	33015	{
32950	33016	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equtype to PROCRETURN)\n");
32951	33017	uint64_t oldstack = (uint64_t )stack[0];

		@@ -32957,10 +33023,10 @@
32957	33023	}
32958	33024	Free(15LLU + 1, sizeof(uint64_t), stack);
32959	33025	stack = oldstack;
32960		- label = 2707LLU; // continue to unroll stack
	33026	+ label = 2712LLU; // continue to unroll stack
32961	33027	break;
32962	33028	}
32963		- case 2709LLU: // return from equtype to PROCRETURN
	33029	+ case 2714LLU: // return from equtype to PROCRETURN
32964	33030	{
32965	33031	uint64_t oldstack = (uint64_t )stack[0];
32966	33032	// copy mutable arguments back from call to equtype

		@@ -32975,21 +33041,21 @@
32975	33041	stack = oldstack;
32976	33042	if(!stack[base + 18]/isequal/)
32977	33043	{
32978		- label = 2710LLU; // jump to alternative
	33044	+ label = 2715LLU; // jump to alternative
32979	33045	break;
32980	33046	}
32981	33047
32982	33048	// consequent
32983		- label = 2711LLU; // consequent complete
	33049	+ label = 2716LLU; // consequent complete
32984	33050	break;
32985	33051	}
32986		- case 2710LLU: // alternative
	33052	+ case 2715LLU: // alternative
32987	33053	{
32988	33054	fprintf(stderr, "%s", "in function ");
32989	33055	// call reportid from PROCRETURN
32990		- stack[base + 41LLU] = 2712LLU/throw to this address/;
	33056	+ stack[base + 41LLU] = 2717LLU/throw to this address/;
32991	33057	stack[base + 42LLU] = base;
32992		- stack[base + 43LLU] = 2713LLU;
	33058	+ stack[base + 43LLU] = 2718LLU;
32993	33059	// arguments for call to reportid
32994	33060	stack[base + 44LLU] = stack[base + 9]/fnid/;
32995	33061	// set stack-base & callee-address

		@@ -32997,21 +33063,21 @@
32997	33063	label = 18446744073709551586LLU; // reportid
32998	33064	break;
32999	33065	}
33000		- case 2712LLU: // copy-back deleter (reportid to PROCRETURN)
	33066	+ case 2717LLU: // copy-back deleter (reportid to PROCRETURN)
33001	33067	{
33002	33068	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
33003	33069	// copy mutable arguments back from call to reportid
33004		- label = 2707LLU; // continue to roll stack
	33070	+ label = 2712LLU; // continue to roll stack
33005	33071	break;
33006	33072	}
33007		- case 2713LLU: // return from reportid to PROCRETURN
	33073	+ case 2718LLU: // return from reportid to PROCRETURN
33008	33074	{
33009	33075	// copy mutable arguments back from call to reportid
33010	33076	fprintf(stderr, "%s", " call to ");
33011	33077	// call reportid from PROCRETURN
33012		- stack[base + 41LLU] = 2714LLU/throw to this address/;
	33078	+ stack[base + 41LLU] = 2719LLU/throw to this address/;
33013	33079	stack[base + 42LLU] = base;
33014		- stack[base + 43LLU] = 2715LLU;
	33080	+ stack[base + 43LLU] = 2720LLU;
33015	33081	// arguments for call to reportid
33016	33082	stack[base + 44LLU] = stack[base + 29]/ceid/;
33017	33083	// set stack-base & callee-address

		@@ -33019,14 +33085,14 @@
33019	33085	label = 18446744073709551586LLU; // reportid
33020	33086	break;
33021	33087	}
33022		- case 2714LLU: // copy-back deleter (reportid to PROCRETURN)
	33088	+ case 2719LLU: // copy-back deleter (reportid to PROCRETURN)
33023	33089	{
33024	33090	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
33025	33091	// copy mutable arguments back from call to reportid
33026		- label = 2707LLU; // continue to roll stack
	33092	+ label = 2712LLU; // continue to roll stack
33027	33093	break;
33028	33094	}
33029		- case 2715LLU: // return from reportid to PROCRETURN
	33095	+ case 2720LLU: // return from reportid to PROCRETURN
33030	33096	{
33031	33097	// copy mutable arguments back from call to reportid
33032	33098	fprintf(stderr, "%s", " can't return result of type ");

		@@ -33033,7 +33099,7 @@
33033	33099	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
33034	33100	if(!newstack)
33035	33101	{
33036		- label = 2707LLU; // throw: begin to unroll stack
	33102	+ label = 2712LLU; // throw: begin to unroll stack
33037	33103	break;
33038	33104	}
33039	33105

		@@ -33040,9 +33106,9 @@
33040	33106	newstack[10LLU] = 9876543210LLU; // overflow-marker
33041	33107	// call reporttype from PROCRETURN
33042	33108	newstack[0] = (uint64_t)stack; // backup stack location
33043		- newstack[1] = 2716LLU;
	33109	+ newstack[1] = 2721LLU;
33044	33110	newstack[2] = base;
33045		- newstack[3] = 2717LLU;
	33111	+ newstack[3] = 2722LLU;
33046	33112	// arguments for call to reporttype
33047	33113	newstack[4LLU] = stack[base + 39]/srctype/;
33048	33114	stack = newstack;

		@@ -33051,7 +33117,7 @@
33051	33117	label = 316LLU; // reporttype
33052	33118	break;
33053	33119	}
33054		- case 2716LLU: // copy-back deleter (reporttype to PROCRETURN)
	33120	+ case 2721LLU: // copy-back deleter (reporttype to PROCRETURN)
33055	33121	{
33056	33122	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttype to PROCRETURN)\n");
33057	33123	uint64_t oldstack = (uint64_t )stack[0];

		@@ -33063,10 +33129,10 @@
33063	33129	}
33064	33130	Free(10LLU + 1, sizeof(uint64_t), stack);
33065	33131	stack = oldstack;
33066		- label = 2707LLU; // continue to unroll stack
	33132	+ label = 2712LLU; // continue to unroll stack
33067	33133	break;
33068	33134	}
33069		- case 2717LLU: // return from reporttype to PROCRETURN
	33135	+ case 2722LLU: // return from reporttype to PROCRETURN
33070	33136	{
33071	33137	uint64_t oldstack = (uint64_t )stack[0];
33072	33138	// copy mutable arguments back from call to reporttype

		@@ -33081,7 +33147,7 @@
33081	33147	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
33082	33148	if(!newstack)
33083	33149	{
33084		- label = 2707LLU; // throw: begin to unroll stack
	33150	+ label = 2712LLU; // throw: begin to unroll stack
33085	33151	break;
33086	33152	}
33087	33153

		@@ -33088,9 +33154,9 @@
33088	33154	newstack[10LLU] = 9876543210LLU; // overflow-marker
33089	33155	// call reporttype from PROCRETURN
33090	33156	newstack[0] = (uint64_t)stack; // backup stack location
33091		- newstack[1] = 2718LLU;
	33157	+ newstack[1] = 2723LLU;
33092	33158	newstack[2] = base;
33093		- newstack[3] = 2719LLU;
	33159	+ newstack[3] = 2724LLU;
33094	33160	// arguments for call to reporttype
33095	33161	newstack[4LLU] = stack[base + 37]/dsttype/;
33096	33162	stack = newstack;

		@@ -33099,7 +33165,7 @@
33099	33165	label = 316LLU; // reporttype
33100	33166	break;
33101	33167	}
33102		- case 2718LLU: // copy-back deleter (reporttype to PROCRETURN)
	33168	+ case 2723LLU: // copy-back deleter (reporttype to PROCRETURN)
33103	33169	{
33104	33170	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reporttype to PROCRETURN)\n");
33105	33171	uint64_t oldstack = (uint64_t )stack[0];

		@@ -33111,10 +33177,10 @@
33111	33177	}
33112	33178	Free(10LLU + 1, sizeof(uint64_t), stack);
33113	33179	stack = oldstack;
33114		- label = 2707LLU; // continue to unroll stack
	33180	+ label = 2712LLU; // continue to unroll stack
33115	33181	break;
33116	33182	}
33117		- case 2719LLU: // return from reporttype to PROCRETURN
	33183	+ case 2724LLU: // return from reporttype to PROCRETURN
33118	33184	{
33119	33185	uint64_t oldstack = (uint64_t )stack[0];
33120	33186	// copy mutable arguments back from call to reporttype

		@@ -33127,53 +33193,53 @@
33127	33193	stack = oldstack;
33128	33194	fprintf(stderr, "%s", "\n");
33129	33195	exit(-1);
33130		- label = 2711LLU; // alternative complete
	33196	+ label = 2716LLU; // alternative complete
33131	33197	break;
33132	33198	}
33133		- case 2711LLU: // completed if-then-else
	33199	+ case 2716LLU: // completed if-then-else
33134	33200	{
33135	33201	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40];
33136	33202	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39];
33137		- label = 2705LLU; // case complete
	33203	+ label = 2710LLU; // case complete
33138	33204	break;
33139	33205	}
33140		- case 2707LLU: // copy-back deleter (switch)
	33206	+ case 2712LLU: // copy-back deleter (switch)
33141	33207	{
33142	33208	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 40];
33143	33209	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 39];
33144		- label = 2704LLU; // continue to unroll stack
	33210	+ label = 2709LLU; // continue to unroll stack
33145	33211	break;
33146	33212	}
33147		- case 2706LLU: // try next case
	33213	+ case 2711LLU: // try next case
33148	33214	{
33149	33215	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
33150	33216	exit(-1);
33151	33217	}
33152		- case 2705LLU: // completed switch
	33218	+ case 2710LLU: // completed switch
33153	33219	{
33154	33220	((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38];
33155	33221	((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37];
33156		- label = 2702LLU; // case complete
	33222	+ label = 2707LLU; // case complete
33157	33223	break;
33158	33224	}
33159		- case 2704LLU: // copy-back deleter (switch)
	33225	+ case 2709LLU: // copy-back deleter (switch)
33160	33226	{
33161	33227	((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 38];
33162	33228	((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 37];
33163		- label = 2701LLU; // continue to unroll stack
	33229	+ label = 2706LLU; // continue to unroll stack
33164	33230	break;
33165	33231	}
33166		- case 2703LLU: // try next case
	33232	+ case 2708LLU: // try next case
33167	33233	{
33168	33234	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
33169	33235	exit(-1);
33170	33236	}
33171		- case 2702LLU: // completed switch
	33237	+ case 2707LLU: // completed switch
33172	33238	{
33173	33239	// call cptypeidx from PROCRETURN
33174		- stack[base + 38LLU] = 2720LLU/throw to this address/;
	33240	+ stack[base + 38LLU] = 2725LLU/throw to this address/;
33175	33241	stack[base + 39LLU] = base;
33176		- stack[base + 40LLU] = 2721LLU;
	33242	+ stack[base + 40LLU] = 2726LLU;
33177	33243	// arguments for call to cptypeidx
33178	33244	stack[base + 42LLU] = stack[base + 36]/typeidx/;
33179	33245	// set stack-base & callee-address

		@@ -33181,14 +33247,14 @@
33181	33247	label = 382LLU; // cptypeidx
33182	33248	break;
33183	33249	}
33184		- case 2720LLU: // copy-back deleter (cptypeidx to PROCRETURN)
	33250	+ case 2725LLU: // copy-back deleter (cptypeidx to PROCRETURN)
33185	33251	{
33186	33252	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (cptypeidx to PROCRETURN)\n");
33187	33253	// copy mutable arguments back from call to cptypeidx
33188		- label = 2701LLU; // continue to roll stack
	33254	+ label = 2706LLU; // continue to roll stack
33189	33255	break;
33190	33256	}
33191		- case 2721LLU: // return from cptypeidx to PROCRETURN
	33257	+ case 2726LLU: // return from cptypeidx to PROCRETURN
33192	33258	{
33193	33259	// copy mutable arguments back from call to cptypeidx
33194	33260	// copy back results provided by call to cptypeidx

		@@ -33210,7 +33276,7 @@
33210	33276	newstack[0] = (uint64_t)stack; // backup stack location
33211	33277	newstack[1] = 1234567890;
33212	33278	newstack[2] = base;
33213		- newstack[3] = 2722LLU;
	33279	+ newstack[3] = 2727LLU;
33214	33280	stack = newstack;
33215	33281	// set stack-base & callee-address
33216	33282	base = 4/deloffset/;

		@@ -33217,16 +33283,16 @@
33217	33283	label = 379LLU; // ~typeidx
33218	33284	break;
33219	33285	}
33220		- case 2722LLU: // return from ~typeidx to PROCRETURN
	33286	+ case 2727LLU: // return from ~typeidx to PROCRETURN
33221	33287	{
33222	33288	stack = (uint64_t *)stack[0];
33223	33289	// releasing toplevel container
33224	33290	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
33225	33291
33226		- label = 2700LLU; // consequent complete
	33292	+ label = 2705LLU; // consequent complete
33227	33293	break;
33228	33294	}
33229		- case 2701LLU: // copy-back deleter (if pop)
	33295	+ case 2706LLU: // copy-back deleter (if pop)
33230	33296	{
33231	33297
33232	33298	uint64_t newstack = (uint64_t )(stack[base + 36] - sizeof(uint64_t) * 4);

		@@ -33234,7 +33300,7 @@
33234	33300	newstack[0] = (uint64_t)stack; // backup stack location
33235	33301	newstack[1] = 1234567890;
33236	33302	newstack[2] = base;
33237		- newstack[3] = 2723LLU;
	33303	+ newstack[3] = 2728LLU;
33238	33304	stack = newstack;
33239	33305	// set stack-base & callee-address
33240	33306	base = 4/deloffset/;

		@@ -33241,22 +33307,22 @@
33241	33307	label = 379LLU; // ~typeidx
33242	33308	break;
33243	33309	}
33244		- case 2723LLU: // return from ~typeidx to PROCRETURN
	33310	+ case 2728LLU: // return from ~typeidx to PROCRETURN
33245	33311	{
33246	33312	stack = (uint64_t *)stack[0];
33247	33313	// releasing toplevel container
33248	33314	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
33249	33315
33250		- label = 2698LLU; // consequent complete
	33316	+ label = 2703LLU; // consequent complete
33251	33317	break;
33252	33318	}
33253		- case 2699LLU: // alternative
	33319	+ case 2704LLU: // alternative
33254	33320	{
33255	33321	fprintf(stderr, "%s", "in function ");
33256	33322	// call reportid from PROCRETURN
33257		- stack[base + 37LLU] = 2724LLU/throw to this address/;
	33323	+ stack[base + 37LLU] = 2729LLU/throw to this address/;
33258	33324	stack[base + 38LLU] = base;
33259		- stack[base + 39LLU] = 2725LLU;
	33325	+ stack[base + 39LLU] = 2730LLU;
33260	33326	// arguments for call to reportid
33261	33327	stack[base + 40LLU] = stack[base + 9]/fnid/;
33262	33328	// set stack-base & callee-address

		@@ -33264,21 +33330,21 @@
33264	33330	label = 18446744073709551586LLU; // reportid
33265	33331	break;
33266	33332	}
33267		- case 2724LLU: // copy-back deleter (reportid to PROCRETURN)
	33333	+ case 2729LLU: // copy-back deleter (reportid to PROCRETURN)
33268	33334	{
33269	33335	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
33270	33336	// copy mutable arguments back from call to reportid
33271		- label = 2698LLU; // continue to roll stack
	33337	+ label = 2703LLU; // continue to roll stack
33272	33338	break;
33273	33339	}
33274		- case 2725LLU: // return from reportid to PROCRETURN
	33340	+ case 2730LLU: // return from reportid to PROCRETURN
33275	33341	{
33276	33342	// copy mutable arguments back from call to reportid
33277	33343	fprintf(stderr, "%s", " call to ");
33278	33344	// call reportid from PROCRETURN
33279		- stack[base + 37LLU] = 2726LLU/throw to this address/;
	33345	+ stack[base + 37LLU] = 2731LLU/throw to this address/;
33280	33346	stack[base + 38LLU] = base;
33281		- stack[base + 39LLU] = 2727LLU;
	33347	+ stack[base + 39LLU] = 2732LLU;
33282	33348	// arguments for call to reportid
33283	33349	stack[base + 40LLU] = stack[base + 29]/ceid/;
33284	33350	// set stack-base & callee-address

		@@ -33286,35 +33352,35 @@
33286	33352	label = 18446744073709551586LLU; // reportid
33287	33353	break;
33288	33354	}
33289		- case 2726LLU: // copy-back deleter (reportid to PROCRETURN)
	33355	+ case 2731LLU: // copy-back deleter (reportid to PROCRETURN)
33290	33356	{
33291	33357	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
33292	33358	// copy mutable arguments back from call to reportid
33293		- label = 2698LLU; // continue to roll stack
	33359	+ label = 2703LLU; // continue to roll stack
33294	33360	break;
33295	33361	}
33296		- case 2727LLU: // return from reportid to PROCRETURN
	33362	+ case 2732LLU: // return from reportid to PROCRETURN
33297	33363	{
33298	33364	// copy mutable arguments back from call to reportid
33299	33365	fprintf(stderr, "%s", " not enough destination-variables for results");
33300	33366	fprintf(stderr, "%s", "\n");
33301	33367	exit(-1);
33302		- label = 2700LLU; // alternative complete
	33368	+ label = 2705LLU; // alternative complete
33303	33369	break;
33304	33370	}
33305		- case 2700LLU: // completed if-then-else
	33371	+ case 2705LLU: // completed if-then-else
33306	33372	{
33307	33373	((struct listnode )(stack[base + 35]/previous*/))->data = stack[base + 34];
33308		- label = 2696LLU; // repeat
	33374	+ label = 2701LLU; // repeat
33309	33375	break;
33310	33376	}
33311		- case 2698LLU: // copy-back deleter for while next
	33377	+ case 2703LLU: // copy-back deleter for while next
33312	33378	{
33313	33379	((struct listnode )(stack[base + 35]/previous*/))->data = stack[base + 34];
33314		- label = 2695LLU; // continue to unroll stack
	33380	+ label = 2700LLU; // continue to unroll stack
33315	33381	break;
33316	33382	}
33317		- case 2697LLU: // loop finished
	33383	+ case 2702LLU: // loop finished
33318	33384	{
33319	33385	((uint64_t **)(stack[base + 24]))[1][7] = stack[base + 32];
33320	33386	((uint64_t **)(stack[base + 24]))[1][6] = stack[base + 31];

		@@ -33324,10 +33390,10 @@
33324	33390	((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
33325	33391	((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
33326	33392	((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
33327		- label = 2693LLU; // case complete
	33393	+ label = 2698LLU; // case complete
33328	33394	break;
33329	33395	}
33330		- case 2695LLU: // copy-back deleter (switch)
	33396	+ case 2700LLU: // copy-back deleter (switch)
33331	33397	{
33332	33398	((uint64_t **)(stack[base + 24]))[1][7] = stack[base + 32];
33333	33399	((uint64_t **)(stack[base + 24]))[1][6] = stack[base + 31];

		@@ -33337,21 +33403,21 @@
33337	33403	((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
33338	33404	((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
33339	33405	((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
33340		- label = 2675LLU; // continue to unroll stack
	33406	+ label = 2680LLU; // continue to unroll stack
33341	33407	break;
33342	33408	}
33343		- case 2694LLU: // try next case
	33409	+ case 2699LLU: // try next case
33344	33410	{
33345	33411	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
33346	33412	exit(-1);
33347	33413	}
33348		- case 2693LLU: // completed switch
	33414	+ case 2698LLU: // completed switch
33349	33415	{
33350	33416	list_reverse(((struct listnode *)(&stack[base + 19]/dsttypeidx*/)));
33351	33417	// call matchsym from PROCRETURN
33352		- stack[base + 25LLU] = 2728LLU/throw to this address/;
	33418	+ stack[base + 25LLU] = 2733LLU/throw to this address/;
33353	33419	stack[base + 26LLU] = base;
33354		- stack[base + 27LLU] = 2729LLU;
	33420	+ stack[base + 27LLU] = 2734LLU;
33355	33421	// arguments for call to matchsym
33356	33422	stack[base + 28LLU] = stack[base + 9]/fnid/;
33357	33423	stack[base + 29LLU] = 40LLU;

		@@ -33361,22 +33427,22 @@
33361	33427	label = 212LLU; // matchsym
33362	33428	break;
33363	33429	}
33364		- case 2728LLU: // copy-back deleter (matchsym to PROCRETURN)
	33430	+ case 2733LLU: // copy-back deleter (matchsym to PROCRETURN)
33365	33431	{
33366	33432	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
33367	33433	// copy mutable arguments back from call to matchsym
33368	33434	stack[base + 14]/lookahead/ = stack[base + 30LLU];
33369		- label = 2675LLU; // continue to roll stack
	33435	+ label = 2680LLU; // continue to roll stack
33370	33436	break;
33371	33437	}
33372		- case 2729LLU: // return from matchsym to PROCRETURN
	33438	+ case 2734LLU: // return from matchsym to PROCRETURN
33373	33439	{
33374	33440	// copy mutable arguments back from call to matchsym
33375	33441	stack[base + 14]/lookahead/ = stack[base + 30LLU];
33376	33442	// call ProcCall from PROCRETURN
33377		- stack[base + 25LLU] = 2730LLU/throw to this address/;
	33443	+ stack[base + 25LLU] = 2735LLU/throw to this address/;
33378	33444	stack[base + 26LLU] = base;
33379		- stack[base + 27LLU] = 2731LLU;
	33445	+ stack[base + 27LLU] = 2736LLU;
33380	33446	// arguments for call to ProcCall
33381	33447	stack[base + 28LLU] = stack[base + 19]/dsttypeidx/;
33382	33448	stack[base + 29LLU] = stack[base + 0]/fndefs/;

		@@ -33401,7 +33467,7 @@
33401	33467	label = 1566LLU; // ProcCall
33402	33468	break;
33403	33469	}
33404		- case 2730LLU: // copy-back deleter (ProcCall to PROCRETURN)
	33470	+ case 2735LLU: // copy-back deleter (ProcCall to PROCRETURN)
33405	33471	{
33406	33472	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (ProcCall to PROCRETURN)\n");
33407	33473	// copy mutable arguments back from call to ProcCall

		@@ -33411,10 +33477,10 @@
33411	33477	stack[base + 14]/lookahead/ = stack[base + 42LLU];
33412	33478	stack[base + 13]/fnmaxcount/ = stack[base + 40LLU];
33413	33479	stack[base + 19]/dsttypeidx/ = stack[base + 28LLU];
33414		- label = 2675LLU; // continue to roll stack
	33480	+ label = 2680LLU; // continue to roll stack
33415	33481	break;
33416	33482	}
33417		- case 2731LLU: // return from ProcCall to PROCRETURN
	33483	+ case 2736LLU: // return from ProcCall to PROCRETURN
33418	33484	{
33419	33485	// copy mutable arguments back from call to ProcCall
33420	33486	stack[base + 17]/label/ = stack[base + 45LLU];

		@@ -33424,9 +33490,9 @@
33424	33490	stack[base + 13]/fnmaxcount/ = stack[base + 40LLU];
33425	33491	stack[base + 19]/dsttypeidx/ = stack[base + 28LLU];
33426	33492	// call matchsym from PROCRETURN
33427		- stack[base + 25LLU] = 2732LLU/throw to this address/;
	33493	+ stack[base + 25LLU] = 2737LLU/throw to this address/;
33428	33494	stack[base + 26LLU] = base;
33429		- stack[base + 27LLU] = 2733LLU;
	33495	+ stack[base + 27LLU] = 2738LLU;
33430	33496	// arguments for call to matchsym
33431	33497	stack[base + 28LLU] = stack[base + 9]/fnid/;
33432	33498	stack[base + 29LLU] = 41LLU;

		@@ -33436,22 +33502,22 @@
33436	33502	label = 212LLU; // matchsym
33437	33503	break;
33438	33504	}
33439		- case 2732LLU: // copy-back deleter (matchsym to PROCRETURN)
	33505	+ case 2737LLU: // copy-back deleter (matchsym to PROCRETURN)
33440	33506	{
33441	33507	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (matchsym to PROCRETURN)\n");
33442	33508	// copy mutable arguments back from call to matchsym
33443	33509	stack[base + 14]/lookahead/ = stack[base + 30LLU];
33444		- label = 2675LLU; // continue to roll stack
	33510	+ label = 2680LLU; // continue to roll stack
33445	33511	break;
33446	33512	}
33447		- case 2733LLU: // return from matchsym to PROCRETURN
	33513	+ case 2738LLU: // return from matchsym to PROCRETURN
33448	33514	{
33449	33515	// copy mutable arguments back from call to matchsym
33450	33516	stack[base + 14]/lookahead/ = stack[base + 30LLU];
33451	33517	// call skipwscmnt from PROCRETURN
33452		- stack[base + 25LLU] = 2734LLU/throw to this address/;
	33518	+ stack[base + 25LLU] = 2739LLU/throw to this address/;
33453	33519	stack[base + 26LLU] = base;
33454		- stack[base + 27LLU] = 2735LLU;
	33520	+ stack[base + 27LLU] = 2740LLU;
33455	33521	// arguments for call to skipwscmnt
33456	33522	stack[base + 29LLU] = stack[base + 14]/lookahead/;
33457	33523	// set stack-base & callee-address

		@@ -33459,22 +33525,22 @@
33459	33525	label = 18446744073709551580LLU; // skipwscmnt
33460	33526	break;
33461	33527	}
33462		- case 2734LLU: // copy-back deleter (skipwscmnt to PROCRETURN)
	33528	+ case 2739LLU: // copy-back deleter (skipwscmnt to PROCRETURN)
33463	33529	{
33464	33530	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (skipwscmnt to PROCRETURN)\n");
33465	33531	// copy mutable arguments back from call to skipwscmnt
33466		- label = 2675LLU; // continue to roll stack
	33532	+ label = 2680LLU; // continue to roll stack
33467	33533	break;
33468	33534	}
33469		- case 2735LLU: // return from skipwscmnt to PROCRETURN
	33535	+ case 2740LLU: // return from skipwscmnt to PROCRETURN
33470	33536	{
33471	33537	// copy mutable arguments back from call to skipwscmnt
33472	33538	// copy back results provided by call to skipwscmnt
33473	33539	stack[base + 14] = stack[base + 28LLU];
33474	33540	// call equ from PROCRETURN
33475		- stack[base + 25LLU] = 2736LLU/throw to this address/;
	33541	+ stack[base + 25LLU] = 2741LLU/throw to this address/;
33476	33542	stack[base + 26LLU] = base;
33477		- stack[base + 27LLU] = 2737LLU;
	33543	+ stack[base + 27LLU] = 2742LLU;
33478	33544	// arguments for call to equ
33479	33545	stack[base + 29LLU] = stack[base + 14]/lookahead/;
33480	33546	stack[base + 30LLU] = 125LLU;

		@@ -33483,14 +33549,14 @@
33483	33549	label = 18446744073709551600LLU; // equ
33484	33550	break;
33485	33551	}
33486		- case 2736LLU: // copy-back deleter (equ to PROCRETURN)
	33552	+ case 2741LLU: // copy-back deleter (equ to PROCRETURN)
33487	33553	{
33488	33554	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (equ to PROCRETURN)\n");
33489	33555	// copy mutable arguments back from call to equ
33490		- label = 2675LLU; // continue to roll stack
	33556	+ label = 2680LLU; // continue to roll stack
33491	33557	break;
33492	33558	}
33493		- case 2737LLU: // return from equ to PROCRETURN
	33559	+ case 2742LLU: // return from equ to PROCRETURN
33494	33560	{
33495	33561	// copy mutable arguments back from call to equ
33496	33562	// copy back results provided by call to equ

		@@ -33497,21 +33563,21 @@
33497	33563	stack[base + 18] = stack[base + 28LLU];
33498	33564	if(!stack[base + 18]/isequal/)
33499	33565	{
33500		- label = 2738LLU; // jump to alternative
	33566	+ label = 2743LLU; // jump to alternative
33501	33567	break;
33502	33568	}
33503	33569
33504	33570	// consequent
33505		- label = 2739LLU; // consequent complete
	33571	+ label = 2744LLU; // consequent complete
33506	33572	break;
33507	33573	}
33508		- case 2738LLU: // alternative
	33574	+ case 2743LLU: // alternative
33509	33575	{
33510	33576	fprintf(stderr, "%s", "in function ");
33511	33577	// call reportid from PROCRETURN
33512		- stack[base + 25LLU] = 2740LLU/throw to this address/;
	33578	+ stack[base + 25LLU] = 2745LLU/throw to this address/;
33513	33579	stack[base + 26LLU] = base;
33514		- stack[base + 27LLU] = 2741LLU;
	33580	+ stack[base + 27LLU] = 2746LLU;
33515	33581	// arguments for call to reportid
33516	33582	stack[base + 28LLU] = stack[base + 9]/fnid/;
33517	33583	// set stack-base & callee-address

		@@ -33519,21 +33585,21 @@
33519	33585	label = 18446744073709551586LLU; // reportid
33520	33586	break;
33521	33587	}
33522		- case 2740LLU: // copy-back deleter (reportid to PROCRETURN)
	33588	+ case 2745LLU: // copy-back deleter (reportid to PROCRETURN)
33523	33589	{
33524	33590	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportid to PROCRETURN)\n");
33525	33591	// copy mutable arguments back from call to reportid
33526		- label = 2675LLU; // continue to roll stack
	33592	+ label = 2680LLU; // continue to roll stack
33527	33593	break;
33528	33594	}
33529		- case 2741LLU: // return from reportid to PROCRETURN
	33595	+ case 2746LLU: // return from reportid to PROCRETURN
33530	33596	{
33531	33597	// copy mutable arguments back from call to reportid
33532	33598	fprintf(stderr, "%s", ": return must be last statement in function - expected '}' but found '");
33533	33599	// call reportbyte from PROCRETURN
33534		- stack[base + 25LLU] = 2742LLU/throw to this address/;
	33600	+ stack[base + 25LLU] = 2747LLU/throw to this address/;
33535	33601	stack[base + 26LLU] = base;
33536		- stack[base + 27LLU] = 2743LLU;
	33602	+ stack[base + 27LLU] = 2748LLU;
33537	33603	// arguments for call to reportbyte
33538	33604	stack[base + 28LLU] = stack[base + 14]/lookahead/;
33539	33605	// set stack-base & callee-address

		@@ -33541,22 +33607,22 @@
33541	33607	label = 18446744073709551591LLU; // reportbyte
33542	33608	break;
33543	33609	}
33544		- case 2742LLU: // copy-back deleter (reportbyte to PROCRETURN)
	33610	+ case 2747LLU: // copy-back deleter (reportbyte to PROCRETURN)
33545	33611	{
33546	33612	fprintf(stderr, "in function PROCRETURN: unrolling stack, copy-back (reportbyte to PROCRETURN)\n");
33547	33613	// copy mutable arguments back from call to reportbyte
33548		- label = 2675LLU; // continue to roll stack
	33614	+ label = 2680LLU; // continue to roll stack
33549	33615	break;
33550	33616	}
33551		- case 2743LLU: // return from reportbyte to PROCRETURN
	33617	+ case 2748LLU: // return from reportbyte to PROCRETURN
33552	33618	{
33553	33619	// copy mutable arguments back from call to reportbyte
33554	33620	fprintf(stderr, "%s", "'\n");
33555	33621	exit(-1);
33556		- label = 2739LLU; // alternative complete
	33622	+ label = 2744LLU; // alternative complete
33557	33623	break;
33558	33624	}
33559		- case 2739LLU: // completed if-then-else
	33625	+ case 2744LLU: // completed if-then-else
33560	33626	{
33561	33627
33562	33628	uint64_t newstack = (uint64_t )(stack[base + 24] - sizeof(uint64_t) * 4);

		@@ -33564,7 +33630,7 @@
33564	33630	newstack[0] = (uint64_t)stack; // backup stack location
33565	33631	newstack[1] = 1234567890;
33566	33632	newstack[2] = base;
33567		- newstack[3] = 2744LLU;
	33633	+ newstack[3] = 2749LLU;
33568	33634	stack = newstack;
33569	33635	// set stack-base & callee-address
33570	33636	base = 4/deloffset/;

		@@ -33571,7 +33637,7 @@
33571	33637	label = 1336LLU; // ~fndef
33572	33638	break;
33573	33639	}
33574		- case 2744LLU: // return from ~fndef to PROCRETURN
	33640	+ case 2749LLU: // return from ~fndef to PROCRETURN
33575	33641	{
33576	33642	stack = (uint64_t *)stack[0];
33577	33643	// releasing toplevel container

		@@ -33578,14 +33644,14 @@
33578	33644	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 24] - sizeof(uint64_t) 4));
33579	33645
33580	33646	// delete list
33581		- label = 2745LLU; // start to repeat
	33647	+ label = 2750LLU; // start to repeat
33582	33648	break;
33583	33649	}
33584		- case 2745LLU: // repeat from here
	33650	+ case 2750LLU: // repeat from here
33585	33651	{
33586	33652	if(!stack[base + 20])
33587	33653	{
33588		- label = 2746LLU; // break loop
	33654	+ label = 2751LLU; // break loop
33589	33655	break;
33590	33656	}
33591	33657

		@@ -33596,7 +33662,7 @@
33596	33662	newstack[0] = (uint64_t)stack; // backup stack location
33597	33663	newstack[1] = 1234567890;
33598	33664	newstack[2] = base;
33599		- newstack[3] = 2747LLU;
	33665	+ newstack[3] = 2752LLU;
33600	33666	stack = newstack;
33601	33667	// set stack-base & callee-address
33602	33668	base = 4/deloffset/;

		@@ -33603,7 +33669,7 @@
33603	33669	label = 379LLU; // ~typeidx
33604	33670	break;
33605	33671	}
33606		- case 2747LLU: // return from ~typeidx to PROCRETURN
	33672	+ case 2752LLU: // return from ~typeidx to PROCRETURN
33607	33673	{
33608	33674	stack = (uint64_t *)stack[0];
33609	33675	// releasing toplevel container

		@@ -33614,20 +33680,20 @@
33614	33680	stack[base + 20] = (uint64_t)list->next;
33615	33681	Free(1, sizeof(struct listnode), list);
33616	33682	}
33617		- label = 2745LLU; // repeat
	33683	+ label = 2750LLU; // repeat
33618	33684	break;
33619	33685	}
33620		- case 2746LLU: // loop finished
	33686	+ case 2751LLU: // loop finished
33621	33687	{
33622	33688	// delete list
33623		- label = 2748LLU; // start to repeat
	33689	+ label = 2753LLU; // start to repeat
33624	33690	break;
33625	33691	}
33626		- case 2748LLU: // repeat from here
	33692	+ case 2753LLU: // repeat from here
33627	33693	{
33628	33694	if(!stack[base + 19])
33629	33695	{
33630		- label = 2749LLU; // break loop
	33696	+ label = 2754LLU; // break loop
33631	33697	break;
33632	33698	}
33633	33699

		@@ -33638,7 +33704,7 @@
33638	33704	newstack[0] = (uint64_t)stack; // backup stack location
33639	33705	newstack[1] = 1234567890;
33640	33706	newstack[2] = base;
33641		- newstack[3] = 2750LLU;
	33707	+ newstack[3] = 2755LLU;
33642	33708	stack = newstack;
33643	33709	// set stack-base & callee-address
33644	33710	base = 4/deloffset/;

		@@ -33645,7 +33711,7 @@
33645	33711	label = 379LLU; // ~typeidx
33646	33712	break;
33647	33713	}
33648		- case 2750LLU: // return from ~typeidx to PROCRETURN
	33714	+ case 2755LLU: // return from ~typeidx to PROCRETURN
33649	33715	{
33650	33716	stack = (uint64_t *)stack[0];
33651	33717	// releasing toplevel container

		@@ -33656,15 +33722,15 @@
33656	33722	stack[base + 19] = (uint64_t)list->next;
33657	33723	Free(1, sizeof(struct listnode), list);
33658	33724	}
33659		- label = 2748LLU; // repeat
	33725	+ label = 2753LLU; // repeat
33660	33726	break;
33661	33727	}
33662		- case 2749LLU: // loop finished
	33728	+ case 2754LLU: // loop finished
33663	33729	{
33664		- label = 2655LLU; // alternative complete
	33730	+ label = 2660LLU; // alternative complete
33665	33731	break;
33666	33732	}
33667		- case 2655LLU: // completed if-then-else
	33733	+ case 2660LLU: // completed if-then-else
33668	33734	{
33669	33735	// return from PROCRETURN
33670	33736	label = stack[base - 1];

		@@ -33671,7 +33737,7 @@
33671	33737	base = stack[base - 2];
33672	33738	break;
33673	33739	}
33674		- case 2752LLU: // function PROCCALL failed
	33740	+ case 2757LLU: // function PROCCALL failed
33675	33741	{
33676	33742	fprintf(stderr, "function PROCCALL failed\n");
33677	33743	label = stack[base - 3];

		@@ -33678,7 +33744,7 @@
33678	33744	base = stack[base - 2];
33679	33745	break;
33680	33746	}
33681		- case 2751LLU: // PROCCALL
	33747	+ case 2756LLU: // PROCCALL
33682	33748	{
33683	33749	//#define arg0 0
33684	33750	//#define arg1 1

		@@ -33696,28 +33762,28 @@
33696	33762	//#define arg13 13
33697	33763	//#define arg14 14
33698	33764	//#define arg15 15
33699		- label = 2754LLU; // skip deleter
	33765	+ label = 2759LLU; // skip deleter
33700	33766	break;
33701	33767	}
33702		- case 2753LLU: // deleter
	33768	+ case 2758LLU: // deleter
33703	33769	{
33704	33770	// throw from PROCCALL
33705	33771	if(!stack[base + 16])
33706	33772	{
33707	33773	fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable [typeidx] dsttypeidx\n");
33708		- label = 2752LLU; // skip, variable already deleted/unscoped
	33774	+ label = 2757LLU; // skip, variable already deleted/unscoped
33709	33775	break;
33710	33776	}
33711	33777	fprintf(stderr, "in function PROCCALL: unrolling stack, variable [typeidx] dsttypeidx\n");
33712	33778	// delete list
33713		- label = 2755LLU; // start to repeat
	33779	+ label = 2760LLU; // start to repeat
33714	33780	break;
33715	33781	}
33716		- case 2755LLU: // repeat from here
	33782	+ case 2760LLU: // repeat from here
33717	33783	{
33718	33784	if(!stack[base + 16])
33719	33785	{
33720		- label = 2756LLU; // break loop
	33786	+ label = 2761LLU; // break loop
33721	33787	break;
33722	33788	}
33723	33789

		@@ -33728,7 +33794,7 @@
33728	33794	newstack[0] = (uint64_t)stack; // backup stack location
33729	33795	newstack[1] = 1234567890;
33730	33796	newstack[2] = base;
33731		- newstack[3] = 2757LLU;
	33797	+ newstack[3] = 2762LLU;
33732	33798	stack = newstack;
33733	33799	// set stack-base & callee-address
33734	33800	base = 4/deloffset/;

		@@ -33735,7 +33801,7 @@
33735	33801	label = 379LLU; // ~typeidx
33736	33802	break;
33737	33803	}
33738		- case 2757LLU: // return from ~typeidx to PROCCALL
	33804	+ case 2762LLU: // return from ~typeidx to PROCCALL
33739	33805	{
33740	33806	stack = (uint64_t *)stack[0];
33741	33807	// releasing toplevel container

		@@ -33746,39 +33812,39 @@
33746	33812	stack[base + 16] = (uint64_t)list->next;
33747	33813	Free(1, sizeof(struct listnode), list);
33748	33814	}
33749		- label = 2755LLU; // repeat
	33815	+ label = 2760LLU; // repeat
33750	33816	break;
33751	33817	}
33752		- case 2756LLU: // loop finished
	33818	+ case 2761LLU: // loop finished
33753	33819	{
33754		- label = 2752LLU; // continue unrolling stack, delete next variable
	33820	+ label = 2757LLU; // continue unrolling stack, delete next variable
33755	33821	break;
33756	33822	}
33757		- case 2754LLU: // skipped deleter
	33823	+ case 2759LLU: // skipped deleter
33758	33824	{
33759	33825	stack[base + 16] = 0;
33760		- label = 2759LLU; // skip deleter
	33826	+ label = 2764LLU; // skip deleter
33761	33827	break;
33762	33828	}
33763		- case 2758LLU: // deleter
	33829	+ case 2763LLU: // deleter
33764	33830	{
33765	33831	// throw from PROCCALL
33766	33832	if(!stack[base + 17])
33767	33833	{
33768	33834	fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable [letdef] results\n");
33769		- label = 2753LLU; // skip, variable already deleted/unscoped
	33835	+ label = 2758LLU; // skip, variable already deleted/unscoped
33770	33836	break;
33771	33837	}
33772	33838	fprintf(stderr, "in function PROCCALL: unrolling stack, variable [letdef] results\n");
33773	33839	// delete list
33774		- label = 2760LLU; // start to repeat
	33840	+ label = 2765LLU; // start to repeat
33775	33841	break;
33776	33842	}
33777		- case 2760LLU: // repeat from here
	33843	+ case 2765LLU: // repeat from here
33778	33844	{
33779	33845	if(!stack[base + 17])
33780	33846	{
33781		- label = 2761LLU; // break loop
	33847	+ label = 2766LLU; // break loop
33782	33848	break;
33783	33849	}
33784	33850

		@@ -33789,7 +33855,7 @@
33789	33855	newstack[0] = (uint64_t)stack; // backup stack location
33790	33856	newstack[1] = 1234567890;
33791	33857	newstack[2] = base;
33792		- newstack[3] = 2762LLU;
	33858	+ newstack[3] = 2767LLU;
33793	33859	stack = newstack;
33794	33860	// set stack-base & callee-address
33795	33861	base = 4/deloffset/;

		@@ -33796,7 +33862,7 @@
33796	33862	label = 457LLU; // ~letdef
33797	33863	break;
33798	33864	}
33799		- case 2762LLU: // return from ~letdef to PROCCALL
	33865	+ case 2767LLU: // return from ~letdef to PROCCALL
33800	33866	{
33801	33867	stack = (uint64_t *)stack[0];
33802	33868	// releasing toplevel container

		@@ -33807,40 +33873,40 @@
33807	33873	stack[base + 17] = (uint64_t)list->next;
33808	33874	Free(1, sizeof(struct listnode), list);
33809	33875	}
33810		- label = 2760LLU; // repeat
	33876	+ label = 2765LLU; // repeat
33811	33877	break;
33812	33878	}
33813		- case 2761LLU: // loop finished
	33879	+ case 2766LLU: // loop finished
33814	33880	{
33815		- label = 2753LLU; // continue unrolling stack, delete next variable
	33881	+ label = 2758LLU; // continue unrolling stack, delete next variable
33816	33882	break;
33817	33883	}
33818		- case 2759LLU: // skipped deleter
	33884	+ case 2764LLU: // skipped deleter
33819	33885	{
33820	33886	stack[base + 17] = 0;
33821		- label = 2764LLU; // skip deleter
	33887	+ label = 2769LLU; // skip deleter
33822	33888	break;
33823	33889	}
33824		- case 2763LLU: // deleter
	33890	+ case 2768LLU: // deleter
33825	33891	{
33826	33892	// throw from PROCCALL
33827	33893	if(!stack[base + 18])
33828	33894	{
33829	33895	fprintf(stderr, "in function PROCCALL: unrolling stack, skipping already deleted/unscoped variable u64 isequal\n");
33830		- label = 2758LLU; // skip, variable already deleted/unscoped
	33896	+ label = 2763LLU; // skip, variable already deleted/unscoped
33831	33897	break;
33832	33898	}
33833	33899	fprintf(stderr, "in function PROCCALL: unrolling stack, variable u64 isequal\n");
33834		- label = 2758LLU; // continue unrolling stack, delete next variable
	33900	+ label = 2763LLU; // continue unrolling stack, delete next variable
33835	33901	break;
33836	33902	}
33837		- case 2764LLU: // skipped deleter
	33903	+ case 2769LLU: // skipped deleter
33838	33904	{
33839	33905	stack[base + 18] = 0;
33840	33906	// call equ from PROCCALL
33841		- stack[base + 19LLU] = 2765LLU/throw to this address/;
	33907	+ stack[base + 19LLU] = 2770LLU/throw to this address/;
33842	33908	stack[base + 20LLU] = base;
33843		- stack[base + 21LLU] = 2766LLU;
	33909	+ stack[base + 21LLU] = 2771LLU;
33844	33910	// arguments for call to equ
33845	33911	stack[base + 23LLU] = 40LLU;
33846	33912	stack[base + 24LLU] = stack[base + 14]/content/;

		@@ -33849,14 +33915,14 @@
33849	33915	label = 18446744073709551600LLU; // equ
33850	33916	break;
33851	33917	}
33852		- case 2765LLU: // copy-back deleter (equ to PROCCALL)
	33918	+ case 2770LLU: // copy-back deleter (equ to PROCCALL)
33853	33919	{
33854	33920	fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (equ to PROCCALL)\n");
33855	33921	// copy mutable arguments back from call to equ
33856		- label = 2763LLU; // continue to roll stack
	33922	+ label = 2768LLU; // continue to roll stack
33857	33923	break;
33858	33924	}
33859		- case 2766LLU: // return from equ to PROCCALL
	33925	+ case 2771LLU: // return from equ to PROCCALL
33860	33926	{
33861	33927	// copy mutable arguments back from call to equ
33862	33928	// copy back results provided by call to equ

		@@ -33863,21 +33929,21 @@
33863	33929	stack[base + 18] = stack[base + 22LLU];
33864	33930	if(!stack[base + 18]/isequal/)
33865	33931	{
33866		- label = 2767LLU; // jump to alternative
	33932	+ label = 2772LLU; // jump to alternative
33867	33933	break;
33868	33934	}
33869	33935
33870	33936	// consequent
33871		- label = 2768LLU; // consequent complete
	33937	+ label = 2773LLU; // consequent complete
33872	33938	break;
33873	33939	}
33874		- case 2767LLU: // alternative
	33940	+ case 2772LLU: // alternative
33875	33941	{
33876	33942	fprintf(stderr, "%s", "expected '(' but found token ");
33877	33943	// call reporttok from PROCCALL
33878		- stack[base + 19LLU] = 2769LLU/throw to this address/;
	33944	+ stack[base + 19LLU] = 2774LLU/throw to this address/;
33879	33945	stack[base + 20LLU] = base;
33880		- stack[base + 21LLU] = 2770LLU;
	33946	+ stack[base + 21LLU] = 2775LLU;
33881	33947	// arguments for call to reporttok
33882	33948	stack[base + 22LLU] = stack[base + 13]/variant/;
33883	33949	stack[base + 23LLU] = stack[base + 14]/content/;

		@@ -33886,27 +33952,27 @@
33886	33952	label = 18446744073709551582LLU; // reporttok
33887	33953	break;
33888	33954	}
33889		- case 2769LLU: // copy-back deleter (reporttok to PROCCALL)
	33955	+ case 2774LLU: // copy-back deleter (reporttok to PROCCALL)
33890	33956	{
33891	33957	fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (reporttok to PROCCALL)\n");
33892	33958	// copy mutable arguments back from call to reporttok
33893		- label = 2763LLU; // continue to roll stack
	33959	+ label = 2768LLU; // continue to roll stack
33894	33960	break;
33895	33961	}
33896		- case 2770LLU: // return from reporttok to PROCCALL
	33962	+ case 2775LLU: // return from reporttok to PROCCALL
33897	33963	{
33898	33964	// copy mutable arguments back from call to reporttok
33899	33965	fprintf(stderr, "%s", "\n");
33900	33966	exit(-1);
33901		- label = 2768LLU; // alternative complete
	33967	+ label = 2773LLU; // alternative complete
33902	33968	break;
33903	33969	}
33904		- case 2768LLU: // completed if-then-else
	33970	+ case 2773LLU: // completed if-then-else
33905	33971	{
33906	33972	// call skipwscmnt from PROCCALL
33907		- stack[base + 19LLU] = 2771LLU/throw to this address/;
	33973	+ stack[base + 19LLU] = 2776LLU/throw to this address/;
33908	33974	stack[base + 20LLU] = base;
33909		- stack[base + 21LLU] = 2772LLU;
	33975	+ stack[base + 21LLU] = 2777LLU;
33910	33976	// arguments for call to skipwscmnt
33911	33977	stack[base + 23LLU] = stack[base + 12]/lookahead/;
33912	33978	// set stack-base & callee-address

		@@ -33914,22 +33980,22 @@
33914	33980	label = 18446744073709551580LLU; // skipwscmnt
33915	33981	break;
33916	33982	}
33917		- case 2771LLU: // copy-back deleter (skipwscmnt to PROCCALL)
	33983	+ case 2776LLU: // copy-back deleter (skipwscmnt to PROCCALL)
33918	33984	{
33919	33985	fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (skipwscmnt to PROCCALL)\n");
33920	33986	// copy mutable arguments back from call to skipwscmnt
33921		- label = 2763LLU; // continue to roll stack
	33987	+ label = 2768LLU; // continue to roll stack
33922	33988	break;
33923	33989	}
33924		- case 2772LLU: // return from skipwscmnt to PROCCALL
	33990	+ case 2777LLU: // return from skipwscmnt to PROCCALL
33925	33991	{
33926	33992	// copy mutable arguments back from call to skipwscmnt
33927	33993	// copy back results provided by call to skipwscmnt
33928	33994	stack[base + 12] = stack[base + 22LLU];
33929	33995	// call equ from PROCCALL
33930		- stack[base + 19LLU] = 2773LLU/throw to this address/;
	33996	+ stack[base + 19LLU] = 2778LLU/throw to this address/;
33931	33997	stack[base + 20LLU] = base;
33932		- stack[base + 21LLU] = 2774LLU;
	33998	+ stack[base + 21LLU] = 2779LLU;
33933	33999	// arguments for call to equ
33934	34000	stack[base + 23LLU] = stack[base + 12]/lookahead/;
33935	34001	stack[base + 24LLU] = 41LLU;

		@@ -33938,14 +34004,14 @@
33938	34004	label = 18446744073709551600LLU; // equ
33939	34005	break;
33940	34006	}
33941		- case 2773LLU: // copy-back deleter (equ to PROCCALL)
	34007	+ case 2778LLU: // copy-back deleter (equ to PROCCALL)
33942	34008	{
33943	34009	fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (equ to PROCCALL)\n");
33944	34010	// copy mutable arguments back from call to equ
33945		- label = 2763LLU; // continue to roll stack
	34011	+ label = 2768LLU; // continue to roll stack
33946	34012	break;
33947	34013	}
33948		- case 2774LLU: // return from equ to PROCCALL
	34014	+ case 2779LLU: // return from equ to PROCCALL
33949	34015	{
33950	34016	// copy mutable arguments back from call to equ
33951	34017	// copy back results provided by call to equ

		@@ -33952,32 +34018,32 @@
33952	34018	stack[base + 18] = stack[base + 22LLU];
33953	34019	if(!stack[base + 18]/isequal/)
33954	34020	{
33955		- label = 2775LLU; // jump to alternative
	34021	+ label = 2780LLU; // jump to alternative
33956	34022	break;
33957	34023	}
33958	34024
33959	34025	// consequent
33960		- label = 2776LLU; // consequent complete
	34026	+ label = 2781LLU; // consequent complete
33961	34027	break;
33962	34028	}
33963		- case 2775LLU: // alternative
	34029	+ case 2780LLU: // alternative
33964	34030	{
33965		- label = 2777LLU; // start to repeat
	34031	+ label = 2782LLU; // start to repeat
33966	34032	break;
33967	34033	}
33968		- case 2777LLU: // repeat from here
	34034	+ case 2782LLU: // repeat from here
33969	34035	{
33970	34036	if(stack[base + 12]/lookahead/ > 0xFF)
33971	34037	{
33972		- label = 2778LLU; // break loop
	34038	+ label = 2783LLU; // break loop
33973	34039	break;
33974	34040	}
33975	34041
33976	34042	// loop body
33977	34043	// call ParseToken from PROCCALL
33978		- stack[base + 19LLU] = 2779LLU/throw to this address/;
	34044	+ stack[base + 19LLU] = 2784LLU/throw to this address/;
33979	34045	stack[base + 20LLU] = base;
33980		- stack[base + 21LLU] = 2780LLU;
	34046	+ stack[base + 21LLU] = 2785LLU;
33981	34047	// arguments for call to ParseToken
33982	34048	stack[base + 24LLU] = stack[base + 12]/lookahead/;
33983	34049	// set stack-base & callee-address

		@@ -33985,15 +34051,15 @@
33985	34051	label = 3LLU; // ParseToken
33986	34052	break;
33987	34053	}
33988		- case 2779LLU: // copy-back deleter (ParseToken to PROCCALL)
	34054	+ case 2784LLU: // copy-back deleter (ParseToken to PROCCALL)
33989	34055	{
33990	34056	fprintf(stderr, "in function PROCCALL: unrolling stack, copy-back (ParseToken to PROCCALL)\n");
33991	34057	// copy mutable arguments back from call to ParseToken
33992	34058	stack[base + 12]/lookahead/ = stack[base + 24LLU];
33993		- label = 2763LLU; // continue to roll stack
	34059	+ label = 2768LLU; // continue to roll stack
33994	34060	break;
33995	34061	}
33996		- case 2780LLU: // return from ParseToken to PROCCALL
	34062