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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	1184 (tree)
Time	2021-03-02 07:55:52
Author	jakobthomsen

Log Message

implement if-next construct

Change Summary

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

Incremental Difference

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

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

		@@ -23145,7 +23145,7 @@
23145	23145	case 1976LLU: // return from reportid to ProcCall
23146	23146	{
23147	23147	// copy mutable arguments back from call to reportid
23148		- fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of parameter obtained by switch)\n");
	23148	+ fprintf(stderr, "%s", ": at least one argument must be a substructure (i.e. part of CONSTANT parameter, obtained by switch case / while next / if next / getbyte)\n");
23149	23149	{
23150	23150	label = 1779LLU; // throw: begin to unroll stack
23151	23151	break;

		@@ -23830,9 +23830,9 @@
23830	23830
23831	23831	// consequent
23832	23832	struct listnode *next = list->next;
23833		- stack[base + 38]/typeidx/ = list->data;
	23833	+ /typeidx/stack[base + 38] = list->data;
23834	23834	Free(1, sizeof(struct listnode), list);
23835		- stack[base + 0]/dsttypeids/ = (uint64_t)next;
	23835	+ /dsttypeids/stack[base + 0] = (uint64_t)next;
23836	23836	}
23837	23837	if(/typeidx/0 != ((uint64_t )(stack[base + 38]/typeidx*/))[0])
23838	23838	{

		@@ -27358,9 +27358,9 @@
27358	27358
27359	27359	// consequent
27360	27360	struct listnode *next = list->next;
27361		- stack[base + 37]/typeidx/ = list->data;
	27361	+ /typeidx/stack[base + 37] = list->data;
27362	27362	Free(1, sizeof(struct listnode), list);
27363		- stack[base + 0]/dsttypeids/ = (uint64_t)next;
	27363	+ /dsttypeids/stack[base + 0] = (uint64_t)next;
27364	27364	}
27365	27365	if(/typeidx/0 != ((uint64_t )(stack[base + 37]/typeidx*/))[0])
27366	27366	{

		@@ -33972,9 +33972,9 @@
33972	33972
33973	33973	// consequent
33974	33974	struct listnode *next = list->next;
33975		- stack[base + 36]/typeidx/ = list->data;
	33975	+ /typeidx/stack[base + 36] = list->data;
33976	33976	Free(1, sizeof(struct listnode), list);
33977		- stack[base + 20]/BLKRESULTS/ = (uint64_t)next;
	33977	+ /BLKRESULTS/stack[base + 20] = (uint64_t)next;
33978	33978	}
33979	33979	if(/typeidx/0 != ((uint64_t )(stack[base + 36]/typeidx*/))[0])
33980	33980	{

		@@ -35695,9 +35695,9 @@
35695	35695
35696	35696	// consequent
35697	35697	struct listnode *next = list->next;
35698		- stack[base + 31]/RESULT/ = list->data;
	35698	+ /RESULT/stack[base + 31] = list->data;
35699	35699	Free(1, sizeof(struct listnode), list);
35700		- stack[base + 17]/results/ = (uint64_t)next;
	35700	+ /results/stack[base + 17] = (uint64_t)next;
35701	35701	}
35702	35702	if(/result/0 != ((uint64_t )(stack[base + 29]/result*/))[0])
35703	35703	{

		@@ -41365,133 +41365,261 @@
41365	41365	}
41366	41366	case 3434LLU: // alternative
41367	41367	{
	41368	+ label = 3477LLU; // skip deleter
	41369	+ break;
	41370	+ }
	41371	+ case 3476LLU: // deleter
	41372	+ {
	41373	+ // throw from procblock
	41374	+ if(!stack[base + 24])
	41375	+ {
	41376	+ label = 3428LLU; // skip, variable already deleted/unscoped
	41377	+ break;
	41378	+ }
	41379	+ label = 3428LLU; // continue unrolling stack, delete next variable
	41380	+ break;
	41381	+ }
	41382	+ case 3477LLU: // skipped deleter
	41383	+ {
41368	41384	// call equ from procblock
41369		- stack[base + 24LLU] = 3476LLU/throw to this address/;
41370		- stack[base + 25LLU] = base;
41371		- stack[base + 26LLU] = 3477LLU;
	41385	+ stack[base + 25LLU] = 3478LLU/throw to this address/;
	41386	+ stack[base + 26LLU] = base;
	41387	+ stack[base + 27LLU] = 3479LLU;
41372	41388	// arguments for call to equ
41373		- stack[base + 28LLU] = stack[base + 16]/content/;
41374		- stack[base + 29LLU] = 786630200929550336LLU;
	41389	+ stack[base + 29LLU] = stack[base + 16]/content/;
	41390	+ stack[base + 30LLU] = 747825068330975232LLU;
41375	41391	// set stack-base & callee-address
41376		- base += 27LLU;
	41392	+ base += 28LLU;
41377	41393	label = 18446744073709551600LLU; // equ
41378	41394	break;
41379	41395	}
41380		- case 3476LLU: // copy-back deleter (equ to procblock)
	41396	+ case 3478LLU: // copy-back deleter (equ to procblock)
41381	41397	{
41382	41398	// copy mutable arguments back from call to equ
41383	41399	label = 3428LLU; // continue to roll stack
41384	41400	break;
41385	41401	}
41386		- case 3477LLU: // return from equ to procblock
	41402	+ case 3479LLU: // return from equ to procblock
41387	41403	{
41388	41404	// copy mutable arguments back from call to equ
41389	41405	// copy back results provided by call to equ
41390		- stack[base + 20] = stack[base + 27LLU];
	41406	+ stack[base + 20] = stack[base + 28LLU];
41391	41407	if(!stack[base + 20]/isequal/)
41392	41408	{
41393		- label = 3478LLU; // jump to alternative
	41409	+ label = 3480LLU; // jump to alternative
41394	41410	break;
41395	41411	}
41396	41412
41397	41413	// consequent
	41414	+ label = 3483LLU; // skip deleter
	41415	+ break;
	41416	+ }
	41417	+ case 3482LLU: // deleter
	41418	+ {
	41419	+ // throw from procblock
	41420	+ if(!stack[base + 24])
	41421	+ {
	41422	+ label = 3428LLU; // skip, variable already deleted/unscoped
	41423	+ break;
	41424	+ }
	41425	+ label = 3428LLU; // continue unrolling stack, delete next variable
	41426	+ break;
	41427	+ }
	41428	+ case 3483LLU: // skipped deleter
	41429	+ {
	41430	+ stack[base + 24] = 0;
	41431	+ label = 3481LLU; // consequent complete
	41432	+ break;
	41433	+ }
	41434	+ case 3480LLU: // alternative
	41435	+ {
	41436	+ // call equ from procblock
	41437	+ stack[base + 25LLU] = 3484LLU/throw to this address/;
	41438	+ stack[base + 26LLU] = base;
	41439	+ stack[base + 27LLU] = 3485LLU;
	41440	+ // arguments for call to equ
	41441	+ stack[base + 29LLU] = stack[base + 16]/content/;
	41442	+ stack[base + 30LLU] = 786630200929550336LLU;
	41443	+ // set stack-base & callee-address
	41444	+ base += 28LLU;
	41445	+ label = 18446744073709551600LLU; // equ
	41446	+ break;
	41447	+ }
	41448	+ case 3484LLU: // copy-back deleter (equ to procblock)
	41449	+ {
	41450	+ // copy mutable arguments back from call to equ
	41451	+ label = 3428LLU; // continue to roll stack
	41452	+ break;
	41453	+ }
	41454	+ case 3485LLU: // return from equ to procblock
	41455	+ {
	41456	+ // copy mutable arguments back from call to equ
	41457	+ // copy back results provided by call to equ
	41458	+ stack[base + 20] = stack[base + 28LLU];
	41459	+ if(!stack[base + 20]/isequal/)
	41460	+ {
	41461	+ label = 3486LLU; // jump to alternative
	41462	+ break;
	41463	+ }
	41464	+
	41465	+ // consequent
	41466	+ label = 3489LLU; // skip deleter
	41467	+ break;
	41468	+ }
	41469	+ case 3488LLU: // deleter
	41470	+ {
	41471	+ // throw from procblock
	41472	+ if(!stack[base + 24])
	41473	+ {
	41474	+ label = 3428LLU; // skip, variable already deleted/unscoped
	41475	+ break;
	41476	+ }
	41477	+ label = 3428LLU; // continue unrolling stack, delete next variable
	41478	+ break;
	41479	+ }
	41480	+ case 3489LLU: // skipped deleter
	41481	+ {
	41482	+ stack[base + 24] = 1;
	41483	+ label = 3487LLU; // consequent complete
	41484	+ break;
	41485	+ }
	41486	+ case 3486LLU: // alternative
	41487	+ {
	41488	+ fprintf(stderr, "%s", "expected '(' but found token ");
	41489	+ // call reporttok from procblock
	41490	+ stack[base + 25LLU] = 3490LLU/throw to this address/;
	41491	+ stack[base + 26LLU] = base;
	41492	+ stack[base + 27LLU] = 3491LLU;
	41493	+ // arguments for call to reporttok
	41494	+ stack[base + 28LLU] = stack[base + 15]/variant/;
	41495	+ stack[base + 29LLU] = stack[base + 16]/content/;
	41496	+ // set stack-base & callee-address
	41497	+ base += 28LLU;
	41498	+ label = 18446744073709551582LLU; // reporttok
	41499	+ break;
	41500	+ }
	41501	+ case 3490LLU: // copy-back deleter (reporttok to procblock)
	41502	+ {
	41503	+ // copy mutable arguments back from call to reporttok
	41504	+ label = 3428LLU; // continue to roll stack
	41505	+ break;
	41506	+ }
	41507	+ case 3491LLU: // return from reporttok to procblock
	41508	+ {
	41509	+ // copy mutable arguments back from call to reporttok
	41510	+ fprintf(stderr, "%s", "\n");
	41511	+ {
	41512	+ label = 3428LLU; // throw: begin to unroll stack
	41513	+ break;
	41514	+ }
	41515	+
	41516	+ label = 3487LLU; // alternative complete
	41517	+ break;
	41518	+ }
	41519	+ case 3487LLU: // completed if-then-else
	41520	+ {
	41521	+ label = 3481LLU; // alternative complete
	41522	+ break;
	41523	+ }
	41524	+ case 3481LLU: // completed if-then-else
	41525	+ {
41398	41526	// call matchsym from procblock
41399		- stack[base + 24LLU] = 3480LLU/throw to this address/;
41400		- stack[base + 25LLU] = base;
41401		- stack[base + 26LLU] = 3481LLU;
	41527	+ stack[base + 25LLU] = 3492LLU/throw to this address/;
	41528	+ stack[base + 26LLU] = base;
	41529	+ stack[base + 27LLU] = 3493LLU;
41402	41530	// arguments for call to matchsym
41403		- stack[base + 27LLU] = stack[base + 8]/fnid/;
41404		- stack[base + 28LLU] = 40LLU;
41405		- stack[base + 29LLU] = stack[base + 19]/lookahead/;
	41531	+ stack[base + 28LLU] = stack[base + 8]/fnid/;
	41532	+ stack[base + 29LLU] = 40LLU;
	41533	+ stack[base + 30LLU] = stack[base + 19]/lookahead/;
41406	41534	// set stack-base & callee-address
41407		- base += 27LLU;
	41535	+ base += 28LLU;
41408	41536	label = 222LLU; // matchsym
41409	41537	break;
41410	41538	}
41411		- case 3480LLU: // copy-back deleter (matchsym to procblock)
	41539	+ case 3492LLU: // copy-back deleter (matchsym to procblock)
41412	41540	{
41413	41541	// copy mutable arguments back from call to matchsym
41414		- stack[base + 19]/lookahead/ = stack[base + 29LLU];
41415		- label = 3428LLU; // continue to roll stack
	41542	+ stack[base + 19]/lookahead/ = stack[base + 30LLU];
	41543	+ label = 3476LLU; // continue to roll stack
41416	41544	break;
41417	41545	}
41418		- case 3481LLU: // return from matchsym to procblock
	41546	+ case 3493LLU: // return from matchsym to procblock
41419	41547	{
41420	41548	// copy mutable arguments back from call to matchsym
41421		- stack[base + 19]/lookahead/ = stack[base + 29LLU];
	41549	+ stack[base + 19]/lookahead/ = stack[base + 30LLU];
41422	41550	// call ParseToken from procblock
41423		- stack[base + 24LLU] = 3482LLU/throw to this address/;
41424		- stack[base + 25LLU] = base;
41425		- stack[base + 26LLU] = 3483LLU;
	41551	+ stack[base + 25LLU] = 3494LLU/throw to this address/;
	41552	+ stack[base + 26LLU] = base;
	41553	+ stack[base + 27LLU] = 3495LLU;
41426	41554	// arguments for call to ParseToken
41427		- stack[base + 29LLU] = stack[base + 19]/lookahead/;
	41555	+ stack[base + 30LLU] = stack[base + 19]/lookahead/;
41428	41556	// set stack-base & callee-address
41429		- base += 27LLU;
	41557	+ base += 28LLU;
41430	41558	label = 3LLU; // ParseToken
41431	41559	break;
41432	41560	}
41433		- case 3482LLU: // copy-back deleter (ParseToken to procblock)
	41561	+ case 3494LLU: // copy-back deleter (ParseToken to procblock)
41434	41562	{
41435	41563	// copy mutable arguments back from call to ParseToken
41436		- stack[base + 19]/lookahead/ = stack[base + 29LLU];
41437		- label = 3428LLU; // continue to roll stack
	41564	+ stack[base + 19]/lookahead/ = stack[base + 30LLU];
	41565	+ label = 3476LLU; // continue to roll stack
41438	41566	break;
41439	41567	}
41440		- case 3483LLU: // return from ParseToken to procblock
	41568	+ case 3495LLU: // return from ParseToken to procblock
41441	41569	{
41442	41570	// copy mutable arguments back from call to ParseToken
41443		- stack[base + 19]/lookahead/ = stack[base + 29LLU];
	41571	+ stack[base + 19]/lookahead/ = stack[base + 30LLU];
41444	41572	// copy back results provided by call to ParseToken
41445		- stack[base + 15] = stack[base + 27LLU];
41446		- stack[base + 16] = stack[base + 28LLU];
	41573	+ stack[base + 15] = stack[base + 28LLU];
	41574	+ stack[base + 16] = stack[base + 29LLU];
41447	41575	// call equ from procblock
41448		- stack[base + 24LLU] = 3484LLU/throw to this address/;
41449		- stack[base + 25LLU] = base;
41450		- stack[base + 26LLU] = 3485LLU;
	41576	+ stack[base + 25LLU] = 3496LLU/throw to this address/;
	41577	+ stack[base + 26LLU] = base;
	41578	+ stack[base + 27LLU] = 3497LLU;
41451	41579	// arguments for call to equ
41452		- stack[base + 28LLU] = stack[base + 15]/variant/;
41453		- stack[base + 29LLU] = 4LLU;
	41580	+ stack[base + 29LLU] = stack[base + 15]/variant/;
	41581	+ stack[base + 30LLU] = 4LLU;
41454	41582	// set stack-base & callee-address
41455		- base += 27LLU;
	41583	+ base += 28LLU;
41456	41584	label = 18446744073709551600LLU; // equ
41457	41585	break;
41458	41586	}
41459		- case 3484LLU: // copy-back deleter (equ to procblock)
	41587	+ case 3496LLU: // copy-back deleter (equ to procblock)
41460	41588	{
41461	41589	// copy mutable arguments back from call to equ
41462		- label = 3428LLU; // continue to roll stack
	41590	+ label = 3476LLU; // continue to roll stack
41463	41591	break;
41464	41592	}
41465		- case 3485LLU: // return from equ to procblock
	41593	+ case 3497LLU: // return from equ to procblock
41466	41594	{
41467	41595	// copy mutable arguments back from call to equ
41468	41596	// copy back results provided by call to equ
41469		- stack[base + 20] = stack[base + 27LLU];
	41597	+ stack[base + 20] = stack[base + 28LLU];
41470	41598	if(!stack[base + 20]/isequal/)
41471	41599	{
41472		- label = 3486LLU; // jump to alternative
	41600	+ label = 3498LLU; // jump to alternative
41473	41601	break;
41474	41602	}
41475	41603
41476	41604	// consequent
41477		- label = 3489LLU; // skip deleter
	41605	+ label = 3501LLU; // skip deleter
41478	41606	break;
41479	41607	}
41480		- case 3488LLU: // deleter
	41608	+ case 3500LLU: // deleter
41481	41609	{
41482	41610	// throw from procblock
41483		- if(!stack[base + 24])
	41611	+ if(!stack[base + 25])
41484	41612	{
41485		- label = 3428LLU; // skip, variable already deleted/unscoped
	41613	+ label = 3476LLU; // skip, variable already deleted/unscoped
41486	41614	break;
41487	41615	}
41488	41616
41489		- uint64_t newstack = (uint64_t )(stack[base + 24] - sizeof(uint64_t) * 4);
	41617	+ uint64_t newstack = (uint64_t )(stack[base + 25] - sizeof(uint64_t) * 4);
41490	41618	// call ~letdef from procblock
41491	41619	newstack[0] = (uint64_t)stack; // backup stack location
41492	41620	newstack[1] = 1234567890;
41493	41621	newstack[2] = base;
41494		- newstack[3] = 3490LLU;
	41622	+ newstack[3] = 3502LLU;
41495	41623	stack = newstack;
41496	41624	// set stack-base & callee-address
41497	41625	base = 4/deloffset/;

		@@ -41498,293 +41626,312 @@
41498	41626	label = 482LLU; // ~letdef
41499	41627	break;
41500	41628	}
41501		- case 3490LLU: // return from ~letdef to procblock
	41629	+ case 3502LLU: // return from ~letdef to procblock
41502	41630	{
41503	41631	stack = (uint64_t *)stack[0];
41504	41632	// releasing toplevel container
41505		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 24] - sizeof(uint64_t) 4));
	41633	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 25] - sizeof(uint64_t) 4));
41506	41634
41507		- label = 3428LLU; // continue unrolling stack, delete next variable
	41635	+ label = 3476LLU; // continue unrolling stack, delete next variable
41508	41636	break;
41509	41637	}
41510		- case 3489LLU: // skipped deleter
	41638	+ case 3501LLU: // skipped deleter
41511	41639	{
41512	41640	// call FindLetNew from procblock
41513		- stack[base + 25LLU] = 3491LLU/throw to this address/;
41514		- stack[base + 26LLU] = base;
41515		- stack[base + 27LLU] = 3492LLU;
	41641	+ stack[base + 26LLU] = 3503LLU/throw to this address/;
	41642	+ stack[base + 27LLU] = base;
	41643	+ stack[base + 28LLU] = 3504LLU;
41516	41644	// arguments for call to FindLetNew
41517		- stack[base + 29LLU] = stack[base + 8]/fnid/;
41518		- stack[base + 30LLU] = stack[base + 16]/content/;
41519		- stack[base + 31LLU] = stack[base + 2]/scopes/;
41520		- stack[base + 32LLU] = stack[base + 3]/scope/;
	41645	+ stack[base + 30LLU] = stack[base + 8]/fnid/;
	41646	+ stack[base + 31LLU] = stack[base + 16]/content/;
	41647	+ stack[base + 32LLU] = stack[base + 2]/scopes/;
	41648	+ stack[base + 33LLU] = stack[base + 3]/scope/;
41521	41649	// set stack-base & callee-address
41522		- base += 28LLU;
	41650	+ base += 29LLU;
41523	41651	label = 615LLU; // FindLetNew
41524	41652	break;
41525	41653	}
41526		- case 3491LLU: // copy-back deleter (FindLetNew to procblock)
	41654	+ case 3503LLU: // copy-back deleter (FindLetNew to procblock)
41527	41655	{
41528	41656	// copy mutable arguments back from call to FindLetNew
41529		- label = 3428LLU; // continue to roll stack
	41657	+ label = 3476LLU; // continue to roll stack
41530	41658	break;
41531	41659	}
41532		- case 3492LLU: // return from FindLetNew to procblock
	41660	+ case 3504LLU: // return from FindLetNew to procblock
41533	41661	{
41534	41662	// copy mutable arguments back from call to FindLetNew
41535	41663	// copy back results provided by call to FindLetNew
41536		- stack[base + 24] = stack[base + 28LLU];
41537		- if(/letdef/0 != ((uint64_t )(stack[base + 24]/letdef*/))[0])
	41664	+ stack[base + 25] = stack[base + 29LLU];
	41665	+ if(/letdef/0 != ((uint64_t )(stack[base + 25]/letdef*/))[0])
41538	41666	{
41539		- label = 3494LLU; // jump to alternative
	41667	+ label = 3506LLU; // jump to alternative
41540	41668	break;
41541	41669	}
41542	41670
41543		- /listtype/stack[base + 25] = ((uint64_t *)(stack[base + 24]/letdef/))[1][0]/type*/;
41544		- /listname/stack[base + 26] = ((uint64_t *)(stack[base + 24]/letdef/))[1][1]/id*/;
41545		- /listindex/stack[base + 27] = ((uint64_t *)(stack[base + 24]/letdef/))[1][2]/index*/;
41546		- /listmut/stack[base + 28] = ((uint64_t *)(stack[base + 24]/letdef/))[1][3]/mutable*/;
41547		- /substruct/stack[base + 29] = ((uint64_t *)(stack[base + 24]/letdef/))[1][4]/substruct*/;
	41671	+ /listtype/stack[base + 26] = ((uint64_t *)(stack[base + 25]/letdef/))[1][0]/type*/;
	41672	+ /listname/stack[base + 27] = ((uint64_t *)(stack[base + 25]/letdef/))[1][1]/id*/;
	41673	+ /listindex/stack[base + 28] = ((uint64_t *)(stack[base + 25]/letdef/))[1][2]/index*/;
	41674	+ /listmut/stack[base + 29] = ((uint64_t *)(stack[base + 25]/letdef/))[1][3]/mutable*/;
	41675	+ /substruct/stack[base + 30] = ((uint64_t *)(stack[base + 25]/letdef/))[1][4]/substruct*/;
41548	41676
41549	41677	// case
41550		- printf("%s", "\n { // if pop");
	41678	+ printf("%s", "\n { // if ");
	41679	+ if(!stack[base + 24]/consume/)
	41680	+ {
	41681	+ label = 3508LLU; // jump to alternative
	41682	+ break;
	41683	+ }
	41684	+
	41685	+ // consequent
	41686	+ printf("%s", "pop");
	41687	+ label = 3509LLU; // consequent complete
	41688	+ break;
	41689	+ }
	41690	+ case 3508LLU: // alternative
	41691	+ {
	41692	+ printf("%s", "next");
	41693	+ label = 3509LLU; // alternative complete
	41694	+ break;
	41695	+ }
	41696	+ case 3509LLU: // completed if-then-else
	41697	+ {
41551	41698	printf("%s", "\n struct listnode list = (struct listnode )");
41552	41699	// call emitvaridx from procblock
41553		- stack[base + 30LLU] = 3496LLU/throw to this address/;
41554		- stack[base + 31LLU] = base;
41555		- stack[base + 32LLU] = 3497LLU;
	41700	+ stack[base + 31LLU] = 3510LLU/throw to this address/;
	41701	+ stack[base + 32LLU] = base;
	41702	+ stack[base + 33LLU] = 3511LLU;
41556	41703	// arguments for call to emitvaridx
41557		- stack[base + 33LLU] = stack[base + 27]/listindex/;
	41704	+ stack[base + 34LLU] = stack[base + 28]/listindex/;
41558	41705	// set stack-base & callee-address
41559		- base += 33LLU;
	41706	+ base += 34LLU;
41560	41707	label = 741LLU; // emitvaridx
41561	41708	break;
41562	41709	}
41563		- case 3496LLU: // copy-back deleter (emitvaridx to procblock)
	41710	+ case 3510LLU: // copy-back deleter (emitvaridx to procblock)
41564	41711	{
41565	41712	// copy mutable arguments back from call to emitvaridx
41566		- label = 3495LLU; // continue to roll stack
	41713	+ label = 3507LLU; // continue to roll stack
41567	41714	break;
41568	41715	}
41569		- case 3497LLU: // return from emitvaridx to procblock
	41716	+ case 3511LLU: // return from emitvaridx to procblock
41570	41717	{
41571	41718	// copy mutable arguments back from call to emitvaridx
41572	41719	printf("%s", "/*");
41573	41720	// call printid from procblock
41574		- stack[base + 30LLU] = 3498LLU/throw to this address/;
41575		- stack[base + 31LLU] = base;
41576		- stack[base + 32LLU] = 3499LLU;
	41721	+ stack[base + 31LLU] = 3512LLU/throw to this address/;
	41722	+ stack[base + 32LLU] = base;
	41723	+ stack[base + 33LLU] = 3513LLU;
41577	41724	// arguments for call to printid
41578		- stack[base + 33LLU] = stack[base + 26]/listname/;
	41725	+ stack[base + 34LLU] = stack[base + 27]/listname/;
41579	41726	// set stack-base & callee-address
41580		- base += 33LLU;
	41727	+ base += 34LLU;
41581	41728	label = 18446744073709551587LLU; // printid
41582	41729	break;
41583	41730	}
41584		- case 3498LLU: // copy-back deleter (printid to procblock)
	41731	+ case 3512LLU: // copy-back deleter (printid to procblock)
41585	41732	{
41586	41733	// copy mutable arguments back from call to printid
41587		- label = 3495LLU; // continue to roll stack
	41734	+ label = 3507LLU; // continue to roll stack
41588	41735	break;
41589	41736	}
41590		- case 3499LLU: // return from printid to procblock
	41737	+ case 3513LLU: // return from printid to procblock
41591	41738	{
41592	41739	// copy mutable arguments back from call to printid
41593	41740	printf("%s", "*/;");
41594	41741	printf("%s", "\n if(!list)");
41595	41742	// call matchsym from procblock
41596		- stack[base + 30LLU] = 3500LLU/throw to this address/;
41597		- stack[base + 31LLU] = base;
41598		- stack[base + 32LLU] = 3501LLU;
	41743	+ stack[base + 31LLU] = 3514LLU/throw to this address/;
	41744	+ stack[base + 32LLU] = base;
	41745	+ stack[base + 33LLU] = 3515LLU;
41599	41746	// arguments for call to matchsym
41600		- stack[base + 33LLU] = stack[base + 8]/fnid/;
41601		- stack[base + 34LLU] = 41LLU;
41602		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41747	+ stack[base + 34LLU] = stack[base + 8]/fnid/;
	41748	+ stack[base + 35LLU] = 41LLU;
	41749	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41603	41750	// set stack-base & callee-address
41604		- base += 33LLU;
	41751	+ base += 34LLU;
41605	41752	label = 222LLU; // matchsym
41606	41753	break;
41607	41754	}
41608		- case 3500LLU: // copy-back deleter (matchsym to procblock)
	41755	+ case 3514LLU: // copy-back deleter (matchsym to procblock)
41609	41756	{
41610	41757	// copy mutable arguments back from call to matchsym
41611		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41612		- label = 3495LLU; // continue to roll stack
	41758	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41759	+ label = 3507LLU; // continue to roll stack
41613	41760	break;
41614	41761	}
41615		- case 3501LLU: // return from matchsym to procblock
	41762	+ case 3515LLU: // return from matchsym to procblock
41616	41763	{
41617	41764	// copy mutable arguments back from call to matchsym
41618		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
	41765	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
41619	41766	// call matchsym from procblock
41620		- stack[base + 30LLU] = 3502LLU/throw to this address/;
41621		- stack[base + 31LLU] = base;
41622		- stack[base + 32LLU] = 3503LLU;
	41767	+ stack[base + 31LLU] = 3516LLU/throw to this address/;
	41768	+ stack[base + 32LLU] = base;
	41769	+ stack[base + 33LLU] = 3517LLU;
41623	41770	// arguments for call to matchsym
41624		- stack[base + 33LLU] = stack[base + 8]/fnid/;
41625		- stack[base + 34LLU] = 45LLU;
41626		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41771	+ stack[base + 34LLU] = stack[base + 8]/fnid/;
	41772	+ stack[base + 35LLU] = 45LLU;
	41773	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41627	41774	// set stack-base & callee-address
41628		- base += 33LLU;
	41775	+ base += 34LLU;
41629	41776	label = 222LLU; // matchsym
41630	41777	break;
41631	41778	}
41632		- case 3502LLU: // copy-back deleter (matchsym to procblock)
	41779	+ case 3516LLU: // copy-back deleter (matchsym to procblock)
41633	41780	{
41634	41781	// copy mutable arguments back from call to matchsym
41635		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41636		- label = 3495LLU; // continue to roll stack
	41782	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41783	+ label = 3507LLU; // continue to roll stack
41637	41784	break;
41638	41785	}
41639		- case 3503LLU: // return from matchsym to procblock
	41786	+ case 3517LLU: // return from matchsym to procblock
41640	41787	{
41641	41788	// copy mutable arguments back from call to matchsym
41642		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
	41789	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
41643	41790	// call matchsym from procblock
41644		- stack[base + 30LLU] = 3504LLU/throw to this address/;
41645		- stack[base + 31LLU] = base;
41646		- stack[base + 32LLU] = 3505LLU;
	41791	+ stack[base + 31LLU] = 3518LLU/throw to this address/;
	41792	+ stack[base + 32LLU] = base;
	41793	+ stack[base + 33LLU] = 3519LLU;
41647	41794	// arguments for call to matchsym
41648		- stack[base + 33LLU] = stack[base + 8]/fnid/;
41649		- stack[base + 34LLU] = 62LLU;
41650		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41795	+ stack[base + 34LLU] = stack[base + 8]/fnid/;
	41796	+ stack[base + 35LLU] = 62LLU;
	41797	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41651	41798	// set stack-base & callee-address
41652		- base += 33LLU;
	41799	+ base += 34LLU;
41653	41800	label = 222LLU; // matchsym
41654	41801	break;
41655	41802	}
41656		- case 3504LLU: // copy-back deleter (matchsym to procblock)
	41803	+ case 3518LLU: // copy-back deleter (matchsym to procblock)
41657	41804	{
41658	41805	// copy mutable arguments back from call to matchsym
41659		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41660		- label = 3495LLU; // continue to roll stack
	41806	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41807	+ label = 3507LLU; // continue to roll stack
41661	41808	break;
41662	41809	}
41663		- case 3505LLU: // return from matchsym to procblock
	41810	+ case 3519LLU: // return from matchsym to procblock
41664	41811	{
41665	41812	// copy mutable arguments back from call to matchsym
41666		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
	41813	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
41667	41814	// call matchsym from procblock
41668		- stack[base + 30LLU] = 3506LLU/throw to this address/;
41669		- stack[base + 31LLU] = base;
41670		- stack[base + 32LLU] = 3507LLU;
	41815	+ stack[base + 31LLU] = 3520LLU/throw to this address/;
	41816	+ stack[base + 32LLU] = base;
	41817	+ stack[base + 33LLU] = 3521LLU;
41671	41818	// arguments for call to matchsym
41672		- stack[base + 33LLU] = stack[base + 8]/fnid/;
41673		- stack[base + 34LLU] = 40LLU;
41674		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41819	+ stack[base + 34LLU] = stack[base + 8]/fnid/;
	41820	+ stack[base + 35LLU] = 40LLU;
	41821	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41675	41822	// set stack-base & callee-address
41676		- base += 33LLU;
	41823	+ base += 34LLU;
41677	41824	label = 222LLU; // matchsym
41678	41825	break;
41679	41826	}
41680		- case 3506LLU: // copy-back deleter (matchsym to procblock)
	41827	+ case 3520LLU: // copy-back deleter (matchsym to procblock)
41681	41828	{
41682	41829	// copy mutable arguments back from call to matchsym
41683		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41684		- label = 3495LLU; // continue to roll stack
	41830	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41831	+ label = 3507LLU; // continue to roll stack
41685	41832	break;
41686	41833	}
41687		- case 3507LLU: // return from matchsym to procblock
	41834	+ case 3521LLU: // return from matchsym to procblock
41688	41835	{
41689	41836	// copy mutable arguments back from call to matchsym
41690		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
	41837	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
41691	41838	// call ParseToken from procblock
41692		- stack[base + 30LLU] = 3508LLU/throw to this address/;
41693		- stack[base + 31LLU] = base;
41694		- stack[base + 32LLU] = 3509LLU;
	41839	+ stack[base + 31LLU] = 3522LLU/throw to this address/;
	41840	+ stack[base + 32LLU] = base;
	41841	+ stack[base + 33LLU] = 3523LLU;
41695	41842	// arguments for call to ParseToken
41696		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41843	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41697	41844	// set stack-base & callee-address
41698		- base += 33LLU;
	41845	+ base += 34LLU;
41699	41846	label = 3LLU; // ParseToken
41700	41847	break;
41701	41848	}
41702		- case 3508LLU: // copy-back deleter (ParseToken to procblock)
	41849	+ case 3522LLU: // copy-back deleter (ParseToken to procblock)
41703	41850	{
41704	41851	// copy mutable arguments back from call to ParseToken
41705		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41706		- label = 3495LLU; // continue to roll stack
	41852	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41853	+ label = 3507LLU; // continue to roll stack
41707	41854	break;
41708	41855	}
41709		- case 3509LLU: // return from ParseToken to procblock
	41856	+ case 3523LLU: // return from ParseToken to procblock
41710	41857	{
41711	41858	// copy mutable arguments back from call to ParseToken
41712		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
	41859	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
41713	41860	// copy back results provided by call to ParseToken
41714		- stack[base + 15] = stack[base + 33LLU];
41715		- stack[base + 16] = stack[base + 34LLU];
	41861	+ stack[base + 15] = stack[base + 34LLU];
	41862	+ stack[base + 16] = stack[base + 35LLU];
41716	41863	// call equ from procblock
41717		- stack[base + 30LLU] = 3510LLU/throw to this address/;
41718		- stack[base + 31LLU] = base;
41719		- stack[base + 32LLU] = 3511LLU;
	41864	+ stack[base + 31LLU] = 3524LLU/throw to this address/;
	41865	+ stack[base + 32LLU] = base;
	41866	+ stack[base + 33LLU] = 3525LLU;
41720	41867	// arguments for call to equ
41721		- stack[base + 34LLU] = stack[base + 15]/variant/;
41722		- stack[base + 35LLU] = 4LLU;
	41868	+ stack[base + 35LLU] = stack[base + 15]/variant/;
	41869	+ stack[base + 36LLU] = 4LLU;
41723	41870	// set stack-base & callee-address
41724		- base += 33LLU;
	41871	+ base += 34LLU;
41725	41872	label = 18446744073709551600LLU; // equ
41726	41873	break;
41727	41874	}
41728		- case 3510LLU: // copy-back deleter (equ to procblock)
	41875	+ case 3524LLU: // copy-back deleter (equ to procblock)
41729	41876	{
41730	41877	// copy mutable arguments back from call to equ
41731		- label = 3495LLU; // continue to roll stack
	41878	+ label = 3507LLU; // continue to roll stack
41732	41879	break;
41733	41880	}
41734		- case 3511LLU: // return from equ to procblock
	41881	+ case 3525LLU: // return from equ to procblock
41735	41882	{
41736	41883	// copy mutable arguments back from call to equ
41737	41884	// copy back results provided by call to equ
41738		- stack[base + 20] = stack[base + 33LLU];
	41885	+ stack[base + 20] = stack[base + 34LLU];
41739	41886	if(!stack[base + 20]/isequal/)
41740	41887	{
41741		- label = 3512LLU; // jump to alternative
	41888	+ label = 3526LLU; // jump to alternative
41742	41889	break;
41743	41890	}
41744	41891
41745	41892	// consequent
41746	41893	// call matchsym from procblock
41747		- stack[base + 30LLU] = 3514LLU/throw to this address/;
41748		- stack[base + 31LLU] = base;
41749		- stack[base + 32LLU] = 3515LLU;
	41894	+ stack[base + 31LLU] = 3528LLU/throw to this address/;
	41895	+ stack[base + 32LLU] = base;
	41896	+ stack[base + 33LLU] = 3529LLU;
41750	41897	// arguments for call to matchsym
41751		- stack[base + 33LLU] = stack[base + 8]/fnid/;
41752		- stack[base + 34LLU] = 41LLU;
41753		- stack[base + 35LLU] = stack[base + 19]/lookahead/;
	41898	+ stack[base + 34LLU] = stack[base + 8]/fnid/;
	41899	+ stack[base + 35LLU] = 41LLU;
	41900	+ stack[base + 36LLU] = stack[base + 19]/lookahead/;
41754	41901	// set stack-base & callee-address
41755		- base += 33LLU;
	41902	+ base += 34LLU;
41756	41903	label = 222LLU; // matchsym
41757	41904	break;
41758	41905	}
41759		- case 3514LLU: // copy-back deleter (matchsym to procblock)
	41906	+ case 3528LLU: // copy-back deleter (matchsym to procblock)
41760	41907	{
41761	41908	// copy mutable arguments back from call to matchsym
41762		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41763		- label = 3495LLU; // continue to roll stack
	41909	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41910	+ label = 3507LLU; // continue to roll stack
41764	41911	break;
41765	41912	}
41766		- case 3515LLU: // return from matchsym to procblock
	41913	+ case 3529LLU: // return from matchsym to procblock
41767	41914	{
41768	41915	// copy mutable arguments back from call to matchsym
41769		- stack[base + 19]/lookahead/ = stack[base + 35LLU];
41770		- label = 3517LLU; // skip deleter
	41916	+ stack[base + 19]/lookahead/ = stack[base + 36LLU];
	41917	+ label = 3531LLU; // skip deleter
41771	41918	break;
41772	41919	}
41773		- case 3516LLU: // deleter
	41920	+ case 3530LLU: // deleter
41774	41921	{
41775	41922	// throw from procblock
41776		- if(!stack[base + 30])
	41923	+ if(!stack[base + 31])
41777	41924	{
41778		- label = 3495LLU; // skip, variable already deleted/unscoped
	41925	+ label = 3507LLU; // skip, variable already deleted/unscoped
41779	41926	break;
41780	41927	}
41781	41928
41782		- uint64_t newstack = (uint64_t )(stack[base + 30] - sizeof(uint64_t) * 4);
	41929	+ uint64_t newstack = (uint64_t )(stack[base + 31] - sizeof(uint64_t) * 4);
41783	41930	// call ~scope from procblock
41784	41931	newstack[0] = (uint64_t)stack; // backup stack location
41785	41932	newstack[1] = 1234567890;
41786	41933	newstack[2] = base;
41787		- newstack[3] = 3518LLU;
	41934	+ newstack[3] = 3532LLU;
41788	41935	stack = newstack;
41789	41936	// set stack-base & callee-address
41790	41937	base = 4/deloffset/;

		@@ -41791,40 +41938,40 @@
41791	41938	label = 558LLU; // ~scope
41792	41939	break;
41793	41940	}
41794		- case 3518LLU: // return from ~scope to procblock
	41941	+ case 3532LLU: // return from ~scope to procblock
41795	41942	{
41796	41943	stack = (uint64_t *)stack[0];
41797	41944	// releasing toplevel container
41798		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 30] - sizeof(uint64_t) 4));
	41945	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 31] - sizeof(uint64_t) 4));
41799	41946
41800		- label = 3495LLU; // continue unrolling stack, delete next variable
	41947	+ label = 3507LLU; // continue unrolling stack, delete next variable
41801	41948	break;
41802	41949	}
41803		- case 3517LLU: // skipped deleter
	41950	+ case 3531LLU: // skipped deleter
41804	41951	{
41805	41952	// call linkscope from procblock
41806		- stack[base + 31LLU] = 3519LLU/throw to this address/;
41807		- stack[base + 32LLU] = base;
41808		- stack[base + 33LLU] = 3520LLU;
	41953	+ stack[base + 32LLU] = 3533LLU/throw to this address/;
	41954	+ stack[base + 33LLU] = base;
	41955	+ stack[base + 34LLU] = 3534LLU;
41809	41956	// arguments for call to linkscope
41810		- stack[base + 35LLU] = stack[base + 3]/scope/;
	41957	+ stack[base + 36LLU] = stack[base + 3]/scope/;
41811	41958	// set stack-base & callee-address
41812		- base += 34LLU;
	41959	+ base += 35LLU;
41813	41960	label = 585LLU; // linkscope
41814	41961	break;
41815	41962	}
41816		- case 3519LLU: // copy-back deleter (linkscope to procblock)
	41963	+ case 3533LLU: // copy-back deleter (linkscope to procblock)
41817	41964	{
41818	41965	// copy mutable arguments back from call to linkscope
41819		- label = 3495LLU; // continue to roll stack
	41966	+ label = 3507LLU; // continue to roll stack
41820	41967	break;
41821	41968	}
41822		- case 3520LLU: // return from linkscope to procblock
	41969	+ case 3534LLU: // return from linkscope to procblock
41823	41970	{
41824	41971	// copy mutable arguments back from call to linkscope
41825	41972	// copy back results provided by call to linkscope
41826		- stack[base + 30] = stack[base + 34LLU];
41827		- swap(&stack[base + 3], &stack[base + 30]);
	41973	+ stack[base + 31] = stack[base + 35LLU];
	41974	+ swap(&stack[base + 3], &stack[base + 31]);
41828	41975	{
41829	41976	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
41830	41977	if(!list)

		@@ -41836,594 +41983,530 @@
41836	41983	}
41837	41984	list->next = (struct listnode )stack[base + 2]/scopes*/;
41838	41985	stack[base + 2]/scopes/ = (uint64_t)list;
41839		- MOVE(&list->data, &stack[base + 30]/newscope/);
	41986	+ MOVE(&list->data, &stack[base + 31]/newscope/);
41840	41987	}
41841		- if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
41842		- {
41843		- label = 3522LLU; // jump to alternative
41844		- break;
41845		- }
41846		-
41847		- /deleteaddr/stack[base + 30] = ((uint64_t *)(stack[base + 3]/scope/))[1][0]/deleteaddr*/;
41848		- /letdefs/stack[base + 31] = ((uint64_t *)(stack[base + 3]/scope/))[1][1]/letdefs*/;
41849		-
41850		- // case
41851		- label = 3525LLU; // skip deleter
	41988	+ label = 3536LLU; // skip deleter
41852	41989	break;
41853	41990	}
41854		- case 3524LLU: // deleter
	41991	+ case 3535LLU: // deleter
41855	41992	{
41856	41993	// throw from procblock
41857		- if(!stack[base + 32])
	41994	+ if(!stack[base + 31])
41858	41995	{
41859		- label = 3523LLU; // skip, variable already deleted/unscoped
	41996	+ label = 3507LLU; // skip, variable already deleted/unscoped
41860	41997	break;
41861	41998	}
41862		-
41863		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
41864		- // call ~type from procblock
41865		- newstack[0] = (uint64_t)stack; // backup stack location
41866		- newstack[1] = 1234567890;
41867		- newstack[2] = base;
41868		- newstack[3] = 3526LLU;
41869		- stack = newstack;
41870		- // set stack-base & callee-address
41871		- base = 4/deloffset/;
41872		- label = 306LLU; // ~type
	41999	+ label = 3507LLU; // continue unrolling stack, delete next variable
41873	42000	break;
41874	42001	}
41875		- case 3526LLU: // return from ~type to procblock
	42002	+ case 3536LLU: // skipped deleter
41876	42003	{
41877		- stack = (uint64_t *)stack[0];
41878		- // releasing toplevel container
41879		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
41880		-
41881		- label = 3523LLU; // continue unrolling stack, delete next variable
41882		- break;
41883		- }
41884		- case 3525LLU: // skipped deleter
41885		- {
41886		- uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
41887		- if(!newstack)
41888		- {
41889		- label = 3523LLU; // throw: begin to unroll stack
41890		- break;
41891		- }
41892		-
41893		- newstack[15LLU] = 9876543210LLU; // overflow-marker
41894		- // call copytype from procblock
41895		- newstack[0] = (uint64_t)stack; // backup stack location
41896		- newstack[1] = 3527LLU;
41897		- newstack[2] = base;
41898		- newstack[3] = 3528LLU;
41899		- // arguments for call to copytype
41900		- newstack[5LLU] = stack[base + 25]/listtype/;
41901		- stack = newstack;
	42004	+ // call getdeladdr from procblock
	42005	+ stack[base + 32LLU] = 3537LLU/throw to this address/;
	42006	+ stack[base + 33LLU] = base;
	42007	+ stack[base + 34LLU] = 3538LLU;
	42008	+ // arguments for call to getdeladdr
	42009	+ stack[base + 36LLU] = stack[base + 3]/scope/;
41902	42010	// set stack-base & callee-address
41903		- base = 4/deloffset/;
41904		- label = 337LLU; // copytype
	42011	+ base += 35LLU;
	42012	+ label = 592LLU; // getdeladdr
41905	42013	break;
41906	42014	}
41907		- case 3527LLU: // copy-back deleter (copytype to procblock)
	42015	+ case 3537LLU: // copy-back deleter (getdeladdr to procblock)
41908	42016	{
41909		- uint64_t oldstack = (uint64_t )stack[0];
41910		- // copy mutable arguments back from call to copytype
41911		- if(stack[15LLU] != 9876543210LLU)
41912		- {
41913		- fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to copytype)!\n");
41914		- exit(-1);
41915		- }
41916		- Free(15LLU + 1, sizeof(uint64_t), stack);
41917		- stack = oldstack;
41918		- label = 3523LLU; // continue to unroll stack
	42017	+ // copy mutable arguments back from call to getdeladdr
	42018	+ label = 3507LLU; // continue to roll stack
41919	42019	break;
41920	42020	}
41921		- case 3528LLU: // return from copytype to procblock
	42021	+ case 3538LLU: // return from getdeladdr to procblock
41922	42022	{
41923		- uint64_t oldstack = (uint64_t )stack[0];
41924		- // copy mutable arguments back from call to copytype
41925		- // copy back results provided by call to copytype
41926		- oldstack[base + 32] = stack[4LLU];
41927		- if(stack[15LLU] != 9876543210LLU)
41928		- {
41929		- fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to copytype)!\n");
41930		- exit(-1);
41931		- }
41932		- Free(15LLU + 1, sizeof(uint64_t), stack);
41933		- stack = oldstack;
41934		- label = 3530LLU; // skip deleter
41935		- break;
41936		- }
41937		- case 3529LLU: // deleter
41938		- {
41939		- // throw from procblock
41940		- if(!stack[base + 33])
41941		- {
41942		- label = 3524LLU; // skip, variable already deleted/unscoped
41943		- break;
41944		- }
41945		- label = 3524LLU; // continue unrolling stack, delete next variable
41946		- break;
41947		- }
41948		- case 3530LLU: // skipped deleter
41949		- {
41950		- // call isparam from procblock
41951		- stack[base + 34LLU] = 3531LLU/throw to this address/;
41952		- stack[base + 35LLU] = base;
41953		- stack[base + 36LLU] = 3532LLU;
41954		- // arguments for call to isparam
41955		- stack[base + 38LLU] = stack[base + 10]/fnrescount/;
41956		- stack[base + 39LLU] = stack[base + 11]/fnargcount/;
41957		- stack[base + 40LLU] = stack[base + 27]/listindex/;
	42023	+ // copy mutable arguments back from call to getdeladdr
	42024	+ // copy back results provided by call to getdeladdr
	42025	+ stack[base + 31] = stack[base + 35LLU];
	42026	+ // call add from procblock
	42027	+ stack[base + 32LLU] = 3539LLU/throw to this address/;
	42028	+ stack[base + 33LLU] = base;
	42029	+ stack[base + 34LLU] = 3540LLU;
	42030	+ // arguments for call to add
	42031	+ stack[base + 36LLU] = 1LLU;
	42032	+ stack[base + 37LLU] = stack[base + 17]/label/;
41958	42033	// set stack-base & callee-address
41959		- base += 37LLU;
41960		- label = 1621LLU; // isparam
	42034	+ base += 35LLU;
	42035	+ label = 18446744073709551605LLU; // add
41961	42036	break;
41962	42037	}
41963		- case 3531LLU: // copy-back deleter (isparam to procblock)
	42038	+ case 3539LLU: // copy-back deleter (add to procblock)
41964	42039	{
41965		- // copy mutable arguments back from call to isparam
41966		- label = 3524LLU; // continue to roll stack
	42040	+ // copy mutable arguments back from call to add
	42041	+ label = 3535LLU; // continue to roll stack
41967	42042	break;
41968	42043	}
41969		- case 3532LLU: // return from isparam to procblock
	42044	+ case 3540LLU: // return from add to procblock
41970	42045	{
41971		- // copy mutable arguments back from call to isparam
41972		- // copy back results provided by call to isparam
41973		- stack[base + 33] = stack[base + 37LLU];
41974		- label = 3534LLU; // skip deleter
	42046	+ // copy mutable arguments back from call to add
	42047	+ // copy back results provided by call to add
	42048	+ stack[base + 17] = stack[base + 35LLU];
	42049	+ label = 3542LLU; // skip deleter
41975	42050	break;
41976	42051	}
41977		- case 3533LLU: // deleter
	42052	+ case 3541LLU: // deleter
41978	42053	{
41979	42054	// throw from procblock
41980		- if(!stack[base + 34])
	42055	+ if(!stack[base + 32])
41981	42056	{
41982		- label = 3529LLU; // skip, variable already deleted/unscoped
	42057	+ label = 3535LLU; // skip, variable already deleted/unscoped
41983	42058	break;
41984	42059	}
41985		- label = 3529LLU; // continue unrolling stack, delete next variable
	42060	+ label = 3535LLU; // continue unrolling stack, delete next variable
41986	42061	break;
41987	42062	}
41988		- case 3534LLU: // skipped deleter
	42063	+ case 3542LLU: // skipped deleter
41989	42064	{
41990		- // call or from procblock
41991		- stack[base + 35LLU] = 3535LLU/throw to this address/;
41992		- stack[base + 36LLU] = base;
41993		- stack[base + 37LLU] = 3536LLU;
41994		- // arguments for call to or
41995		- stack[base + 39LLU] = stack[base + 29]/substruct/;
41996		- stack[base + 40LLU] = stack[base + 33]/listparam/;
41997		- // set stack-base & callee-address
41998		- base += 38LLU;
41999		- label = 18446744073709551611LLU; // or
	42065	+ stack[base + 32] = stack[base + 17]/label/;
	42066	+ label = 3544LLU; // skip deleter
42000	42067	break;
42001	42068	}
42002		- case 3535LLU: // copy-back deleter (or to procblock)
	42069	+ case 3543LLU: // deleter
42003	42070	{
42004		- // copy mutable arguments back from call to or
42005		- label = 3529LLU; // continue to roll stack
42006		- break;
42007		- }
42008		- case 3536LLU: // return from or to procblock
42009		- {
42010		- // copy mutable arguments back from call to or
42011		- // copy back results provided by call to or
42012		- stack[base + 34] = stack[base + 38LLU];
42013		- label = 3538LLU; // skip deleter
42014		- break;
42015		- }
42016		- case 3537LLU: // deleter
42017		- {
42018	42071	// throw from procblock
42019		- if(!stack[base + 35])
	42072	+ if(!stack[base + 33])
42020	42073	{
42021		- label = 3533LLU; // skip, variable already deleted/unscoped
	42074	+ label = 3541LLU; // skip, variable already deleted/unscoped
42022	42075	break;
42023	42076	}
42024	42077
42025		- uint64_t newstack = (uint64_t )(stack[base + 35] - sizeof(uint64_t) * 4);
42026		- // call ~letdef from procblock
	42078	+ uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);
	42079	+ // call ~scope from procblock
42027	42080	newstack[0] = (uint64_t)stack; // backup stack location
42028	42081	newstack[1] = 1234567890;
42029	42082	newstack[2] = base;
42030		- newstack[3] = 3539LLU;
	42083	+ newstack[3] = 3545LLU;
42031	42084	stack = newstack;
42032	42085	// set stack-base & callee-address
42033	42086	base = 4/deloffset/;
42034		- label = 482LLU; // ~letdef
	42087	+ label = 558LLU; // ~scope
42035	42088	break;
42036	42089	}
42037		- case 3539LLU: // return from ~letdef to procblock
	42090	+ case 3545LLU: // return from ~scope to procblock
42038	42091	{
42039	42092	stack = (uint64_t *)stack[0];
42040	42093	// releasing toplevel container
42041		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 35] - sizeof(uint64_t) 4));
	42094	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
42042	42095
42043		- label = 3533LLU; // continue unrolling stack, delete next variable
	42096	+ label = 3541LLU; // continue unrolling stack, delete next variable
42044	42097	break;
42045	42098	}
42046		- case 3538LLU: // skipped deleter
	42099	+ case 3544LLU: // skipped deleter
42047	42100	{
42048		- // construct letdef.letdef
42049		- if(!(stack[base + 35] = construct(5)))
	42101	+ // call chainscope from procblock
	42102	+ stack[base + 34LLU] = 3546LLU/throw to this address/;
	42103	+ stack[base + 35LLU] = base;
	42104	+ stack[base + 36LLU] = 3547LLU;
	42105	+ // arguments for call to chainscope
	42106	+ stack[base + 38LLU] = stack[base + 32]/labelfail/;
	42107	+ // set stack-base & callee-address
	42108	+ base += 37LLU;
	42109	+ label = 575LLU; // chainscope
	42110	+ break;
	42111	+ }
	42112	+ case 3546LLU: // copy-back deleter (chainscope to procblock)
	42113	+ {
	42114	+ // copy mutable arguments back from call to chainscope
	42115	+ label = 3541LLU; // continue to roll stack
	42116	+ break;
	42117	+ }
	42118	+ case 3547LLU: // return from chainscope to procblock
	42119	+ {
	42120	+ // copy mutable arguments back from call to chainscope
	42121	+ // copy back results provided by call to chainscope
	42122	+ stack[base + 33] = stack[base + 37LLU];
	42123	+ swap(&stack[base + 3], &stack[base + 33]);
42050	42124	{
42051		- label = 3533LLU; // throw: begin to unroll stack
42052		- break;
42053		- }
42054		-
42055		- // consequent
42056		- ((uint64_t *)stack[base + 35])[0] = 0;
42057		- INIT(&(((uint64_t *)(stack[base + 35]))[1][0]), &stack[base + 32]/cptype*/);
42058		- (((uint64_t *)(stack[base + 35]))[1][1]) = stack[base + 26]/listname*/;
42059		- (((uint64_t *)(stack[base + 35]))[1][2]) = stack[base + 27]/listindex*/;
42060		- (((uint64_t *)(stack[base + 35]))[1][3]) = stack[base + 28]/listmut*/;
42061		- (((uint64_t *)(stack[base + 35]))[1][4]) = stack[base + 34]/substruct*/;
42062		- {
42063	42125	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
42064	42126	if(!list)
42065	42127	{
42066		- fprintf(stderr, "in function procblock push to [letdef]: OUT OF MEMORY!\n");
	42128	+ fprintf(stderr, "in function procblock push to [scope]: OUT OF MEMORY!\n");
42067	42129	label = stack[base - 3];
42068	42130	base = stack[base - 2];
42069	42131	break;
42070	42132	}
42071		- list->next = (struct listnode )stack[base + 31]/letdefs*/;
42072		- stack[base + 31]/letdefs/ = (uint64_t)list;
42073		- MOVE(&list->data, &stack[base + 35]/lock/);
	42133	+ list->next = (struct listnode )stack[base + 2]/scopes*/;
	42134	+ stack[base + 2]/scopes/ = (uint64_t)list;
	42135	+ MOVE(&list->data, &stack[base + 33]/newscope/);
42074	42136	}
42075		- ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 31];
42076		- ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 30];
42077		- label = 3521LLU; // case complete
	42137	+ if(/typelist/1 != ((uint64_t )(stack[base + 26]/listtype*/))[0])
	42138	+ {
	42139	+ label = 3549LLU; // jump to alternative
	42140	+ break;
	42141	+ }
	42142	+
	42143	+ /subtype/stack[base + 33] = ((uint64_t *)(stack[base + 26]/listtype/))[1][0]/subtype*/;
	42144	+
	42145	+ // case
	42146	+ label = 3552LLU; // skip deleter
42078	42147	break;
42079	42148	}
42080		- case 3523LLU: // copy-back deleter (switch)
	42149	+ case 3551LLU: // deleter
42081	42150	{
42082		- ((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 31];
42083		- ((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 30];
42084		- label = 3495LLU; // continue to unroll stack
	42151	+ // throw from procblock
	42152	+ if(!stack[base + 34])
	42153	+ {
	42154	+ label = 3550LLU; // skip, variable already deleted/unscoped
	42155	+ break;
	42156	+ }
	42157	+ label = 3550LLU; // continue unrolling stack, delete next variable
42085	42158	break;
42086	42159	}
42087		- case 3522LLU: // try next case
	42160	+ case 3552LLU: // skipped deleter
42088	42161	{
42089		- fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
42090		- exit(-1);
42091		- }
42092		- case 3521LLU: // completed switch
42093		- {
42094		- label = 3541LLU; // skip deleter
	42162	+ label = 3554LLU; // skip deleter
42095	42163	break;
42096	42164	}
42097		- case 3540LLU: // deleter
	42165	+ case 3553LLU: // deleter
42098	42166	{
42099	42167	// throw from procblock
42100		- if(!stack[base + 30])
	42168	+ if(!stack[base + 35])
42101	42169	{
42102		- label = 3495LLU; // skip, variable already deleted/unscoped
	42170	+ label = 3550LLU; // skip, variable already deleted/unscoped
42103	42171	break;
42104	42172	}
42105		- label = 3495LLU; // continue unrolling stack, delete next variable
	42173	+ label = 3550LLU; // continue unrolling stack, delete next variable
42106	42174	break;
42107	42175	}
42108		- case 3541LLU: // skipped deleter
	42176	+ case 3554LLU: // skipped deleter
42109	42177	{
42110		- // call getdeladdr from procblock
42111		- stack[base + 31LLU] = 3542LLU/throw to this address/;
42112		- stack[base + 32LLU] = base;
42113		- stack[base + 33LLU] = 3543LLU;
42114		- // arguments for call to getdeladdr
42115		- stack[base + 35LLU] = stack[base + 3]/scope/;
	42178	+ // call isparam from procblock
	42179	+ stack[base + 36LLU] = 3555LLU/throw to this address/;
	42180	+ stack[base + 37LLU] = base;
	42181	+ stack[base + 38LLU] = 3556LLU;
	42182	+ // arguments for call to isparam
	42183	+ stack[base + 40LLU] = stack[base + 10]/fnrescount/;
	42184	+ stack[base + 41LLU] = stack[base + 11]/fnargcount/;
	42185	+ stack[base + 42LLU] = stack[base + 28]/listindex/;
42116	42186	// set stack-base & callee-address
42117		- base += 34LLU;
42118		- label = 592LLU; // getdeladdr
	42187	+ base += 39LLU;
	42188	+ label = 1621LLU; // isparam
42119	42189	break;
42120	42190	}
42121		- case 3542LLU: // copy-back deleter (getdeladdr to procblock)
	42191	+ case 3555LLU: // copy-back deleter (isparam to procblock)
42122	42192	{
42123		- // copy mutable arguments back from call to getdeladdr
42124		- label = 3495LLU; // continue to roll stack
	42193	+ // copy mutable arguments back from call to isparam
	42194	+ label = 3550LLU; // continue to roll stack
42125	42195	break;
42126	42196	}
42127		- case 3543LLU: // return from getdeladdr to procblock
	42197	+ case 3556LLU: // return from isparam to procblock
42128	42198	{
42129		- // copy mutable arguments back from call to getdeladdr
42130		- // copy back results provided by call to getdeladdr
42131		- stack[base + 30] = stack[base + 34LLU];
42132		- // call add from procblock
42133		- stack[base + 31LLU] = 3544LLU/throw to this address/;
42134		- stack[base + 32LLU] = base;
42135		- stack[base + 33LLU] = 3545LLU;
42136		- // arguments for call to add
42137		- stack[base + 35LLU] = 1LLU;
42138		- stack[base + 36LLU] = stack[base + 17]/label/;
42139		- // set stack-base & callee-address
42140		- base += 34LLU;
42141		- label = 18446744073709551605LLU; // add
	42199	+ // copy mutable arguments back from call to isparam
	42200	+ // copy back results provided by call to isparam
	42201	+ stack[base + 35] = stack[base + 39LLU];
	42202	+ if(!stack[base + 29]/listmut/)
	42203	+ {
	42204	+ label = 3557LLU; // jump to alternative
	42205	+ break;
	42206	+ }
	42207	+
	42208	+ // consequent
	42209	+ label = 3560LLU; // skip deleter
42142	42210	break;
42143	42211	}
42144		- case 3544LLU: // copy-back deleter (add to procblock)
	42212	+ case 3559LLU: // deleter
42145	42213	{
42146		- // copy mutable arguments back from call to add
42147		- label = 3540LLU; // continue to roll stack
42148		- break;
42149		- }
42150		- case 3545LLU: // return from add to procblock
42151		- {
42152		- // copy mutable arguments back from call to add
42153		- // copy back results provided by call to add
42154		- stack[base + 17] = stack[base + 34LLU];
42155		- label = 3547LLU; // skip deleter
42156		- break;
42157		- }
42158		- case 3546LLU: // deleter
42159		- {
42160	42214	// throw from procblock
42161		- if(!stack[base + 31])
	42215	+ if(!stack[base + 34])
42162	42216	{
42163		- label = 3540LLU; // skip, variable already deleted/unscoped
	42217	+ label = 3553LLU; // skip, variable already deleted/unscoped
42164	42218	break;
42165	42219	}
42166		- label = 3540LLU; // continue unrolling stack, delete next variable
	42220	+ label = 3553LLU; // continue unrolling stack, delete next variable
42167	42221	break;
42168	42222	}
42169		- case 3547LLU: // skipped deleter
	42223	+ case 3560LLU: // skipped deleter
42170	42224	{
42171		- stack[base + 31] = stack[base + 17]/label/;
42172		- label = 3549LLU; // skip deleter
	42225	+ stack[base + 34] = 0;
	42226	+ label = 3558LLU; // consequent complete
42173	42227	break;
42174	42228	}
42175		- case 3548LLU: // deleter
	42229	+ case 3557LLU: // alternative
42176	42230	{
42177		- // throw from procblock
42178		- if(!stack[base + 32])
42179		- {
42180		- label = 3546LLU; // skip, variable already deleted/unscoped
42181		- break;
42182		- }
42183		-
42184		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
42185		- // call ~scope from procblock
42186		- newstack[0] = (uint64_t)stack; // backup stack location
42187		- newstack[1] = 1234567890;
42188		- newstack[2] = base;
42189		- newstack[3] = 3550LLU;
42190		- stack = newstack;
	42231	+ // call or from procblock
	42232	+ stack[base + 36LLU] = 3561LLU/throw to this address/;
	42233	+ stack[base + 37LLU] = base;
	42234	+ stack[base + 38LLU] = 3562LLU;
	42235	+ // arguments for call to or
	42236	+ stack[base + 40LLU] = stack[base + 30]/substruct/;
	42237	+ stack[base + 41LLU] = stack[base + 35]/listparam/;
42191	42238	// set stack-base & callee-address
42192		- base = 4/deloffset/;
42193		- label = 558LLU; // ~scope
	42239	+ base += 39LLU;
	42240	+ label = 18446744073709551611LLU; // or
42194	42241	break;
42195	42242	}
42196		- case 3550LLU: // return from ~scope to procblock
	42243	+ case 3561LLU: // copy-back deleter (or to procblock)
42197	42244	{
42198		- stack = (uint64_t *)stack[0];
42199		- // releasing toplevel container
42200		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
42201		-
42202		- label = 3546LLU; // continue unrolling stack, delete next variable
	42245	+ // copy mutable arguments back from call to or
	42246	+ label = 3553LLU; // continue to roll stack
42203	42247	break;
42204	42248	}
42205		- case 3549LLU: // skipped deleter
	42249	+ case 3562LLU: // return from or to procblock
42206	42250	{
42207		- // call chainscope from procblock
42208		- stack[base + 33LLU] = 3551LLU/throw to this address/;
42209		- stack[base + 34LLU] = base;
42210		- stack[base + 35LLU] = 3552LLU;
42211		- // arguments for call to chainscope
42212		- stack[base + 37LLU] = stack[base + 31]/labelfail/;
42213		- // set stack-base & callee-address
42214		- base += 36LLU;
42215		- label = 575LLU; // chainscope
	42251	+ // copy mutable arguments back from call to or
	42252	+ // copy back results provided by call to or
	42253	+ stack[base + 34] = stack[base + 39LLU];
	42254	+ label = 3558LLU; // alternative complete
42216	42255	break;
42217	42256	}
42218		- case 3551LLU: // copy-back deleter (chainscope to procblock)
	42257	+ case 3558LLU: // completed if-then-else
42219	42258	{
42220		- // copy mutable arguments back from call to chainscope
42221		- label = 3546LLU; // continue to roll stack
	42259	+ label = 3564LLU; // skip deleter
42222	42260	break;
42223	42261	}
42224		- case 3552LLU: // return from chainscope to procblock
	42262	+ case 3563LLU: // deleter
42225	42263	{
42226		- // copy mutable arguments back from call to chainscope
42227		- // copy back results provided by call to chainscope
42228		- stack[base + 32] = stack[base + 36LLU];
42229		- swap(&stack[base + 3], &stack[base + 32]);
42230		- {
42231		- struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));
42232		- if(!list)
42233		- {
42234		- fprintf(stderr, "in function procblock push to [scope]: OUT OF MEMORY!\n");
42235		- label = stack[base - 3];
42236		- base = stack[base - 2];
42237		- break;
42238		- }
42239		- list->next = (struct listnode )stack[base + 2]/scopes*/;
42240		- stack[base + 2]/scopes/ = (uint64_t)list;
42241		- MOVE(&list->data, &stack[base + 32]/newscope/);
42242		- }
42243		- if(/typelist/1 != ((uint64_t )(stack[base + 25]/listtype*/))[0])
42244		- {
42245		- label = 3554LLU; // jump to alternative
42246		- break;
42247		- }
42248		-
42249		- /subtype/stack[base + 32] = ((uint64_t *)(stack[base + 25]/listtype/))[1][0]/subtype*/;
42250		-
42251		- // case
42252		- label = 3557LLU; // skip deleter
42253		- break;
42254		- }
42255		- case 3556LLU: // deleter
42256		- {
42257	42264	// throw from procblock
42258		- if(!stack[base + 33])
	42265	+ if(!stack[base + 35])
42259	42266	{
42260		- label = 3555LLU; // skip, variable already deleted/unscoped
	42267	+ label = 3551LLU; // skip, variable already deleted/unscoped
42261	42268	break;
42262	42269	}
42263		- label = 3555LLU; // continue unrolling stack, delete next variable
	42270	+ label = 3551LLU; // continue unrolling stack, delete next variable
42264	42271	break;
42265	42272	}
42266		- case 3557LLU: // skipped deleter
	42273	+ case 3564LLU: // skipped deleter
42267	42274	{
42268	42275	// call newvarraw from procblock
42269		- stack[base + 34LLU] = 3558LLU/throw to this address/;
42270		- stack[base + 35LLU] = base;
42271		- stack[base + 36LLU] = 3559LLU;
	42276	+ stack[base + 36LLU] = 3565LLU/throw to this address/;
	42277	+ stack[base + 37LLU] = base;
	42278	+ stack[base + 38LLU] = 3566LLU;
42272	42279	// arguments for call to newvarraw
42273		- stack[base + 38LLU] = stack[base + 32]/subtype/;
42274		- stack[base + 39LLU] = stack[base + 16]/content/;
42275		- stack[base + 40LLU] = 1LLU;
42276		- stack[base + 41LLU] = stack[base + 10]/fnrescount/;
42277		- stack[base + 42LLU] = stack[base + 11]/fnargcount/;
42278		- stack[base + 43LLU] = stack[base + 12]/fnmaxcount/;
42279		- stack[base + 44LLU] = stack[base + 18]/varcount/;
42280		- stack[base + 45LLU] = stack[base + 3]/scope/;
42281		- stack[base + 46LLU] = 1LLU;
	42280	+ stack[base + 40LLU] = stack[base + 33]/subtype/;
	42281	+ stack[base + 41LLU] = stack[base + 16]/content/;
	42282	+ stack[base + 42LLU] = stack[base + 29]/listmut/;
	42283	+ stack[base + 43LLU] = stack[base + 10]/fnrescount/;
	42284	+ stack[base + 44LLU] = stack[base + 11]/fnargcount/;
	42285	+ stack[base + 45LLU] = stack[base + 12]/fnmaxcount/;
	42286	+ stack[base + 46LLU] = stack[base + 18]/varcount/;
	42287	+ stack[base + 47LLU] = stack[base + 3]/scope/;
	42288	+ stack[base + 48LLU] = stack[base + 34]/substruct/;
42282	42289	// set stack-base & callee-address
42283		- base += 37LLU;
	42290	+ base += 39LLU;
42284	42291	label = 755LLU; // newvarraw
42285	42292	break;
42286	42293	}
42287		- case 3558LLU: // copy-back deleter (newvarraw to procblock)
	42294	+ case 3565LLU: // copy-back deleter (newvarraw to procblock)
42288	42295	{
42289	42296	// copy mutable arguments back from call to newvarraw
42290		- stack[base + 3]/scope/ = stack[base + 45LLU];
42291		- stack[base + 18]/varcount/ = stack[base + 44LLU];
42292		- stack[base + 12]/fnmaxcount/ = stack[base + 43LLU];
42293		- label = 3555LLU; // continue to roll stack
	42297	+ stack[base + 3]/scope/ = stack[base + 47LLU];
	42298	+ stack[base + 18]/varcount/ = stack[base + 46LLU];
	42299	+ stack[base + 12]/fnmaxcount/ = stack[base + 45LLU];
	42300	+ label = 3551LLU; // continue to roll stack
42294	42301	break;
42295	42302	}
42296		- case 3559LLU: // return from newvarraw to procblock
	42303	+ case 3566LLU: // return from newvarraw to procblock
42297	42304	{
42298	42305	// copy mutable arguments back from call to newvarraw
42299		- stack[base + 3]/scope/ = stack[base + 45LLU];
42300		- stack[base + 18]/varcount/ = stack[base + 44LLU];
42301		- stack[base + 12]/fnmaxcount/ = stack[base + 43LLU];
	42306	+ stack[base + 3]/scope/ = stack[base + 47LLU];
	42307	+ stack[base + 18]/varcount/ = stack[base + 46LLU];
	42308	+ stack[base + 12]/fnmaxcount/ = stack[base + 45LLU];
42302	42309	// copy back results provided by call to newvarraw
42303		- stack[base + 33] = stack[base + 37LLU];
42304		- ((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 32];
42305		- label = 3553LLU; // case complete
	42310	+ stack[base + 35] = stack[base + 39LLU];
	42311	+ printf("%s", "\n {");
	42312	+ printf("%s", "\n label = ");
	42313	+ // call printnr from procblock
	42314	+ stack[base + 36LLU] = 3567LLU/throw to this address/;
	42315	+ stack[base + 37LLU] = base;
	42316	+ stack[base + 38LLU] = 3568LLU;
	42317	+ // arguments for call to printnr
	42318	+ stack[base + 39LLU] = stack[base + 22]/labelalt/;
	42319	+ // set stack-base & callee-address
	42320	+ base += 39LLU;
	42321	+ label = 18446744073709551590LLU; // printnr
42306	42322	break;
42307	42323	}
42308		- case 3555LLU: // copy-back deleter (switch)
	42324	+ case 3567LLU: // copy-back deleter (printnr to procblock)
42309	42325	{
42310		- ((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 32];
42311		- label = 3546LLU; // continue to unroll stack
	42326	+ // copy mutable arguments back from call to printnr
	42327	+ label = 3563LLU; // continue to roll stack
42312	42328	break;
42313	42329	}
42314		- case 3554LLU: // try next case
	42330	+ case 3568LLU: // return from printnr to procblock
42315	42331	{
42316		- // default
42317		- fprintf(stderr, "%s", "can only pop from list but type of ");
42318		- // call reportid from procblock
42319		- stack[base + 32LLU] = 3560LLU/throw to this address/;
42320		- stack[base + 33LLU] = base;
42321		- stack[base + 34LLU] = 3561LLU;
42322		- // arguments for call to reportid
42323		- stack[base + 35LLU] = stack[base + 26]/listname/;
	42332	+ // copy mutable arguments back from call to printnr
	42333	+ printf("%s", "LLU; // jump to alternative");
	42334	+ printf("%s", "\n break;");
	42335	+ printf("%s", "\n }");
	42336	+ printf("%s", "\n");
	42337	+ printf("%s", "\n // consequent");
	42338	+ // call matchsym from procblock
	42339	+ stack[base + 36LLU] = 3569LLU/throw to this address/;
	42340	+ stack[base + 37LLU] = base;
	42341	+ stack[base + 38LLU] = 3570LLU;
	42342	+ // arguments for call to matchsym
	42343	+ stack[base + 39LLU] = stack[base + 8]/fnid/;
	42344	+ stack[base + 40LLU] = 123LLU;
	42345	+ stack[base + 41LLU] = stack[base + 19]/lookahead/;
42324	42346	// set stack-base & callee-address
42325		- base += 35LLU;
42326		- label = 18446744073709551586LLU; // reportid
	42347	+ base += 39LLU;
	42348	+ label = 222LLU; // matchsym
42327	42349	break;
42328	42350	}
42329		- case 3560LLU: // copy-back deleter (reportid to procblock)
	42351	+ case 3569LLU: // copy-back deleter (matchsym to procblock)
42330	42352	{
42331		- // copy mutable arguments back from call to reportid
42332		- label = 3546LLU; // continue to roll stack
	42353	+ // copy mutable arguments back from call to matchsym
	42354	+ stack[base + 19]/lookahead/ = stack[base + 41LLU];
	42355	+ label = 3563LLU; // continue to roll stack
42333	42356	break;
42334	42357	}
42335		- case 3561LLU: // return from reportid to procblock
	42358	+ case 3570LLU: // return from matchsym to procblock
42336	42359	{
42337		- // copy mutable arguments back from call to reportid
42338		- fprintf(stderr, "%s", " is ");
42339		- uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
42340		- if(!newstack)
42341		- {
42342		- label = 3546LLU; // throw: begin to unroll stack
42343		- break;
42344		- }
42345		-
42346		- newstack[10LLU] = 9876543210LLU; // overflow-marker
42347		- // call reporttype from procblock
42348		- newstack[0] = (uint64_t)stack; // backup stack location
42349		- newstack[1] = 3562LLU;
42350		- newstack[2] = base;
42351		- newstack[3] = 3563LLU;
42352		- // arguments for call to reporttype
42353		- newstack[4LLU] = stack[base + 25]/listtype/;
42354		- stack = newstack;
	42360	+ // copy mutable arguments back from call to matchsym
	42361	+ stack[base + 19]/lookahead/ = stack[base + 41LLU];
	42362	+ printf("%s", "\n struct listnode *next = list->next;");
	42363	+ printf("%s", "\n /*");
	42364	+ // call printid from procblock
	42365	+ stack[base + 36LLU] = 3571LLU/throw to this address/;
	42366	+ stack[base + 37LLU] = base;
	42367	+ stack[base + 38LLU] = 3572LLU;
	42368	+ // arguments for call to printid
	42369	+ stack[base + 39LLU] = stack[base + 16]/content/;
42355	42370	// set stack-base & callee-address
42356		- base = 4/deloffset/;
42357		- label = 326LLU; // reporttype
	42371	+ base += 39LLU;
	42372	+ label = 18446744073709551587LLU; // printid
42358	42373	break;
42359	42374	}
42360		- case 3562LLU: // copy-back deleter (reporttype to procblock)
	42375	+ case 3571LLU: // copy-back deleter (printid to procblock)
42361	42376	{
42362		- uint64_t oldstack = (uint64_t )stack[0];
42363		- // copy mutable arguments back from call to reporttype
42364		- if(stack[10LLU] != 9876543210LLU)
42365		- {
42366		- fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!\n");
42367		- exit(-1);
42368		- }
42369		- Free(10LLU + 1, sizeof(uint64_t), stack);
42370		- stack = oldstack;
42371		- label = 3546LLU; // continue to unroll stack
	42377	+ // copy mutable arguments back from call to printid
	42378	+ label = 3563LLU; // continue to roll stack
42372	42379	break;
42373	42380	}
42374		- case 3563LLU: // return from reporttype to procblock
	42381	+ case 3572LLU: // return from printid to procblock
42375	42382	{
42376		- uint64_t oldstack = (uint64_t )stack[0];
42377		- // copy mutable arguments back from call to reporttype
42378		- if(stack[10LLU] != 9876543210LLU)
	42383	+ // copy mutable arguments back from call to printid
	42384	+ printf("%s", "*/");
	42385	+ // call emitvaridx from procblock
	42386	+ stack[base + 36LLU] = 3573LLU/throw to this address/;
	42387	+ stack[base + 37LLU] = base;
	42388	+ stack[base + 38LLU] = 3574LLU;
	42389	+ // arguments for call to emitvaridx
	42390	+ stack[base + 39LLU] = stack[base + 35]/elemindex/;
	42391	+ // set stack-base & callee-address
	42392	+ base += 39LLU;
	42393	+ label = 741LLU; // emitvaridx
	42394	+ break;
	42395	+ }
	42396	+ case 3573LLU: // copy-back deleter (emitvaridx to procblock)
	42397	+ {
	42398	+ // copy mutable arguments back from call to emitvaridx
	42399	+ label = 3563LLU; // continue to roll stack
	42400	+ break;
	42401	+ }
	42402	+ case 3574LLU: // return from emitvaridx to procblock
	42403	+ {
	42404	+ // copy mutable arguments back from call to emitvaridx
	42405	+ printf("%s", " = list->data;");
	42406	+ if(!stack[base + 24]/consume/)
42379	42407	{
42380		- fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!\n");
42381		- exit(-1);
42382		- }
42383		- Free(10LLU + 1, sizeof(uint64_t), stack);
42384		- stack = oldstack;
42385		- fprintf(stderr, "%s", "\n");
42386		- {
42387		- label = 3546LLU; // throw: begin to unroll stack
	42408	+ label = 3575LLU; // jump to alternative
42388	42409	break;
42389	42410	}
42390	42411
42391		- label = 3553LLU; // default complete
	42412	+ // consequent
	42413	+ printf("%s", "\n Free(1, sizeof(struct listnode), list);");
	42414	+ printf("%s", "\n /*");
	42415	+ // call printid from procblock
	42416	+ stack[base + 36LLU] = 3577LLU/throw to this address/;
	42417	+ stack[base + 37LLU] = base;
	42418	+ stack[base + 38LLU] = 3578LLU;
	42419	+ // arguments for call to printid
	42420	+ stack[base + 39LLU] = stack[base + 27]/listname/;
	42421	+ // set stack-base & callee-address
	42422	+ base += 39LLU;
	42423	+ label = 18446744073709551587LLU; // printid
42392	42424	break;
42393	42425	}
42394		- case 3553LLU: // completed switch
	42426	+ case 3577LLU: // copy-back deleter (printid to procblock)
42395	42427	{
42396		- if(!stack[base + 28]/listmut/)
	42428	+ // copy mutable arguments back from call to printid
	42429	+ label = 3563LLU; // continue to roll stack
	42430	+ break;
	42431	+ }
	42432	+ case 3578LLU: // return from printid to procblock
	42433	+ {
	42434	+ // copy mutable arguments back from call to printid
	42435	+ printf("%s", "*/");
	42436	+ // call emitvaridx from procblock
	42437	+ stack[base + 36LLU] = 3579LLU/throw to this address/;
	42438	+ stack[base + 37LLU] = base;
	42439	+ stack[base + 38LLU] = 3580LLU;
	42440	+ // arguments for call to emitvaridx
	42441	+ stack[base + 39LLU] = stack[base + 28]/listindex/;
	42442	+ // set stack-base & callee-address
	42443	+ base += 39LLU;
	42444	+ label = 741LLU; // emitvaridx
	42445	+ break;
	42446	+ }
	42447	+ case 3579LLU: // copy-back deleter (emitvaridx to procblock)
	42448	+ {
	42449	+ // copy mutable arguments back from call to emitvaridx
	42450	+ label = 3563LLU; // continue to roll stack
	42451	+ break;
	42452	+ }
	42453	+ case 3580LLU: // return from emitvaridx to procblock
	42454	+ {
	42455	+ // copy mutable arguments back from call to emitvaridx
	42456	+ printf("%s", " = (uint64_t)next;");
	42457	+ if(!stack[base + 29]/listmut/)
42397	42458	{
42398		- label = 3564LLU; // jump to alternative
	42459	+ label = 3581LLU; // jump to alternative
42399	42460	break;
42400	42461	}
42401	42462
42402	42463	// consequent
42403		- label = 3565LLU; // consequent complete
	42464	+ label = 3582LLU; // consequent complete
42404	42465	break;
42405	42466	}
42406		- case 3564LLU: // alternative
	42467	+ case 3581LLU: // alternative
42407	42468	{
	42469	+ fprintf(stderr, "%s", "in function ");
	42470	+ // call reportid from procblock
	42471	+ stack[base + 36LLU] = 3583LLU/throw to this address/;
	42472	+ stack[base + 37LLU] = base;
	42473	+ stack[base + 38LLU] = 3584LLU;
	42474	+ // arguments for call to reportid
	42475	+ stack[base + 39LLU] = stack[base + 8]/fnid/;
	42476	+ // set stack-base & callee-address
	42477	+ base += 39LLU;
	42478	+ label = 18446744073709551586LLU; // reportid
	42479	+ break;
	42480	+ }
	42481	+ case 3583LLU: // copy-back deleter (reportid to procblock)
	42482	+ {
	42483	+ // copy mutable arguments back from call to reportid
	42484	+ label = 3563LLU; // continue to roll stack
	42485	+ break;
	42486	+ }
	42487	+ case 3584LLU: // return from reportid to procblock
	42488	+ {
	42489	+ // copy mutable arguments back from call to reportid
	42490	+ fprintf(stderr, "%s", ": ");
42408	42491	fprintf(stderr, "%s", "can't pop from CONSTANT list ");
42409	42492	// call reportid from procblock
42410		- stack[base + 32LLU] = 3566LLU/throw to this address/;
42411		- stack[base + 33LLU] = base;
42412		- stack[base + 34LLU] = 3567LLU;
	42493	+ stack[base + 36LLU] = 3585LLU/throw to this address/;
	42494	+ stack[base + 37LLU] = base;
	42495	+ stack[base + 38LLU] = 3586LLU;
42413	42496	// arguments for call to reportid
42414		- stack[base + 35LLU] = stack[base + 26]/listname/;
	42497	+ stack[base + 39LLU] = stack[base + 27]/listname/;
42415	42498	// set stack-base & callee-address
42416		- base += 35LLU;
	42499	+ base += 39LLU;
42417	42500	label = 18446744073709551586LLU; // reportid
42418	42501	break;
42419	42502	}
42420		- case 3566LLU: // copy-back deleter (reportid to procblock)
	42503	+ case 3585LLU: // copy-back deleter (reportid to procblock)
42421	42504	{
42422	42505	// copy mutable arguments back from call to reportid
42423		- label = 3546LLU; // continue to roll stack
	42506	+ label = 3563LLU; // continue to roll stack
42424	42507	break;
42425	42508	}
42426		- case 3567LLU: // return from reportid to procblock
	42509	+ case 3586LLU: // return from reportid to procblock
42427	42510	{
42428	42511	// copy mutable arguments back from call to reportid
42429	42512	fprintf(stderr, "%s", " of type ");

		@@ -42430,7 +42513,7 @@
42430	42513	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
42431	42514	if(!newstack)
42432	42515	{
42433		- label = 3546LLU; // throw: begin to unroll stack
	42516	+ label = 3563LLU; // throw: begin to unroll stack
42434	42517	break;
42435	42518	}
42436	42519

		@@ -42437,11 +42520,11 @@
42437	42520	newstack[10LLU] = 9876543210LLU; // overflow-marker
42438	42521	// call reporttype from procblock
42439	42522	newstack[0] = (uint64_t)stack; // backup stack location
42440		- newstack[1] = 3568LLU;
	42523	+ newstack[1] = 3587LLU;
42441	42524	newstack[2] = base;
42442		- newstack[3] = 3569LLU;
	42525	+ newstack[3] = 3588LLU;
42443	42526	// arguments for call to reporttype
42444		- newstack[4LLU] = stack[base + 25]/listtype/;
	42527	+ newstack[4LLU] = stack[base + 26]/listtype/;
42445	42528	stack = newstack;
42446	42529	// set stack-base & callee-address
42447	42530	base = 4/deloffset/;

		@@ -42448,7 +42531,7 @@
42448	42531	label = 326LLU; // reporttype
42449	42532	break;
42450	42533	}
42451		- case 3568LLU: // copy-back deleter (reporttype to procblock)
	42534	+ case 3587LLU: // copy-back deleter (reporttype to procblock)
42452	42535	{
42453	42536	uint64_t oldstack = (uint64_t )stack[0];
42454	42537	// copy mutable arguments back from call to reporttype

		@@ -42459,10 +42542,10 @@
42459	42542	}
42460	42543	Free(10LLU + 1, sizeof(uint64_t), stack);
42461	42544	stack = oldstack;
42462		- label = 3546LLU; // continue to unroll stack
	42545	+ label = 3563LLU; // continue to unroll stack
42463	42546	break;
42464	42547	}
42465		- case 3569LLU: // return from reporttype to procblock
	42548	+ case 3588LLU: // return from reporttype to procblock
42466	42549	{
42467	42550	uint64_t oldstack = (uint64_t )stack[0];
42468	42551	// copy mutable arguments back from call to reporttype

		@@ -42475,122 +42558,124 @@
42475	42558	stack = oldstack;
42476	42559	fprintf(stderr, "%s", "\n");
42477	42560	{
42478		- label = 3546LLU; // throw: begin to unroll stack
	42561	+ label = 3563LLU; // throw: begin to unroll stack
42479	42562	break;
42480	42563	}
42481	42564
42482		- label = 3565LLU; // alternative complete
	42565	+ label = 3582LLU; // alternative complete
42483	42566	break;
42484	42567	}
42485		- case 3565LLU: // completed if-then-else
	42568	+ case 3582LLU: // completed if-then-else
42486	42569	{
42487		- printf("%s", "\n {");
42488		- printf("%s", "\n label = ");
42489		- // call printnr from procblock
42490		- stack[base + 32LLU] = 3570LLU/throw to this address/;
42491		- stack[base + 33LLU] = base;
42492		- stack[base + 34LLU] = 3571LLU;
42493		- // arguments for call to printnr
42494		- stack[base + 35LLU] = stack[base + 22]/labelalt/;
42495		- // set stack-base & callee-address
42496		- base += 35LLU;
42497		- label = 18446744073709551590LLU; // printnr
	42570	+ label = 3576LLU; // consequent complete
42498	42571	break;
42499	42572	}
42500		- case 3570LLU: // copy-back deleter (printnr to procblock)
	42573	+ case 3575LLU: // alternative
42501	42574	{
42502		- // copy mutable arguments back from call to printnr
42503		- label = 3546LLU; // continue to roll stack
	42575	+ label = 3590LLU; // skip deleter
42504	42576	break;
42505	42577	}
42506		- case 3571LLU: // return from printnr to procblock
	42578	+ case 3589LLU: // deleter
42507	42579	{
42508		- // copy mutable arguments back from call to printnr
42509		- printf("%s", "LLU; // jump to alternative");
42510		- printf("%s", "\n break;");
42511		- printf("%s", "\n }");
42512		- printf("%s", "\n");
42513		- printf("%s", "\n // consequent");
42514		- // call matchsym from procblock
42515		- stack[base + 32LLU] = 3572LLU/throw to this address/;
42516		- stack[base + 33LLU] = base;
42517		- stack[base + 34LLU] = 3573LLU;
42518		- // arguments for call to matchsym
42519		- stack[base + 35LLU] = stack[base + 8]/fnid/;
42520		- stack[base + 36LLU] = 123LLU;
42521		- stack[base + 37LLU] = stack[base + 19]/lookahead/;
	42580	+ // throw from procblock
	42581	+ if(!stack[base + 36])
	42582	+ {
	42583	+ label = 3563LLU; // skip, variable already deleted/unscoped
	42584	+ break;
	42585	+ }
	42586	+ label = 3563LLU; // continue unrolling stack, delete next variable
	42587	+ break;
	42588	+ }
	42589	+ case 3590LLU: // skipped deleter
	42590	+ {
	42591	+ // call newvarraw from procblock
	42592	+ stack[base + 37LLU] = 3591LLU/throw to this address/;
	42593	+ stack[base + 38LLU] = base;
	42594	+ stack[base + 39LLU] = 3592LLU;
	42595	+ // arguments for call to newvarraw
	42596	+ stack[base + 41LLU] = stack[base + 26]/listtype/;
	42597	+ stack[base + 42LLU] = stack[base + 27]/listname/;
	42598	+ stack[base + 43LLU] = stack[base + 29]/listmut/;
	42599	+ stack[base + 44LLU] = stack[base + 10]/fnrescount/;
	42600	+ stack[base + 45LLU] = stack[base + 11]/fnargcount/;
	42601	+ stack[base + 46LLU] = stack[base + 12]/fnmaxcount/;
	42602	+ stack[base + 47LLU] = stack[base + 18]/varcount/;
	42603	+ stack[base + 48LLU] = stack[base + 3]/scope/;
	42604	+ stack[base + 49LLU] = stack[base + 34]/substruct/;
42522	42605	// set stack-base & callee-address
42523		- base += 35LLU;
42524		- label = 222LLU; // matchsym
	42606	+ base += 40LLU;
	42607	+ label = 755LLU; // newvarraw
42525	42608	break;
42526	42609	}
42527		- case 3572LLU: // copy-back deleter (matchsym to procblock)
	42610	+ case 3591LLU: // copy-back deleter (newvarraw to procblock)
42528	42611	{
42529		- // copy mutable arguments back from call to matchsym
42530		- stack[base + 19]/lookahead/ = stack[base + 37LLU];
42531		- label = 3546LLU; // continue to roll stack
	42612	+ // copy mutable arguments back from call to newvarraw
	42613	+ stack[base + 3]/scope/ = stack[base + 48LLU];
	42614	+ stack[base + 18]/varcount/ = stack[base + 47LLU];
	42615	+ stack[base + 12]/fnmaxcount/ = stack[base + 46LLU];
	42616	+ label = 3563LLU; // continue to roll stack
42532	42617	break;
42533	42618	}
42534		- case 3573LLU: // return from matchsym to procblock
	42619	+ case 3592LLU: // return from newvarraw to procblock
42535	42620	{
42536		- // copy mutable arguments back from call to matchsym
42537		- stack[base + 19]/lookahead/ = stack[base + 37LLU];
42538		- printf("%s", "\n struct listnode *next = list->next;");
42539		- printf("%s", "\n ");
42540		- // call emitvar from procblock
42541		- stack[base + 32LLU] = 3574LLU/throw to this address/;
42542		- stack[base + 33LLU] = base;
42543		- stack[base + 34LLU] = 3575LLU;
42544		- // arguments for call to emitvar
42545		- stack[base + 35LLU] = stack[base + 8]/fnid/;
42546		- stack[base + 36LLU] = stack[base + 16]/content/;
42547		- stack[base + 37LLU] = stack[base + 2]/scopes/;
42548		- stack[base + 38LLU] = stack[base + 3]/scope/;
	42621	+ // copy mutable arguments back from call to newvarraw
	42622	+ stack[base + 3]/scope/ = stack[base + 48LLU];
	42623	+ stack[base + 18]/varcount/ = stack[base + 47LLU];
	42624	+ stack[base + 12]/fnmaxcount/ = stack[base + 46LLU];
	42625	+ // copy back results provided by call to newvarraw
	42626	+ stack[base + 36] = stack[base + 40LLU];
	42627	+ printf("%s", "\n /*");
	42628	+ // call printid from procblock
	42629	+ stack[base + 37LLU] = 3593LLU/throw to this address/;
	42630	+ stack[base + 38LLU] = base;
	42631	+ stack[base + 39LLU] = 3594LLU;
	42632	+ // arguments for call to printid
	42633	+ stack[base + 40LLU] = stack[base + 27]/listname/;
42549	42634	// set stack-base & callee-address
42550		- base += 35LLU;
42551		- label = 745LLU; // emitvar
	42635	+ base += 40LLU;
	42636	+ label = 18446744073709551587LLU; // printid
42552	42637	break;
42553	42638	}
42554		- case 3574LLU: // copy-back deleter (emitvar to procblock)
	42639	+ case 3593LLU: // copy-back deleter (printid to procblock)
42555	42640	{
42556		- // copy mutable arguments back from call to emitvar
42557		- label = 3546LLU; // continue to roll stack
	42641	+ // copy mutable arguments back from call to printid
	42642	+ label = 3589LLU; // continue to roll stack
42558	42643	break;
42559	42644	}
42560		- case 3575LLU: // return from emitvar to procblock
	42645	+ case 3594LLU: // return from printid to procblock
42561	42646	{
42562		- // copy mutable arguments back from call to emitvar
42563		- printf("%s", " = list->data;");
42564		- printf("%s", "\n Free(1, sizeof(struct listnode), list);");
42565		- printf("%s", "\n ");
42566		- // call emitvar from procblock
42567		- stack[base + 32LLU] = 3576LLU/throw to this address/;
42568		- stack[base + 33LLU] = base;
42569		- stack[base + 34LLU] = 3577LLU;
42570		- // arguments for call to emitvar
42571		- stack[base + 35LLU] = stack[base + 8]/fnid/;
42572		- stack[base + 36LLU] = stack[base + 26]/listname/;
42573		- stack[base + 37LLU] = stack[base + 2]/scopes/;
42574		- stack[base + 38LLU] = stack[base + 3]/scope/;
	42647	+ // copy mutable arguments back from call to printid
	42648	+ printf("%s", "*/");
	42649	+ // call emitvaridx from procblock
	42650	+ stack[base + 37LLU] = 3595LLU/throw to this address/;
	42651	+ stack[base + 38LLU] = base;
	42652	+ stack[base + 39LLU] = 3596LLU;
	42653	+ // arguments for call to emitvaridx
	42654	+ stack[base + 40LLU] = stack[base + 36]/restindex/;
42575	42655	// set stack-base & callee-address
42576		- base += 35LLU;
42577		- label = 745LLU; // emitvar
	42656	+ base += 40LLU;
	42657	+ label = 741LLU; // emitvaridx
42578	42658	break;
42579	42659	}
42580		- case 3576LLU: // copy-back deleter (emitvar to procblock)
	42660	+ case 3595LLU: // copy-back deleter (emitvaridx to procblock)
42581	42661	{
42582		- // copy mutable arguments back from call to emitvar
42583		- label = 3546LLU; // continue to roll stack
	42662	+ // copy mutable arguments back from call to emitvaridx
	42663	+ label = 3589LLU; // continue to roll stack
42584	42664	break;
42585	42665	}
42586		- case 3577LLU: // return from emitvar to procblock
	42666	+ case 3596LLU: // return from emitvaridx to procblock
42587	42667	{
42588		- // copy mutable arguments back from call to emitvar
	42668	+ // copy mutable arguments back from call to emitvaridx
42589	42669	printf("%s", " = (uint64_t)next;");
	42670	+ label = 3576LLU; // alternative complete
	42671	+ break;
	42672	+ }
	42673	+ case 3576LLU: // completed if-then-else
	42674	+ {
42590	42675	printf("%s", "\n }");
42591	42676	if(!stack[base + 21]/returnflag/)
42592	42677	{
42593		- label = 3578LLU; // jump to alternative
	42678	+ label = 3597LLU; // jump to alternative
42594	42679	break;
42595	42680	}
42596	42681

		@@ -42598,7 +42683,7 @@
42598	42683	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
42599	42684	if(!newstack)
42600	42685	{
42601		- label = 3546LLU; // throw: begin to unroll stack
	42686	+ label = 3563LLU; // throw: begin to unroll stack
42602	42687	break;
42603	42688	}
42604	42689

		@@ -42605,9 +42690,9 @@
42605	42690	newstack[160LLU] = 9876543210LLU; // overflow-marker
42606	42691	// call procblock from procblock
42607	42692	newstack[0] = (uint64_t)stack; // backup stack location
42608		- newstack[1] = 3580LLU;
	42693	+ newstack[1] = 3599LLU;
42609	42694	newstack[2] = base;
42610		- newstack[3] = 3581LLU;
	42695	+ newstack[3] = 3600LLU;
42611	42696	// arguments for call to procblock
42612	42697	newstack[4LLU] = stack[base + 0]/fndefs/;
42613	42698	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -42633,7 +42718,7 @@
42633	42718	label = 3319LLU; // procblock
42634	42719	break;
42635	42720	}
42636		- case 3580LLU: // copy-back deleter (procblock to procblock)
	42721	+ case 3599LLU: // copy-back deleter (procblock to procblock)
42637	42722	{
42638	42723	uint64_t oldstack = (uint64_t )stack[0];
42639	42724	// copy mutable arguments back from call to procblock

		@@ -42650,10 +42735,10 @@
42650	42735	}
42651	42736	Free(160LLU + 1, sizeof(uint64_t), stack);
42652	42737	stack = oldstack;
42653		- label = 3546LLU; // continue to unroll stack
	42738	+ label = 3563LLU; // continue to unroll stack
42654	42739	break;
42655	42740	}
42656		- case 3581LLU: // return from procblock to procblock
	42741	+ case 3600LLU: // return from procblock to procblock
42657	42742	{
42658	42743	uint64_t oldstack = (uint64_t )stack[0];
42659	42744	// copy mutable arguments back from call to procblock

		@@ -42670,42 +42755,42 @@
42670	42755	}
42671	42756	Free(160LLU + 1, sizeof(uint64_t), stack);
42672	42757	stack = oldstack;
42673		- label = 3579LLU; // consequent complete
	42758	+ label = 3598LLU; // consequent complete
42674	42759	break;
42675	42760	}
42676		- case 3578LLU: // alternative
	42761	+ case 3597LLU: // alternative
42677	42762	{
42678		- label = 3583LLU; // skip deleter
	42763	+ label = 3602LLU; // skip deleter
42679	42764	break;
42680	42765	}
42681		- case 3582LLU: // deleter
	42766	+ case 3601LLU: // deleter
42682	42767	{
42683	42768	// throw from procblock
42684		- if(!stack[base + 32])
	42769	+ if(!stack[base + 36])
42685	42770	{
42686		- label = 3546LLU; // skip, variable already deleted/unscoped
	42771	+ label = 3563LLU; // skip, variable already deleted/unscoped
42687	42772	break;
42688	42773	}
42689	42774	// delete list
42690		- label = 3584LLU; // start to repeat
	42775	+ label = 3603LLU; // start to repeat
42691	42776	break;
42692	42777	}
42693		- case 3584LLU: // repeat from here
	42778	+ case 3603LLU: // repeat from here
42694	42779	{
42695		- if(!stack[base + 32])
	42780	+ if(!stack[base + 36])
42696	42781	{
42697		- label = 3585LLU; // break loop
	42782	+ label = 3604LLU; // break loop
42698	42783	break;
42699	42784	}
42700	42785
42701	42786	// delete list loop body
42702	42787
42703		- uint64_t newstack = (uint64_t )(((struct listnode )stack[base + 32])->data - sizeof(uint64_t) 4);
	42788	+ uint64_t newstack = (uint64_t )(((struct listnode )stack[base + 36])->data - sizeof(uint64_t) 4);
42704	42789	// call ~typeidx from procblock
42705	42790	newstack[0] = (uint64_t)stack; // backup stack location
42706	42791	newstack[1] = 1234567890;
42707	42792	newstack[2] = base;
42708		- newstack[3] = 3586LLU;
	42793	+ newstack[3] = 3605LLU;
42709	42794	stack = newstack;
42710	42795	// set stack-base & callee-address
42711	42796	base = 4/deloffset/;

		@@ -42712,32 +42797,32 @@
42712	42797	label = 395LLU; // ~typeidx
42713	42798	break;
42714	42799	}
42715		- case 3586LLU: // return from ~typeidx to procblock
	42800	+ case 3605LLU: // return from ~typeidx to procblock
42716	42801	{
42717	42802	stack = (uint64_t *)stack[0];
42718	42803	// releasing toplevel container
42719		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(((struct listnode )stack[base + 32])->data - sizeof(uint64_t) * 4));
	42804	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(((struct listnode )stack[base + 36])->data - sizeof(uint64_t) * 4));
42720	42805
42721	42806	{
42722		- struct listnode list = (struct listnode )stack[base + 32];
42723		- stack[base + 32] = (uint64_t)list->next;
	42807	+ struct listnode list = (struct listnode )stack[base + 36];
	42808	+ stack[base + 36] = (uint64_t)list->next;
42724	42809	Free(1, sizeof(struct listnode), list);
42725	42810	}
42726		- label = 3584LLU; // repeat
	42811	+ label = 3603LLU; // repeat
42727	42812	break;
42728	42813	}
42729		- case 3585LLU: // loop finished
	42814	+ case 3604LLU: // loop finished
42730	42815	{
42731		- label = 3546LLU; // continue unrolling stack, delete next variable
	42816	+ label = 3563LLU; // continue unrolling stack, delete next variable
42732	42817	break;
42733	42818	}
42734		- case 3583LLU: // skipped deleter
	42819	+ case 3602LLU: // skipped deleter
42735	42820	{
42736		- stack[base + 32] = 0;
	42821	+ stack[base + 36] = 0;
42737	42822	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
42738	42823	if(!newstack)
42739	42824	{
42740		- label = 3582LLU; // throw: begin to unroll stack
	42825	+ label = 3601LLU; // throw: begin to unroll stack
42741	42826	break;
42742	42827	}
42743	42828

		@@ -42744,15 +42829,15 @@
42744	42829	newstack[160LLU] = 9876543210LLU; // overflow-marker
42745	42830	// call procblock from procblock
42746	42831	newstack[0] = (uint64_t)stack; // backup stack location
42747		- newstack[1] = 3587LLU;
	42832	+ newstack[1] = 3606LLU;
42748	42833	newstack[2] = base;
42749		- newstack[3] = 3588LLU;
	42834	+ newstack[3] = 3607LLU;
42750	42835	// arguments for call to procblock
42751	42836	newstack[4LLU] = stack[base + 0]/fndefs/;
42752	42837	newstack[5LLU] = stack[base + 1]/typedefs/;
42753	42838	newstack[6LLU] = stack[base + 2]/scopes/;
42754	42839	newstack[7LLU] = stack[base + 3]/scope/;
42755		- newstack[8LLU] = stack[base + 32]/blkresults/;
	42840	+ newstack[8LLU] = stack[base + 36]/blkresults/;
42756	42841	newstack[9LLU] = stack[base + 5]/fnrec/;
42757	42842	newstack[10LLU] = stack[base + 6]/fncanthrow/;
42758	42843	newstack[11LLU] = stack[base + 7]/fnIO/;

		@@ -42772,7 +42857,7 @@
42772	42857	label = 3319LLU; // procblock
42773	42858	break;
42774	42859	}
42775		- case 3587LLU: // copy-back deleter (procblock to procblock)
	42860	+ case 3606LLU: // copy-back deleter (procblock to procblock)
42776	42861	{
42777	42862	uint64_t oldstack = (uint64_t )stack[0];
42778	42863	// copy mutable arguments back from call to procblock

		@@ -42789,10 +42874,10 @@
42789	42874	}
42790	42875	Free(160LLU + 1, sizeof(uint64_t), stack);
42791	42876	stack = oldstack;
42792		- label = 3582LLU; // continue to unroll stack
	42877	+ label = 3601LLU; // continue to unroll stack
42793	42878	break;
42794	42879	}
42795		- case 3588LLU: // return from procblock to procblock
	42880	+ case 3607LLU: // return from procblock to procblock
42796	42881	{
42797	42882	uint64_t oldstack = (uint64_t )stack[0];
42798	42883	// copy mutable arguments back from call to procblock

		@@ -42810,25 +42895,25 @@
42810	42895	Free(160LLU + 1, sizeof(uint64_t), stack);
42811	42896	stack = oldstack;
42812	42897	// delete list
42813		- label = 3589LLU; // start to repeat
	42898	+ label = 3608LLU; // start to repeat
42814	42899	break;
42815	42900	}
42816		- case 3589LLU: // repeat from here
	42901	+ case 3608LLU: // repeat from here
42817	42902	{
42818		- if(!stack[base + 32])
	42903	+ if(!stack[base + 36])
42819	42904	{
42820		- label = 3590LLU; // break loop
	42905	+ label = 3609LLU; // break loop
42821	42906	break;
42822	42907	}
42823	42908
42824	42909	// delete list loop body
42825	42910
42826		- uint64_t newstack = (uint64_t )(((struct listnode )stack[base + 32])->data - sizeof(uint64_t) 4);
	42911	+ uint64_t newstack = (uint64_t )(((struct listnode )stack[base + 36])->data - sizeof(uint64_t) 4);
42827	42912	// call ~typeidx from procblock
42828	42913	newstack[0] = (uint64_t)stack; // backup stack location
42829	42914	newstack[1] = 1234567890;
42830	42915	newstack[2] = base;
42831		- newstack[3] = 3591LLU;
	42916	+ newstack[3] = 3610LLU;
42832	42917	stack = newstack;
42833	42918	// set stack-base & callee-address
42834	42919	base = 4/deloffset/;

		@@ -42835,71 +42920,78 @@
42835	42920	label = 395LLU; // ~typeidx
42836	42921	break;
42837	42922	}
42838		- case 3591LLU: // return from ~typeidx to procblock
	42923	+ case 3610LLU: // return from ~typeidx to procblock
42839	42924	{
42840	42925	stack = (uint64_t *)stack[0];
42841	42926	// releasing toplevel container
42842		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(((struct listnode )stack[base + 32])->data - sizeof(uint64_t) * 4));
	42927	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(((struct listnode )stack[base + 36])->data - sizeof(uint64_t) * 4));
42843	42928
42844	42929	{
42845		- struct listnode list = (struct listnode )stack[base + 32];
42846		- stack[base + 32] = (uint64_t)list->next;
	42930	+ struct listnode list = (struct listnode )stack[base + 36];
	42931	+ stack[base + 36] = (uint64_t)list->next;
42847	42932	Free(1, sizeof(struct listnode), list);
42848	42933	}
42849		- label = 3589LLU; // repeat
	42934	+ label = 3608LLU; // repeat
42850	42935	break;
42851	42936	}
42852		- case 3590LLU: // loop finished
	42937	+ case 3609LLU: // loop finished
42853	42938	{
42854		- label = 3579LLU; // alternative complete
	42939	+ label = 3598LLU; // alternative complete
42855	42940	break;
42856	42941	}
42857		- case 3579LLU: // completed if-then-else
	42942	+ case 3598LLU: // completed if-then-else
42858	42943	{
	42944	+ if(!stack[base + 24]/consume/)
	42945	+ {
	42946	+ label = 3611LLU; // jump to alternative
	42947	+ break;
	42948	+ }
	42949	+
	42950	+ // consequent
42859	42951	// call closescope from procblock
42860		- stack[base + 32LLU] = 3592LLU/throw to this address/;
42861		- stack[base + 33LLU] = base;
42862		- stack[base + 34LLU] = 3593LLU;
	42952	+ stack[base + 36LLU] = 3613LLU/throw to this address/;
	42953	+ stack[base + 37LLU] = base;
	42954	+ stack[base + 38LLU] = 3614LLU;
42863	42955	// arguments for call to closescope
42864		- stack[base + 35LLU] = stack[base + 8]/fnid/;
42865		- stack[base + 36LLU] = stack[base + 1]/typedefs/;
42866		- stack[base + 37LLU] = stack[base + 3]/scope/;
42867		- stack[base + 38LLU] = stack[base + 17]/label/;
	42956	+ stack[base + 39LLU] = stack[base + 8]/fnid/;
	42957	+ stack[base + 40LLU] = stack[base + 1]/typedefs/;
	42958	+ stack[base + 41LLU] = stack[base + 3]/scope/;
	42959	+ stack[base + 42LLU] = stack[base + 17]/label/;
42868	42960	// set stack-base & callee-address
42869		- base += 35LLU;
	42961	+ base += 39LLU;
42870	42962	label = 3246LLU; // closescope
42871	42963	break;
42872	42964	}
42873		- case 3592LLU: // copy-back deleter (closescope to procblock)
	42965	+ case 3613LLU: // copy-back deleter (closescope to procblock)
42874	42966	{
42875	42967	// copy mutable arguments back from call to closescope
42876		- stack[base + 17]/label/ = stack[base + 38LLU];
42877		- label = 3546LLU; // continue to roll stack
	42968	+ stack[base + 17]/label/ = stack[base + 42LLU];
	42969	+ label = 3563LLU; // continue to roll stack
42878	42970	break;
42879	42971	}
42880		- case 3593LLU: // return from closescope to procblock
	42972	+ case 3614LLU: // return from closescope to procblock
42881	42973	{
42882	42974	// copy mutable arguments back from call to closescope
42883		- stack[base + 17]/label/ = stack[base + 38LLU];
	42975	+ stack[base + 17]/label/ = stack[base + 42LLU];
42884	42976	printf("%s", "\n label = ");
42885	42977	// call printnr from procblock
42886		- stack[base + 32LLU] = 3594LLU/throw to this address/;
42887		- stack[base + 33LLU] = base;
42888		- stack[base + 34LLU] = 3595LLU;
	42978	+ stack[base + 36LLU] = 3615LLU/throw to this address/;
	42979	+ stack[base + 37LLU] = base;
	42980	+ stack[base + 38LLU] = 3616LLU;
42889	42981	// arguments for call to printnr
42890		- stack[base + 35LLU] = stack[base + 23]/labelskip/;
	42982	+ stack[base + 39LLU] = stack[base + 23]/labelskip/;
42891	42983	// set stack-base & callee-address
42892		- base += 35LLU;
	42984	+ base += 39LLU;
42893	42985	label = 18446744073709551590LLU; // printnr
42894	42986	break;
42895	42987	}
42896		- case 3594LLU: // copy-back deleter (printnr to procblock)
	42988	+ case 3615LLU: // copy-back deleter (printnr to procblock)
42897	42989	{
42898	42990	// copy mutable arguments back from call to printnr
42899		- label = 3546LLU; // continue to roll stack
	42991	+ label = 3563LLU; // continue to roll stack
42900	42992	break;
42901	42993	}
42902		- case 3595LLU: // return from printnr to procblock
	42994	+ case 3616LLU: // return from printnr to procblock
42903	42995	{
42904	42996	// copy mutable arguments back from call to printnr
42905	42997	printf("%s", "LLU; // consequent complete");

		@@ -42907,71 +42999,71 @@
42907	42999	printf("%s", "\n }");
42908	43000	printf("%s", "\n case ");
42909	43001	// call printnr from procblock
42910		- stack[base + 32LLU] = 3596LLU/throw to this address/;
42911		- stack[base + 33LLU] = base;
42912		- stack[base + 34LLU] = 3597LLU;
	43002	+ stack[base + 36LLU] = 3617LLU/throw to this address/;
	43003	+ stack[base + 37LLU] = base;
	43004	+ stack[base + 38LLU] = 3618LLU;
42913	43005	// arguments for call to printnr
42914		- stack[base + 35LLU] = stack[base + 31]/labelfail/;
	43006	+ stack[base + 39LLU] = stack[base + 32]/labelfail/;
42915	43007	// set stack-base & callee-address
42916		- base += 35LLU;
	43008	+ base += 39LLU;
42917	43009	label = 18446744073709551590LLU; // printnr
42918	43010	break;
42919	43011	}
42920		- case 3596LLU: // copy-back deleter (printnr to procblock)
	43012	+ case 3617LLU: // copy-back deleter (printnr to procblock)
42921	43013	{
42922	43014	// copy mutable arguments back from call to printnr
42923		- label = 3546LLU; // continue to roll stack
	43015	+ label = 3563LLU; // continue to roll stack
42924	43016	break;
42925	43017	}
42926		- case 3597LLU: // return from printnr to procblock
	43018	+ case 3618LLU: // return from printnr to procblock
42927	43019	{
42928	43020	// copy mutable arguments back from call to printnr
42929	43021	printf("%s", "LLU: // copy-back deleter (if pop)");
42930	43022	printf("%s", "\n {");
42931	43023	// call closescope from procblock
42932		- stack[base + 32LLU] = 3598LLU/throw to this address/;
42933		- stack[base + 33LLU] = base;
42934		- stack[base + 34LLU] = 3599LLU;
	43024	+ stack[base + 36LLU] = 3619LLU/throw to this address/;
	43025	+ stack[base + 37LLU] = base;
	43026	+ stack[base + 38LLU] = 3620LLU;
42935	43027	// arguments for call to closescope
42936		- stack[base + 35LLU] = stack[base + 8]/fnid/;
42937		- stack[base + 36LLU] = stack[base + 1]/typedefs/;
42938		- stack[base + 37LLU] = stack[base + 3]/scope/;
42939		- stack[base + 38LLU] = stack[base + 17]/label/;
	43028	+ stack[base + 39LLU] = stack[base + 8]/fnid/;
	43029	+ stack[base + 40LLU] = stack[base + 1]/typedefs/;
	43030	+ stack[base + 41LLU] = stack[base + 3]/scope/;
	43031	+ stack[base + 42LLU] = stack[base + 17]/label/;
42940	43032	// set stack-base & callee-address
42941		- base += 35LLU;
	43033	+ base += 39LLU;
42942	43034	label = 3246LLU; // closescope
42943	43035	break;
42944	43036	}
42945		- case 3598LLU: // copy-back deleter (closescope to procblock)
	43037	+ case 3619LLU: // copy-back deleter (closescope to procblock)
42946	43038	{
42947	43039	// copy mutable arguments back from call to closescope
42948		- stack[base + 17]/label/ = stack[base + 38LLU];
42949		- label = 3546LLU; // continue to roll stack
	43040	+ stack[base + 17]/label/ = stack[base + 42LLU];
	43041	+ label = 3563LLU; // continue to roll stack
42950	43042	break;
42951	43043	}
42952		- case 3599LLU: // return from closescope to procblock
	43044	+ case 3620LLU: // return from closescope to procblock
42953	43045	{
42954	43046	// copy mutable arguments back from call to closescope
42955		- stack[base + 17]/label/ = stack[base + 38LLU];
	43047	+ stack[base + 17]/label/ = stack[base + 42LLU];
42956	43048	printf("%s", "\n label = ");
42957	43049	// call printnr from procblock
42958		- stack[base + 32LLU] = 3600LLU/throw to this address/;
42959		- stack[base + 33LLU] = base;
42960		- stack[base + 34LLU] = 3601LLU;
	43050	+ stack[base + 36LLU] = 3621LLU/throw to this address/;
	43051	+ stack[base + 37LLU] = base;
	43052	+ stack[base + 38LLU] = 3622LLU;
42961	43053	// arguments for call to printnr
42962		- stack[base + 35LLU] = stack[base + 30]/labelthrow/;
	43054	+ stack[base + 39LLU] = stack[base + 31]/labelthrow/;
42963	43055	// set stack-base & callee-address
42964		- base += 35LLU;
	43056	+ base += 39LLU;
42965	43057	label = 18446744073709551590LLU; // printnr
42966	43058	break;
42967	43059	}
42968		- case 3600LLU: // copy-back deleter (printnr to procblock)
	43060	+ case 3621LLU: // copy-back deleter (printnr to procblock)
42969	43061	{
42970	43062	// copy mutable arguments back from call to printnr
42971		- label = 3546LLU; // continue to roll stack
	43063	+ label = 3563LLU; // continue to roll stack
42972	43064	break;
42973	43065	}
42974		- case 3601LLU: // return from printnr to procblock
	43066	+ case 3622LLU: // return from printnr to procblock
42975	43067	{
42976	43068	// copy mutable arguments back from call to printnr
42977	43069	printf("%s", "LLU; // consequent complete");

		@@ -42979,49 +43071,332 @@
42979	43071	printf("%s", "\n }");
42980	43072	printf("%s", "\n case ");
42981	43073	// call printnr from procblock
42982		- stack[base + 32LLU] = 3602LLU/throw to this address/;
42983		- stack[base + 33LLU] = base;
42984		- stack[base + 34LLU] = 3603LLU;
	43074	+ stack[base + 36LLU] = 3623LLU/throw to this address/;
	43075	+ stack[base + 37LLU] = base;
	43076	+ stack[base + 38LLU] = 3624LLU;
42985	43077	// arguments for call to printnr
42986		- stack[base + 35LLU] = stack[base + 22]/labelalt/;
	43078	+ stack[base + 39LLU] = stack[base + 22]/labelalt/;
42987	43079	// set stack-base & callee-address
42988		- base += 35LLU;
	43080	+ base += 39LLU;
42989	43081	label = 18446744073709551590LLU; // printnr
42990	43082	break;
42991	43083	}
42992		- case 3602LLU: // copy-back deleter (printnr to procblock)
	43084	+ case 3623LLU: // copy-back deleter (printnr to procblock)
42993	43085	{
42994	43086	// copy mutable arguments back from call to printnr
42995		- label = 3546LLU; // continue to roll stack
	43087	+ label = 3563LLU; // continue to roll stack
42996	43088	break;
42997	43089	}
42998		- case 3603LLU: // return from printnr to procblock
	43090	+ case 3624LLU: // return from printnr to procblock
42999	43091	{
43000	43092	// copy mutable arguments back from call to printnr
43001	43093	printf("%s", "LLU: // alternative");
43002	43094	printf("%s", "\n {");
	43095	+ label = 3612LLU; // consequent complete
	43096	+ break;
	43097	+ }
	43098	+ case 3611LLU: // alternative
	43099	+ {
	43100	+ printf("%s", "\n { // copyback");
	43101	+ printf("%s", "\n struct listnode list = (struct listnode )");
	43102	+ // call emitvaridx from procblock
	43103	+ stack[base + 36LLU] = 3625LLU/throw to this address/;
	43104	+ stack[base + 37LLU] = base;
	43105	+ stack[base + 38LLU] = 3626LLU;
	43106	+ // arguments for call to emitvaridx
	43107	+ stack[base + 39LLU] = stack[base + 28]/listindex/;
	43108	+ // set stack-base & callee-address
	43109	+ base += 39LLU;
	43110	+ label = 741LLU; // emitvaridx
	43111	+ break;
	43112	+ }
	43113	+ case 3625LLU: // copy-back deleter (emitvaridx to procblock)
	43114	+ {
	43115	+ // copy mutable arguments back from call to emitvaridx
	43116	+ label = 3563LLU; // continue to roll stack
	43117	+ break;
	43118	+ }
	43119	+ case 3626LLU: // return from emitvaridx to procblock
	43120	+ {
	43121	+ // copy mutable arguments back from call to emitvaridx
	43122	+ printf("%s", "/*");
	43123	+ // call printid from procblock
	43124	+ stack[base + 36LLU] = 3627LLU/throw to this address/;
	43125	+ stack[base + 37LLU] = base;
	43126	+ stack[base + 38LLU] = 3628LLU;
	43127	+ // arguments for call to printid
	43128	+ stack[base + 39LLU] = stack[base + 27]/listname/;
	43129	+ // set stack-base & callee-address
	43130	+ base += 39LLU;
	43131	+ label = 18446744073709551587LLU; // printid
	43132	+ break;
	43133	+ }
	43134	+ case 3627LLU: // copy-back deleter (printid to procblock)
	43135	+ {
	43136	+ // copy mutable arguments back from call to printid
	43137	+ label = 3563LLU; // continue to roll stack
	43138	+ break;
	43139	+ }
	43140	+ case 3628LLU: // return from printid to procblock
	43141	+ {
	43142	+ // copy mutable arguments back from call to printid
	43143	+ printf("%s", "*/;");
	43144	+ printf("%s", "\n list->data = ");
	43145	+ // call emitvaridx from procblock
	43146	+ stack[base + 36LLU] = 3629LLU/throw to this address/;
	43147	+ stack[base + 37LLU] = base;
	43148	+ stack[base + 38LLU] = 3630LLU;
	43149	+ // arguments for call to emitvaridx
	43150	+ stack[base + 39LLU] = stack[base + 35]/elemindex/;
	43151	+ // set stack-base & callee-address
	43152	+ base += 39LLU;
	43153	+ label = 741LLU; // emitvaridx
	43154	+ break;
	43155	+ }
	43156	+ case 3629LLU: // copy-back deleter (emitvaridx to procblock)
	43157	+ {
	43158	+ // copy mutable arguments back from call to emitvaridx
	43159	+ label = 3563LLU; // continue to roll stack
	43160	+ break;
	43161	+ }
	43162	+ case 3630LLU: // return from emitvaridx to procblock
	43163	+ {
	43164	+ // copy mutable arguments back from call to emitvaridx
	43165	+ printf("%s", ";");
	43166	+ printf("%s", "\n list->next = (struct listnode *)");
	43167	+ // call emitvar from procblock
	43168	+ stack[base + 36LLU] = 3631LLU/throw to this address/;
	43169	+ stack[base + 37LLU] = base;
	43170	+ stack[base + 38LLU] = 3632LLU;
	43171	+ // arguments for call to emitvar
	43172	+ stack[base + 39LLU] = stack[base + 8]/fnid/;
	43173	+ stack[base + 40LLU] = stack[base + 27]/listname/;
	43174	+ stack[base + 41LLU] = stack[base + 2]/scopes/;
	43175	+ stack[base + 42LLU] = stack[base + 3]/scope/;
	43176	+ // set stack-base & callee-address
	43177	+ base += 39LLU;
	43178	+ label = 745LLU; // emitvar
	43179	+ break;
	43180	+ }
	43181	+ case 3631LLU: // copy-back deleter (emitvar to procblock)
	43182	+ {
	43183	+ // copy mutable arguments back from call to emitvar
	43184	+ label = 3563LLU; // continue to roll stack
	43185	+ break;
	43186	+ }
	43187	+ case 3632LLU: // return from emitvar to procblock
	43188	+ {
	43189	+ // copy mutable arguments back from call to emitvar
	43190	+ printf("%s", ";");
	43191	+ printf("%s", "\n }");
	43192	+ printf("%s", "\n label = ");
	43193	+ // call printnr from procblock
	43194	+ stack[base + 36LLU] = 3633LLU/throw to this address/;
	43195	+ stack[base + 37LLU] = base;
	43196	+ stack[base + 38LLU] = 3634LLU;
	43197	+ // arguments for call to printnr
	43198	+ stack[base + 39LLU] = stack[base + 23]/labelskip/;
	43199	+ // set stack-base & callee-address
	43200	+ base += 39LLU;
	43201	+ label = 18446744073709551590LLU; // printnr
	43202	+ break;
	43203	+ }
	43204	+ case 3633LLU: // copy-back deleter (printnr to procblock)
	43205	+ {
	43206	+ // copy mutable arguments back from call to printnr
	43207	+ label = 3563LLU; // continue to roll stack
	43208	+ break;
	43209	+ }
	43210	+ case 3634LLU: // return from printnr to procblock
	43211	+ {
	43212	+ // copy mutable arguments back from call to printnr
	43213	+ printf("%s", "LLU; // consequent complete");
	43214	+ printf("%s", "\n break;");
	43215	+ printf("%s", "\n }");
	43216	+ printf("%s", "\n case ");
	43217	+ // call printnr from procblock
	43218	+ stack[base + 36LLU] = 3635LLU/throw to this address/;
	43219	+ stack[base + 37LLU] = base;
	43220	+ stack[base + 38LLU] = 3636LLU;
	43221	+ // arguments for call to printnr
	43222	+ stack[base + 39LLU] = stack[base + 22]/labelalt/;
	43223	+ // set stack-base & callee-address
	43224	+ base += 39LLU;
	43225	+ label = 18446744073709551590LLU; // printnr
	43226	+ break;
	43227	+ }
	43228	+ case 3635LLU: // copy-back deleter (printnr to procblock)
	43229	+ {
	43230	+ // copy mutable arguments back from call to printnr
	43231	+ label = 3563LLU; // continue to roll stack
	43232	+ break;
	43233	+ }
	43234	+ case 3636LLU: // return from printnr to procblock
	43235	+ {
	43236	+ // copy mutable arguments back from call to printnr
	43237	+ printf("%s", "LLU: // alternative");
	43238	+ printf("%s", "\n {");
	43239	+ label = 3612LLU; // alternative complete
	43240	+ break;
	43241	+ }
	43242	+ case 3612LLU: // completed if-then-else
	43243	+ {
	43244	+ ((uint64_t **)(stack[base + 26]))[1][0] = stack[base + 33];
	43245	+ label = 3548LLU; // case complete
	43246	+ break;
	43247	+ }
	43248	+ case 3550LLU: // copy-back deleter (switch)
	43249	+ {
	43250	+ ((uint64_t **)(stack[base + 26]))[1][0] = stack[base + 33];
	43251	+ label = 3541LLU; // continue to unroll stack
	43252	+ break;
	43253	+ }
	43254	+ case 3549LLU: // try next case
	43255	+ {
	43256	+ // default
	43257	+ fprintf(stderr, "%s", "in function ");
	43258	+ // call reportid from procblock
	43259	+ stack[base + 33LLU] = 3637LLU/throw to this address/;
	43260	+ stack[base + 34LLU] = base;
	43261	+ stack[base + 35LLU] = 3638LLU;
	43262	+ // arguments for call to reportid
	43263	+ stack[base + 36LLU] = stack[base + 8]/fnid/;
	43264	+ // set stack-base & callee-address
	43265	+ base += 36LLU;
	43266	+ label = 18446744073709551586LLU; // reportid
	43267	+ break;
	43268	+ }
	43269	+ case 3637LLU: // copy-back deleter (reportid to procblock)
	43270	+ {
	43271	+ // copy mutable arguments back from call to reportid
	43272	+ label = 3541LLU; // continue to roll stack
	43273	+ break;
	43274	+ }
	43275	+ case 3638LLU: // return from reportid to procblock
	43276	+ {
	43277	+ // copy mutable arguments back from call to reportid
	43278	+ fprintf(stderr, "%s", ": ");
	43279	+ fprintf(stderr, "%s", "can only ");
	43280	+ if(!stack[base + 24]/consume/)
	43281	+ {
	43282	+ label = 3639LLU; // jump to alternative
	43283	+ break;
	43284	+ }
	43285	+
	43286	+ // consequent
	43287	+ printf("%s", "pop");
	43288	+ label = 3640LLU; // consequent complete
	43289	+ break;
	43290	+ }
	43291	+ case 3639LLU: // alternative
	43292	+ {
	43293	+ printf("%s", "next");
	43294	+ label = 3640LLU; // alternative complete
	43295	+ break;
	43296	+ }
	43297	+ case 3640LLU: // completed if-then-else
	43298	+ {
	43299	+ printf("%s", " from list but type of ");
	43300	+ // call reportid from procblock
	43301	+ stack[base + 33LLU] = 3641LLU/throw to this address/;
	43302	+ stack[base + 34LLU] = base;
	43303	+ stack[base + 35LLU] = 3642LLU;
	43304	+ // arguments for call to reportid
	43305	+ stack[base + 36LLU] = stack[base + 27]/listname/;
	43306	+ // set stack-base & callee-address
	43307	+ base += 36LLU;
	43308	+ label = 18446744073709551586LLU; // reportid
	43309	+ break;
	43310	+ }
	43311	+ case 3641LLU: // copy-back deleter (reportid to procblock)
	43312	+ {
	43313	+ // copy mutable arguments back from call to reportid
	43314	+ label = 3541LLU; // continue to roll stack
	43315	+ break;
	43316	+ }
	43317	+ case 3642LLU: // return from reportid to procblock
	43318	+ {
	43319	+ // copy mutable arguments back from call to reportid
	43320	+ fprintf(stderr, "%s", " is ");
	43321	+ uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
	43322	+ if(!newstack)
	43323	+ {
	43324	+ label = 3541LLU; // throw: begin to unroll stack
	43325	+ break;
	43326	+ }
	43327	+
	43328	+ newstack[10LLU] = 9876543210LLU; // overflow-marker
	43329	+ // call reporttype from procblock
	43330	+ newstack[0] = (uint64_t)stack; // backup stack location
	43331	+ newstack[1] = 3643LLU;
	43332	+ newstack[2] = base;
	43333	+ newstack[3] = 3644LLU;
	43334	+ // arguments for call to reporttype
	43335	+ newstack[4LLU] = stack[base + 26]/listtype/;
	43336	+ stack = newstack;
	43337	+ // set stack-base & callee-address
	43338	+ base = 4/deloffset/;
	43339	+ label = 326LLU; // reporttype
	43340	+ break;
	43341	+ }
	43342	+ case 3643LLU: // copy-back deleter (reporttype to procblock)
	43343	+ {
	43344	+ uint64_t oldstack = (uint64_t )stack[0];
	43345	+ // copy mutable arguments back from call to reporttype
	43346	+ if(stack[10LLU] != 9876543210LLU)
	43347	+ {
	43348	+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!\n");
	43349	+ exit(-1);
	43350	+ }
	43351	+ Free(10LLU + 1, sizeof(uint64_t), stack);
	43352	+ stack = oldstack;
	43353	+ label = 3541LLU; // continue to unroll stack
	43354	+ break;
	43355	+ }
	43356	+ case 3644LLU: // return from reporttype to procblock
	43357	+ {
	43358	+ uint64_t oldstack = (uint64_t )stack[0];
	43359	+ // copy mutable arguments back from call to reporttype
	43360	+ if(stack[10LLU] != 9876543210LLU)
	43361	+ {
	43362	+ fprintf(stderr, "INTERNAL ERROR - OVERFLOW (in recursive call to reporttype)!\n");
	43363	+ exit(-1);
	43364	+ }
	43365	+ Free(10LLU + 1, sizeof(uint64_t), stack);
	43366	+ stack = oldstack;
	43367	+ fprintf(stderr, "%s", "\n");
	43368	+ {
	43369	+ label = 3541LLU; // throw: begin to unroll stack
	43370	+ break;
	43371	+ }
	43372	+
	43373	+ label = 3548LLU; // default complete
	43374	+ break;
	43375	+ }
	43376	+ case 3548LLU: // completed switch
	43377	+ {
43003	43378	{ // if pop
43004	43379	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
43005	43380	if(!list)
43006	43381	{
43007		- label = 3604LLU; // jump to alternative
	43382	+ label = 3645LLU; // jump to alternative
43008	43383	break;
43009	43384	}
43010	43385
43011	43386	// consequent
43012	43387	struct listnode *next = list->next;
43013		- stack[base + 32]/tmp/ = list->data;
	43388	+ /tmp/stack[base + 33] = list->data;
43014	43389	Free(1, sizeof(struct listnode), list);
43015		- stack[base + 2]/scopes/ = (uint64_t)next;
	43390	+ /scopes/stack[base + 2] = (uint64_t)next;
43016	43391	}
43017		- swap(&stack[base + 32], &stack[base + 3]);
	43392	+ swap(&stack[base + 33], &stack[base + 3]);
43018	43393
43019		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
	43394	+ uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);
43020	43395	// call ~scope from procblock
43021	43396	newstack[0] = (uint64_t)stack; // backup stack location
43022	43397	newstack[1] = 1234567890;
43023	43398	newstack[2] = base;
43024		- newstack[3] = 3607LLU;
	43399	+ newstack[3] = 3648LLU;
43025	43400	stack = newstack;
43026	43401	// set stack-base & callee-address
43027	43402	base = 4/deloffset/;

		@@ -43028,24 +43403,24 @@
43028	43403	label = 558LLU; // ~scope
43029	43404	break;
43030	43405	}
43031		- case 3607LLU: // return from ~scope to procblock
	43406	+ case 3648LLU: // return from ~scope to procblock
43032	43407	{
43033	43408	stack = (uint64_t *)stack[0];
43034	43409	// releasing toplevel container
43035		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
	43410	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
43036	43411
43037		- label = 3605LLU; // consequent complete
	43412	+ label = 3646LLU; // consequent complete
43038	43413	break;
43039	43414	}
43040		- case 3606LLU: // copy-back deleter (if pop)
	43415	+ case 3647LLU: // copy-back deleter (if pop)
43041	43416	{
43042	43417
43043		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
	43418	+ uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);
43044	43419	// call ~scope from procblock
43045	43420	newstack[0] = (uint64_t)stack; // backup stack location
43046	43421	newstack[1] = 1234567890;
43047	43422	newstack[2] = base;
43048		- newstack[3] = 3608LLU;
	43423	+ newstack[3] = 3649LLU;
43049	43424	stack = newstack;
43050	43425	// set stack-base & callee-address
43051	43426	base = 4/deloffset/;

		@@ -43052,50 +43427,50 @@
43052	43427	label = 558LLU; // ~scope
43053	43428	break;
43054	43429	}
43055		- case 3608LLU: // return from ~scope to procblock
	43430	+ case 3649LLU: // return from ~scope to procblock
43056	43431	{
43057	43432	stack = (uint64_t *)stack[0];
43058	43433	// releasing toplevel container
43059		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
	43434	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
43060	43435
43061		- label = 3546LLU; // consequent complete
	43436	+ label = 3541LLU; // consequent complete
43062	43437	break;
43063	43438	}
43064		- case 3604LLU: // alternative
	43439	+ case 3645LLU: // alternative
43065	43440	{
43066	43441	fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n");
43067	43442	{
43068		- label = 3546LLU; // throw: begin to unroll stack
	43443	+ label = 3541LLU; // throw: begin to unroll stack
43069	43444	break;
43070	43445	}
43071	43446
43072		- label = 3605LLU; // alternative complete
	43447	+ label = 3646LLU; // alternative complete
43073	43448	break;
43074	43449	}
43075		- case 3605LLU: // completed if-then-else
	43450	+ case 3646LLU: // completed if-then-else
43076	43451	{
43077	43452	{ // if pop
43078	43453	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
43079	43454	if(!list)
43080	43455	{
43081		- label = 3609LLU; // jump to alternative
	43456	+ label = 3650LLU; // jump to alternative
43082	43457	break;
43083	43458	}
43084	43459
43085	43460	// consequent
43086	43461	struct listnode *next = list->next;
43087		- stack[base + 32]/tmp/ = list->data;
	43462	+ /tmp/stack[base + 33] = list->data;
43088	43463	Free(1, sizeof(struct listnode), list);
43089		- stack[base + 2]/scopes/ = (uint64_t)next;
	43464	+ /scopes/stack[base + 2] = (uint64_t)next;
43090	43465	}
43091		- swap(&stack[base + 32], &stack[base + 3]);
	43466	+ swap(&stack[base + 33], &stack[base + 3]);
43092	43467
43093		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
	43468	+ uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);
43094	43469	// call ~scope from procblock
43095	43470	newstack[0] = (uint64_t)stack; // backup stack location
43096	43471	newstack[1] = 1234567890;
43097	43472	newstack[2] = base;
43098		- newstack[3] = 3612LLU;
	43473	+ newstack[3] = 3653LLU;
43099	43474	stack = newstack;
43100	43475	// set stack-base & callee-address
43101	43476	base = 4/deloffset/;

		@@ -43102,24 +43477,24 @@
43102	43477	label = 558LLU; // ~scope
43103	43478	break;
43104	43479	}
43105		- case 3612LLU: // return from ~scope to procblock
	43480	+ case 3653LLU: // return from ~scope to procblock
43106	43481	{
43107	43482	stack = (uint64_t *)stack[0];
43108	43483	// releasing toplevel container
43109		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
	43484	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
43110	43485
43111		- label = 3610LLU; // consequent complete
	43486	+ label = 3651LLU; // consequent complete
43112	43487	break;
43113	43488	}
43114		- case 3611LLU: // copy-back deleter (if pop)
	43489	+ case 3652LLU: // copy-back deleter (if pop)
43115	43490	{
43116	43491
43117		- uint64_t newstack = (uint64_t )(stack[base + 32] - sizeof(uint64_t) * 4);
	43492	+ uint64_t newstack = (uint64_t )(stack[base + 33] - sizeof(uint64_t) * 4);
43118	43493	// call ~scope from procblock
43119	43494	newstack[0] = (uint64_t)stack; // backup stack location
43120	43495	newstack[1] = 1234567890;
43121	43496	newstack[2] = base;
43122		- newstack[3] = 3613LLU;
	43497	+ newstack[3] = 3654LLU;
43123	43498	stack = newstack;
43124	43499	// set stack-base & callee-address
43125	43500	base = 4/deloffset/;

		@@ -43126,98 +43501,98 @@
43126	43501	label = 558LLU; // ~scope
43127	43502	break;
43128	43503	}
43129		- case 3613LLU: // return from ~scope to procblock
	43504	+ case 3654LLU: // return from ~scope to procblock
43130	43505	{
43131	43506	stack = (uint64_t *)stack[0];
43132	43507	// releasing toplevel container
43133		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
	43508	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
43134	43509
43135		- label = 3546LLU; // consequent complete
	43510	+ label = 3541LLU; // consequent complete
43136	43511	break;
43137	43512	}
43138		- case 3609LLU: // alternative
	43513	+ case 3650LLU: // alternative
43139	43514	{
43140	43515	fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n");
43141	43516	{
43142		- label = 3546LLU; // throw: begin to unroll stack
	43517	+ label = 3541LLU; // throw: begin to unroll stack
43143	43518	break;
43144	43519	}
43145	43520
43146		- label = 3610LLU; // alternative complete
	43521	+ label = 3651LLU; // alternative complete
43147	43522	break;
43148	43523	}
43149		- case 3610LLU: // completed if-then-else
	43524	+ case 3651LLU: // completed if-then-else
43150	43525	{
43151		- label = 3513LLU; // consequent complete
	43526	+ label = 3527LLU; // consequent complete
43152	43527	break;
43153	43528	}
43154		- case 3512LLU: // alternative
	43529	+ case 3526LLU: // alternative
43155	43530	{
43156	43531	fprintf(stderr, "%s", "expected identifier in pop but found ");
43157	43532	// call reporttok from procblock
43158		- stack[base + 30LLU] = 3614LLU/throw to this address/;
43159		- stack[base + 31LLU] = base;
43160		- stack[base + 32LLU] = 3615LLU;
	43533	+ stack[base + 31LLU] = 3655LLU/throw to this address/;
	43534	+ stack[base + 32LLU] = base;
	43535	+ stack[base + 33LLU] = 3656LLU;
43161	43536	// arguments for call to reporttok
43162		- stack[base + 33LLU] = stack[base + 15]/variant/;
43163		- stack[base + 34LLU] = stack[base + 16]/content/;
	43537	+ stack[base + 34LLU] = stack[base + 15]/variant/;
	43538	+ stack[base + 35LLU] = stack[base + 16]/content/;
43164	43539	// set stack-base & callee-address
43165		- base += 33LLU;
	43540	+ base += 34LLU;
43166	43541	label = 18446744073709551582LLU; // reporttok
43167	43542	break;
43168	43543	}
43169		- case 3614LLU: // copy-back deleter (reporttok to procblock)
	43544	+ case 3655LLU: // copy-back deleter (reporttok to procblock)
43170	43545	{
43171	43546	// copy mutable arguments back from call to reporttok
43172		- label = 3495LLU; // continue to roll stack
	43547	+ label = 3507LLU; // continue to roll stack
43173	43548	break;
43174	43549	}
43175		- case 3615LLU: // return from reporttok to procblock
	43550	+ case 3656LLU: // return from reporttok to procblock
43176	43551	{
43177	43552	// copy mutable arguments back from call to reporttok
43178	43553	fprintf(stderr, "%s", "\n");
43179	43554	{
43180		- label = 3495LLU; // throw: begin to unroll stack
	43555	+ label = 3507LLU; // throw: begin to unroll stack
43181	43556	break;
43182	43557	}
43183	43558
43184		- label = 3513LLU; // alternative complete
	43559	+ label = 3527LLU; // alternative complete
43185	43560	break;
43186	43561	}
43187		- case 3513LLU: // completed if-then-else
	43562	+ case 3527LLU: // completed if-then-else
43188	43563	{
43189		- ((uint64_t **)(stack[base + 24]))[1][4] = stack[base + 29];
43190		- ((uint64_t **)(stack[base + 24]))[1][3] = stack[base + 28];
43191		- ((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
43192		- ((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
43193		- ((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
43194		- label = 3493LLU; // case complete
	43564	+ ((uint64_t **)(stack[base + 25]))[1][4] = stack[base + 30];
	43565	+ ((uint64_t **)(stack[base + 25]))[1][3] = stack[base + 29];
	43566	+ ((uint64_t **)(stack[base + 25]))[1][2] = stack[base + 28];
	43567	+ ((uint64_t **)(stack[base + 25]))[1][1] = stack[base + 27];
	43568	+ ((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 26];
	43569	+ label = 3505LLU; // case complete
43195	43570	break;
43196	43571	}
43197		- case 3495LLU: // copy-back deleter (switch)
	43572	+ case 3507LLU: // copy-back deleter (switch)
43198	43573	{
43199		- ((uint64_t **)(stack[base + 24]))[1][4] = stack[base + 29];
43200		- ((uint64_t **)(stack[base + 24]))[1][3] = stack[base + 28];
43201		- ((uint64_t **)(stack[base + 24]))[1][2] = stack[base + 27];
43202		- ((uint64_t **)(stack[base + 24]))[1][1] = stack[base + 26];
43203		- ((uint64_t **)(stack[base + 24]))[1][0] = stack[base + 25];
43204		- label = 3488LLU; // continue to unroll stack
	43574	+ ((uint64_t **)(stack[base + 25]))[1][4] = stack[base + 30];
	43575	+ ((uint64_t **)(stack[base + 25]))[1][3] = stack[base + 29];
	43576	+ ((uint64_t **)(stack[base + 25]))[1][2] = stack[base + 28];
	43577	+ ((uint64_t **)(stack[base + 25]))[1][1] = stack[base + 27];
	43578	+ ((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 26];
	43579	+ label = 3500LLU; // continue to unroll stack
43205	43580	break;
43206	43581	}
43207		- case 3494LLU: // try next case
	43582	+ case 3506LLU: // try next case
43208	43583	{
43209	43584	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
43210	43585	exit(-1);
43211	43586	}
43212		- case 3493LLU: // completed switch
	43587	+ case 3505LLU: // completed switch
43213	43588	{
43214	43589
43215		- uint64_t newstack = (uint64_t )(stack[base + 24] - sizeof(uint64_t) * 4);
	43590	+ uint64_t newstack = (uint64_t )(stack[base + 25] - sizeof(uint64_t) * 4);
43216	43591	// call ~letdef from procblock
43217	43592	newstack[0] = (uint64_t)stack; // backup stack location
43218	43593	newstack[1] = 1234567890;
43219	43594	newstack[2] = base;
43220		- newstack[3] = 3616LLU;
	43595	+ newstack[3] = 3657LLU;
43221	43596	stack = newstack;
43222	43597	// set stack-base & callee-address
43223	43598	base = 4/deloffset/;

		@@ -43224,88 +43599,50 @@
43224	43599	label = 482LLU; // ~letdef
43225	43600	break;
43226	43601	}
43227		- case 3616LLU: // return from ~letdef to procblock
	43602	+ case 3657LLU: // return from ~letdef to procblock
43228	43603	{
43229	43604	stack = (uint64_t *)stack[0];
43230	43605	// releasing toplevel container
43231		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 24] - sizeof(uint64_t) 4));
	43606	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 25] - sizeof(uint64_t) 4));
43232	43607
43233		- label = 3487LLU; // consequent complete
	43608	+ label = 3499LLU; // consequent complete
43234	43609	break;
43235	43610	}
43236		- case 3486LLU: // alternative
	43611	+ case 3498LLU: // alternative
43237	43612	{
43238	43613	fprintf(stderr, "%s", "expected identifier in pop but found ");
43239	43614	// call reporttok from procblock
43240		- stack[base + 24LLU] = 3617LLU/throw to this address/;
43241		- stack[base + 25LLU] = base;
43242		- stack[base + 26LLU] = 3618LLU;
	43615	+ stack[base + 25LLU] = 3658LLU/throw to this address/;
	43616	+ stack[base + 26LLU] = base;
	43617	+ stack[base + 27LLU] = 3659LLU;
43243	43618	// arguments for call to reporttok
43244		- stack[base + 27LLU] = stack[base + 15]/variant/;
43245		- stack[base + 28LLU] = stack[base + 16]/content/;
	43619	+ stack[base + 28LLU] = stack[base + 15]/variant/;
	43620	+ stack[base + 29LLU] = stack[base + 16]/content/;
43246	43621	// set stack-base & callee-address
43247		- base += 27LLU;
	43622	+ base += 28LLU;
43248	43623	label = 18446744073709551582LLU; // reporttok
43249	43624	break;
43250	43625	}
43251		- case 3617LLU: // copy-back deleter (reporttok to procblock)
	43626	+ case 3658LLU: // copy-back deleter (reporttok to procblock)
43252	43627	{
43253	43628	// copy mutable arguments back from call to reporttok
43254		- label = 3428LLU; // continue to roll stack
	43629	+ label = 3476LLU; // continue to roll stack
43255	43630	break;
43256	43631	}
43257		- case 3618LLU: // return from reporttok to procblock
	43632	+ case 3659LLU: // return from reporttok to procblock
43258	43633	{
43259	43634	// copy mutable arguments back from call to reporttok
43260	43635	fprintf(stderr, "%s", "\n");
43261	43636	{
43262		- label = 3428LLU; // throw: begin to unroll stack
	43637	+ label = 3476LLU; // throw: begin to unroll stack
43263	43638	break;
43264	43639	}
43265	43640
43266		- label = 3487LLU; // alternative complete
	43641	+ label = 3499LLU; // alternative complete
43267	43642	break;
43268	43643	}
43269		- case 3487LLU: // completed if-then-else
	43644	+ case 3499LLU: // completed if-then-else
43270	43645	{
43271		- label = 3479LLU; // consequent complete
43272		- break;
43273		- }
43274		- case 3478LLU: // alternative
43275		- {
43276		- fprintf(stderr, "%s", "expected '(' but found token ");
43277		- // call reporttok from procblock
43278		- stack[base + 24LLU] = 3619LLU/throw to this address/;
43279		- stack[base + 25LLU] = base;
43280		- stack[base + 26LLU] = 3620LLU;
43281		- // arguments for call to reporttok
43282		- stack[base + 27LLU] = stack[base + 15]/variant/;
43283		- stack[base + 28LLU] = stack[base + 16]/content/;
43284		- // set stack-base & callee-address
43285		- base += 27LLU;
43286		- label = 18446744073709551582LLU; // reporttok
43287		- break;
43288		- }
43289		- case 3619LLU: // copy-back deleter (reporttok to procblock)
43290		- {
43291		- // copy mutable arguments back from call to reporttok
43292		- label = 3428LLU; // continue to roll stack
43293		- break;
43294		- }
43295		- case 3620LLU: // return from reporttok to procblock
43296		- {
43297		- // copy mutable arguments back from call to reporttok
43298		- fprintf(stderr, "%s", "\n");
43299		- {
43300		- label = 3428LLU; // throw: begin to unroll stack
43301		- break;
43302		- }
43303		-
43304		- label = 3479LLU; // alternative complete
43305		- break;
43306		- }
43307		- case 3479LLU: // completed if-then-else
43308		- {
43309	43646	label = 3435LLU; // alternative complete
43310	43647	break;
43311	43648	}

		@@ -43312,9 +43649,9 @@
43312	43649	case 3435LLU: // completed if-then-else
43313	43650	{
43314	43651	// call matchid from procblock
43315		- stack[base + 24LLU] = 3621LLU/throw to this address/;
	43652	+ stack[base + 24LLU] = 3660LLU/throw to this address/;
43316	43653	stack[base + 25LLU] = base;
43317		- stack[base + 26LLU] = 3622LLU;
	43654	+ stack[base + 26LLU] = 3661LLU;
43318	43655	// arguments for call to matchid
43319	43656	stack[base + 27LLU] = stack[base + 8]/fnid/;
43320	43657	stack[base + 28LLU] = 587642785557905408LLU;

		@@ -43324,7 +43661,7 @@
43324	43661	label = 252LLU; // matchid
43325	43662	break;
43326	43663	}
43327		- case 3621LLU: // copy-back deleter (matchid to procblock)
	43664	+ case 3660LLU: // copy-back deleter (matchid to procblock)
43328	43665	{
43329	43666	// copy mutable arguments back from call to matchid
43330	43667	stack[base + 19]/lookahead/ = stack[base + 29LLU];

		@@ -43331,14 +43668,14 @@
43331	43668	label = 3428LLU; // continue to roll stack
43332	43669	break;
43333	43670	}
43334		- case 3622LLU: // return from matchid to procblock
	43671	+ case 3661LLU: // return from matchid to procblock
43335	43672	{
43336	43673	// copy mutable arguments back from call to matchid
43337	43674	stack[base + 19]/lookahead/ = stack[base + 29LLU];
43338	43675	// call matchsym from procblock
43339		- stack[base + 24LLU] = 3623LLU/throw to this address/;
	43676	+ stack[base + 24LLU] = 3662LLU/throw to this address/;
43340	43677	stack[base + 25LLU] = base;
43341		- stack[base + 26LLU] = 3624LLU;
	43678	+ stack[base + 26LLU] = 3663LLU;
43342	43679	// arguments for call to matchsym
43343	43680	stack[base + 27LLU] = stack[base + 8]/fnid/;
43344	43681	stack[base + 28LLU] = 123LLU;

		@@ -43348,7 +43685,7 @@
43348	43685	label = 222LLU; // matchsym
43349	43686	break;
43350	43687	}
43351		- case 3623LLU: // copy-back deleter (matchsym to procblock)
	43688	+ case 3662LLU: // copy-back deleter (matchsym to procblock)
43352	43689	{
43353	43690	// copy mutable arguments back from call to matchsym
43354	43691	stack[base + 19]/lookahead/ = stack[base + 29LLU];

		@@ -43355,13 +43692,13 @@
43355	43692	label = 3428LLU; // continue to roll stack
43356	43693	break;
43357	43694	}
43358		- case 3624LLU: // return from matchsym to procblock
	43695	+ case 3663LLU: // return from matchsym to procblock
43359	43696	{
43360	43697	// copy mutable arguments back from call to matchsym
43361	43698	stack[base + 19]/lookahead/ = stack[base + 29LLU];
43362	43699	if(!stack[base + 21]/returnflag/)
43363	43700	{
43364		- label = 3625LLU; // jump to alternative
	43701	+ label = 3664LLU; // jump to alternative
43365	43702	break;
43366	43703	}
43367	43704

		@@ -43376,9 +43713,9 @@
43376	43713	newstack[160LLU] = 9876543210LLU; // overflow-marker
43377	43714	// call procblock from procblock
43378	43715	newstack[0] = (uint64_t)stack; // backup stack location
43379		- newstack[1] = 3627LLU;
	43716	+ newstack[1] = 3666LLU;
43380	43717	newstack[2] = base;
43381		- newstack[3] = 3628LLU;
	43718	+ newstack[3] = 3667LLU;
43382	43719	// arguments for call to procblock
43383	43720	newstack[4LLU] = stack[base + 0]/fndefs/;
43384	43721	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -43404,7 +43741,7 @@
43404	43741	label = 3319LLU; // procblock
43405	43742	break;
43406	43743	}
43407		- case 3627LLU: // copy-back deleter (procblock to procblock)
	43744	+ case 3666LLU: // copy-back deleter (procblock to procblock)
43408	43745	{
43409	43746	uint64_t oldstack = (uint64_t )stack[0];
43410	43747	// copy mutable arguments back from call to procblock

		@@ -43424,7 +43761,7 @@
43424	43761	label = 3428LLU; // continue to unroll stack
43425	43762	break;
43426	43763	}
43427		- case 3628LLU: // return from procblock to procblock
	43764	+ case 3667LLU: // return from procblock to procblock
43428	43765	{
43429	43766	uint64_t oldstack = (uint64_t )stack[0];
43430	43767	// copy mutable arguments back from call to procblock

		@@ -43441,15 +43778,15 @@
43441	43778	}
43442	43779	Free(160LLU + 1, sizeof(uint64_t), stack);
43443	43780	stack = oldstack;
43444		- label = 3626LLU; // consequent complete
	43781	+ label = 3665LLU; // consequent complete
43445	43782	break;
43446	43783	}
43447		- case 3625LLU: // alternative
	43784	+ case 3664LLU: // alternative
43448	43785	{
43449		- label = 3630LLU; // skip deleter
	43786	+ label = 3669LLU; // skip deleter
43450	43787	break;
43451	43788	}
43452		- case 3629LLU: // deleter
	43789	+ case 3668LLU: // deleter
43453	43790	{
43454	43791	// throw from procblock
43455	43792	if(!stack[base + 24])

		@@ -43458,14 +43795,14 @@
43458	43795	break;
43459	43796	}
43460	43797	// delete list
43461		- label = 3631LLU; // start to repeat
	43798	+ label = 3670LLU; // start to repeat
43462	43799	break;
43463	43800	}
43464		- case 3631LLU: // repeat from here
	43801	+ case 3670LLU: // repeat from here
43465	43802	{
43466	43803	if(!stack[base + 24])
43467	43804	{
43468		- label = 3632LLU; // break loop
	43805	+ label = 3671LLU; // break loop
43469	43806	break;
43470	43807	}
43471	43808

		@@ -43476,7 +43813,7 @@
43476	43813	newstack[0] = (uint64_t)stack; // backup stack location
43477	43814	newstack[1] = 1234567890;
43478	43815	newstack[2] = base;
43479		- newstack[3] = 3633LLU;
	43816	+ newstack[3] = 3672LLU;
43480	43817	stack = newstack;
43481	43818	// set stack-base & callee-address
43482	43819	base = 4/deloffset/;

		@@ -43483,7 +43820,7 @@
43483	43820	label = 395LLU; // ~typeidx
43484	43821	break;
43485	43822	}
43486		- case 3633LLU: // return from ~typeidx to procblock
	43823	+ case 3672LLU: // return from ~typeidx to procblock
43487	43824	{
43488	43825	stack = (uint64_t *)stack[0];
43489	43826	// releasing toplevel container

		@@ -43494,21 +43831,21 @@
43494	43831	stack[base + 24] = (uint64_t)list->next;
43495	43832	Free(1, sizeof(struct listnode), list);
43496	43833	}
43497		- label = 3631LLU; // repeat
	43834	+ label = 3670LLU; // repeat
43498	43835	break;
43499	43836	}
43500		- case 3632LLU: // loop finished
	43837	+ case 3671LLU: // loop finished
43501	43838	{
43502	43839	label = 3428LLU; // continue unrolling stack, delete next variable
43503	43840	break;
43504	43841	}
43505		- case 3630LLU: // skipped deleter
	43842	+ case 3669LLU: // skipped deleter
43506	43843	{
43507	43844	stack[base + 24] = 0;
43508	43845	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
43509	43846	if(!newstack)
43510	43847	{
43511		- label = 3629LLU; // throw: begin to unroll stack
	43848	+ label = 3668LLU; // throw: begin to unroll stack
43512	43849	break;
43513	43850	}
43514	43851

		@@ -43515,9 +43852,9 @@
43515	43852	newstack[160LLU] = 9876543210LLU; // overflow-marker
43516	43853	// call procblock from procblock
43517	43854	newstack[0] = (uint64_t)stack; // backup stack location
43518		- newstack[1] = 3634LLU;
	43855	+ newstack[1] = 3673LLU;
43519	43856	newstack[2] = base;
43520		- newstack[3] = 3635LLU;
	43857	+ newstack[3] = 3674LLU;
43521	43858	// arguments for call to procblock
43522	43859	newstack[4LLU] = stack[base + 0]/fndefs/;
43523	43860	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -43543,7 +43880,7 @@
43543	43880	label = 3319LLU; // procblock
43544	43881	break;
43545	43882	}
43546		- case 3634LLU: // copy-back deleter (procblock to procblock)
	43883	+ case 3673LLU: // copy-back deleter (procblock to procblock)
43547	43884	{
43548	43885	uint64_t oldstack = (uint64_t )stack[0];
43549	43886	// copy mutable arguments back from call to procblock

		@@ -43560,10 +43897,10 @@
43560	43897	}
43561	43898	Free(160LLU + 1, sizeof(uint64_t), stack);
43562	43899	stack = oldstack;
43563		- label = 3629LLU; // continue to unroll stack
	43900	+ label = 3668LLU; // continue to unroll stack
43564	43901	break;
43565	43902	}
43566		- case 3635LLU: // return from procblock to procblock
	43903	+ case 3674LLU: // return from procblock to procblock
43567	43904	{
43568	43905	uint64_t oldstack = (uint64_t )stack[0];
43569	43906	// copy mutable arguments back from call to procblock

		@@ -43581,14 +43918,14 @@
43581	43918	Free(160LLU + 1, sizeof(uint64_t), stack);
43582	43919	stack = oldstack;
43583	43920	// delete list
43584		- label = 3636LLU; // start to repeat
	43921	+ label = 3675LLU; // start to repeat
43585	43922	break;
43586	43923	}
43587		- case 3636LLU: // repeat from here
	43924	+ case 3675LLU: // repeat from here
43588	43925	{
43589	43926	if(!stack[base + 24])
43590	43927	{
43591		- label = 3637LLU; // break loop
	43928	+ label = 3676LLU; // break loop
43592	43929	break;
43593	43930	}
43594	43931

		@@ -43599,7 +43936,7 @@
43599	43936	newstack[0] = (uint64_t)stack; // backup stack location
43600	43937	newstack[1] = 1234567890;
43601	43938	newstack[2] = base;
43602		- newstack[3] = 3638LLU;
	43939	+ newstack[3] = 3677LLU;
43603	43940	stack = newstack;
43604	43941	// set stack-base & callee-address
43605	43942	base = 4/deloffset/;

		@@ -43606,7 +43943,7 @@
43606	43943	label = 395LLU; // ~typeidx
43607	43944	break;
43608	43945	}
43609		- case 3638LLU: // return from ~typeidx to procblock
	43946	+ case 3677LLU: // return from ~typeidx to procblock
43610	43947	{
43611	43948	stack = (uint64_t *)stack[0];
43612	43949	// releasing toplevel container

		@@ -43617,21 +43954,21 @@
43617	43954	stack[base + 24] = (uint64_t)list->next;
43618	43955	Free(1, sizeof(struct listnode), list);
43619	43956	}
43620		- label = 3636LLU; // repeat
	43957	+ label = 3675LLU; // repeat
43621	43958	break;
43622	43959	}
43623		- case 3637LLU: // loop finished
	43960	+ case 3676LLU: // loop finished
43624	43961	{
43625		- label = 3626LLU; // alternative complete
	43962	+ label = 3665LLU; // alternative complete
43626	43963	break;
43627	43964	}
43628		- case 3626LLU: // completed if-then-else
	43965	+ case 3665LLU: // completed if-then-else
43629	43966	{
43630	43967	printf("%s", "\n label = ");
43631	43968	// call printnr from procblock
43632		- stack[base + 24LLU] = 3639LLU/throw to this address/;
	43969	+ stack[base + 24LLU] = 3678LLU/throw to this address/;
43633	43970	stack[base + 25LLU] = base;
43634		- stack[base + 26LLU] = 3640LLU;
	43971	+ stack[base + 26LLU] = 3679LLU;
43635	43972	// arguments for call to printnr
43636	43973	stack[base + 27LLU] = stack[base + 23]/labelskip/;
43637	43974	// set stack-base & callee-address

		@@ -43639,13 +43976,13 @@
43639	43976	label = 18446744073709551590LLU; // printnr
43640	43977	break;
43641	43978	}
43642		- case 3639LLU: // copy-back deleter (printnr to procblock)
	43979	+ case 3678LLU: // copy-back deleter (printnr to procblock)
43643	43980	{
43644	43981	// copy mutable arguments back from call to printnr
43645	43982	label = 3428LLU; // continue to roll stack
43646	43983	break;
43647	43984	}
43648		- case 3640LLU: // return from printnr to procblock
	43985	+ case 3679LLU: // return from printnr to procblock
43649	43986	{
43650	43987	// copy mutable arguments back from call to printnr
43651	43988	printf("%s", "LLU; // alternative complete");

		@@ -43653,9 +43990,9 @@
43653	43990	printf("%s", "\n }");
43654	43991	printf("%s", "\n case ");
43655	43992	// call printnr from procblock
43656		- stack[base + 24LLU] = 3641LLU/throw to this address/;
	43993	+ stack[base + 24LLU] = 3680LLU/throw to this address/;
43657	43994	stack[base + 25LLU] = base;
43658		- stack[base + 26LLU] = 3642LLU;
	43995	+ stack[base + 26LLU] = 3681LLU;
43659	43996	// arguments for call to printnr
43660	43997	stack[base + 27LLU] = stack[base + 23]/labelskip/;
43661	43998	// set stack-base & callee-address

		@@ -43663,13 +44000,13 @@
43663	44000	label = 18446744073709551590LLU; // printnr
43664	44001	break;
43665	44002	}
43666		- case 3641LLU: // copy-back deleter (printnr to procblock)
	44003	+ case 3680LLU: // copy-back deleter (printnr to procblock)
43667	44004	{
43668	44005	// copy mutable arguments back from call to printnr
43669	44006	label = 3428LLU; // continue to roll stack
43670	44007	break;
43671	44008	}
43672		- case 3642LLU: // return from printnr to procblock
	44009	+ case 3681LLU: // return from printnr to procblock
43673	44010	{
43674	44011	// copy mutable arguments back from call to printnr
43675	44012	printf("%s", "LLU: // completed if-then-else");

		@@ -43676,15 +44013,15 @@
43676	44013	printf("%s", "\n {");
43677	44014	if(!stack[base + 21]/returnflag/)
43678	44015	{
43679		- label = 3643LLU; // jump to alternative
	44016	+ label = 3682LLU; // jump to alternative
43680	44017	break;
43681	44018	}
43682	44019
43683	44020	// consequent
43684	44021	// call MATCHPEEK from procblock
43685		- stack[base + 24LLU] = 3645LLU/throw to this address/;
	44022	+ stack[base + 24LLU] = 3684LLU/throw to this address/;
43686	44023	stack[base + 25LLU] = base;
43687		- stack[base + 26LLU] = 3646LLU;
	44024	+ stack[base + 26LLU] = 3685LLU;
43688	44025	// arguments for call to MATCHPEEK
43689	44026	stack[base + 27LLU] = stack[base + 8]/fnid/;
43690	44027	stack[base + 28LLU] = 125LLU;

		@@ -43694,7 +44031,7 @@
43694	44031	label = 206LLU; // MATCHPEEK
43695	44032	break;
43696	44033	}
43697		- case 3645LLU: // copy-back deleter (MATCHPEEK to procblock)
	44034	+ case 3684LLU: // copy-back deleter (MATCHPEEK to procblock)
43698	44035	{
43699	44036	// copy mutable arguments back from call to MATCHPEEK
43700	44037	stack[base + 19]/lookahead/ = stack[base + 29LLU];

		@@ -43701,14 +44038,14 @@
43701	44038	label = 3428LLU; // continue to roll stack
43702	44039	break;
43703	44040	}
43704		- case 3646LLU: // return from MATCHPEEK to procblock
	44041	+ case 3685LLU: // return from MATCHPEEK to procblock
43705	44042	{
43706	44043	// copy mutable arguments back from call to MATCHPEEK
43707	44044	stack[base + 19]/lookahead/ = stack[base + 29LLU];
43708	44045	// call EOSbyte from procblock
43709		- stack[base + 24LLU] = 3647LLU/throw to this address/;
	44046	+ stack[base + 24LLU] = 3686LLU/throw to this address/;
43710	44047	stack[base + 25LLU] = base;
43711		- stack[base + 26LLU] = 3648LLU;
	44048	+ stack[base + 26LLU] = 3687LLU;
43712	44049	// arguments for call to EOSbyte
43713	44050	// set stack-base & callee-address
43714	44051	base += 27LLU;

		@@ -43715,26 +44052,26 @@
43715	44052	label = 77LLU; // EOSbyte
43716	44053	break;
43717	44054	}
43718		- case 3647LLU: // copy-back deleter (EOSbyte to procblock)
	44055	+ case 3686LLU: // copy-back deleter (EOSbyte to procblock)
43719	44056	{
43720	44057	// copy mutable arguments back from call to EOSbyte
43721	44058	label = 3428LLU; // continue to roll stack
43722	44059	break;
43723	44060	}
43724		- case 3648LLU: // return from EOSbyte to procblock
	44061	+ case 3687LLU: // return from EOSbyte to procblock
43725	44062	{
43726	44063	// copy mutable arguments back from call to EOSbyte
43727	44064	// copy back results provided by call to EOSbyte
43728	44065	stack[base + 19] = stack[base + 27LLU];
43729		- label = 3644LLU; // consequent complete
	44066	+ label = 3683LLU; // consequent complete
43730	44067	break;
43731	44068	}
43732		- case 3643LLU: // alternative
	44069	+ case 3682LLU: // alternative
43733	44070	{
43734		- label = 3644LLU; // alternative complete
	44071	+ label = 3683LLU; // alternative complete
43735	44072	break;
43736	44073	}
43737		- case 3644LLU: // completed if-then-else
	44074	+ case 3683LLU: // completed if-then-else
43738	44075	{
43739	44076	label = 3421LLU; // consequent complete
43740	44077	break;

		@@ -43742,9 +44079,9 @@
43742	44079	case 3420LLU: // alternative
43743	44080	{
43744	44081	// call equ from procblock
43745		- stack[base + 22LLU] = 3649LLU/throw to this address/;
	44082	+ stack[base + 22LLU] = 3688LLU/throw to this address/;
43746	44083	stack[base + 23LLU] = base;
43747		- stack[base + 24LLU] = 3650LLU;
	44084	+ stack[base + 24LLU] = 3689LLU;
43748	44085	// arguments for call to equ
43749	44086	stack[base + 26LLU] = stack[base + 16]/content/;
43750	44087	stack[base + 27LLU] = 910732593752702976LLU;

		@@ -43753,13 +44090,13 @@
43753	44090	label = 18446744073709551600LLU; // equ
43754	44091	break;
43755	44092	}
43756		- case 3649LLU: // copy-back deleter (equ to procblock)
	44093	+ case 3688LLU: // copy-back deleter (equ to procblock)
43757	44094	{
43758	44095	// copy mutable arguments back from call to equ
43759	44096	label = 3386LLU; // continue to roll stack
43760	44097	break;
43761	44098	}
43762		- case 3650LLU: // return from equ to procblock
	44099	+ case 3689LLU: // return from equ to procblock
43763	44100	{
43764	44101	// copy mutable arguments back from call to equ
43765	44102	// copy back results provided by call to equ

		@@ -43766,15 +44103,15 @@
43766	44103	stack[base + 20] = stack[base + 25LLU];
43767	44104	if(!stack[base + 20]/isequal/)
43768	44105	{
43769		- label = 3651LLU; // jump to alternative
	44106	+ label = 3690LLU; // jump to alternative
43770	44107	break;
43771	44108	}
43772	44109
43773	44110	// consequent
43774		- label = 3654LLU; // skip deleter
	44111	+ label = 3693LLU; // skip deleter
43775	44112	break;
43776	44113	}
43777		- case 3653LLU: // deleter
	44114	+ case 3692LLU: // deleter
43778	44115	{
43779	44116	// throw from procblock
43780	44117	if(!stack[base + 22])

		@@ -43788,7 +44125,7 @@
43788	44125	newstack[0] = (uint64_t)stack; // backup stack location
43789	44126	newstack[1] = 1234567890;
43790	44127	newstack[2] = base;
43791		- newstack[3] = 3655LLU;
	44128	+ newstack[3] = 3694LLU;
43792	44129	stack = newstack;
43793	44130	// set stack-base & callee-address
43794	44131	base = 4/deloffset/;

		@@ -43795,7 +44132,7 @@
43795	44132	label = 558LLU; // ~scope
43796	44133	break;
43797	44134	}
43798		- case 3655LLU: // return from ~scope to procblock
	44135	+ case 3694LLU: // return from ~scope to procblock
43799	44136	{
43800	44137	stack = (uint64_t *)stack[0];
43801	44138	// releasing toplevel container

		@@ -43804,12 +44141,12 @@
43804	44141	label = 3386LLU; // continue unrolling stack, delete next variable
43805	44142	break;
43806	44143	}
43807		- case 3654LLU: // skipped deleter
	44144	+ case 3693LLU: // skipped deleter
43808	44145	{
43809	44146	// call linkscope from procblock
43810		- stack[base + 23LLU] = 3656LLU/throw to this address/;
	44147	+ stack[base + 23LLU] = 3695LLU/throw to this address/;
43811	44148	stack[base + 24LLU] = base;
43812		- stack[base + 25LLU] = 3657LLU;
	44149	+ stack[base + 25LLU] = 3696LLU;
43813	44150	// arguments for call to linkscope
43814	44151	stack[base + 27LLU] = stack[base + 3]/scope/;
43815	44152	// set stack-base & callee-address

		@@ -43817,13 +44154,13 @@
43817	44154	label = 585LLU; // linkscope
43818	44155	break;
43819	44156	}
43820		- case 3656LLU: // copy-back deleter (linkscope to procblock)
	44157	+ case 3695LLU: // copy-back deleter (linkscope to procblock)
43821	44158	{
43822	44159	// copy mutable arguments back from call to linkscope
43823	44160	label = 3386LLU; // continue to roll stack
43824	44161	break;
43825	44162	}
43826		- case 3657LLU: // return from linkscope to procblock
	44163	+ case 3696LLU: // return from linkscope to procblock
43827	44164	{
43828	44165	// copy mutable arguments back from call to linkscope
43829	44166	// copy back results provided by call to linkscope

		@@ -43843,9 +44180,9 @@
43843	44180	MOVE(&list->data, &stack[base + 22]/newscope/);
43844	44181	}
43845	44182	// call add from procblock
43846		- stack[base + 22LLU] = 3658LLU/throw to this address/;
	44183	+ stack[base + 22LLU] = 3697LLU/throw to this address/;
43847	44184	stack[base + 23LLU] = base;
43848		- stack[base + 24LLU] = 3659LLU;
	44185	+ stack[base + 24LLU] = 3698LLU;
43849	44186	// arguments for call to add
43850	44187	stack[base + 26LLU] = 1LLU;
43851	44188	stack[base + 27LLU] = stack[base + 17]/label/;

		@@ -43854,21 +44191,21 @@
43854	44191	label = 18446744073709551605LLU; // add
43855	44192	break;
43856	44193	}
43857		- case 3658LLU: // copy-back deleter (add to procblock)
	44194	+ case 3697LLU: // copy-back deleter (add to procblock)
43858	44195	{
43859	44196	// copy mutable arguments back from call to add
43860	44197	label = 3386LLU; // continue to roll stack
43861	44198	break;
43862	44199	}
43863		- case 3659LLU: // return from add to procblock
	44200	+ case 3698LLU: // return from add to procblock
43864	44201	{
43865	44202	// copy mutable arguments back from call to add
43866	44203	// copy back results provided by call to add
43867	44204	stack[base + 17] = stack[base + 25LLU];
43868		- label = 3661LLU; // skip deleter
	44205	+ label = 3700LLU; // skip deleter
43869	44206	break;
43870	44207	}
43871		- case 3660LLU: // deleter
	44208	+ case 3699LLU: // deleter
43872	44209	{
43873	44210	// throw from procblock
43874	44211	if(!stack[base + 22])

		@@ -43879,13 +44216,13 @@
43879	44216	label = 3386LLU; // continue unrolling stack, delete next variable
43880	44217	break;
43881	44218	}
43882		- case 3661LLU: // skipped deleter
	44219	+ case 3700LLU: // skipped deleter
43883	44220	{
43884	44221	stack[base + 22] = stack[base + 17]/label/;
43885	44222	// call add from procblock
43886		- stack[base + 23LLU] = 3662LLU/throw to this address/;
	44223	+ stack[base + 23LLU] = 3701LLU/throw to this address/;
43887	44224	stack[base + 24LLU] = base;
43888		- stack[base + 25LLU] = 3663LLU;
	44225	+ stack[base + 25LLU] = 3702LLU;
43889	44226	// arguments for call to add
43890	44227	stack[base + 27LLU] = 1LLU;
43891	44228	stack[base + 28LLU] = stack[base + 17]/label/;

		@@ -43894,38 +44231,38 @@
43894	44231	label = 18446744073709551605LLU; // add
43895	44232	break;
43896	44233	}
43897		- case 3662LLU: // copy-back deleter (add to procblock)
	44234	+ case 3701LLU: // copy-back deleter (add to procblock)
43898	44235	{
43899	44236	// copy mutable arguments back from call to add
43900		- label = 3660LLU; // continue to roll stack
	44237	+ label = 3699LLU; // continue to roll stack
43901	44238	break;
43902	44239	}
43903		- case 3663LLU: // return from add to procblock
	44240	+ case 3702LLU: // return from add to procblock
43904	44241	{
43905	44242	// copy mutable arguments back from call to add
43906	44243	// copy back results provided by call to add
43907	44244	stack[base + 17] = stack[base + 26LLU];
43908		- label = 3665LLU; // skip deleter
	44245	+ label = 3704LLU; // skip deleter
43909	44246	break;
43910	44247	}
43911		- case 3664LLU: // deleter
	44248	+ case 3703LLU: // deleter
43912	44249	{
43913	44250	// throw from procblock
43914	44251	if(!stack[base + 23])
43915	44252	{
43916		- label = 3660LLU; // skip, variable already deleted/unscoped
	44253	+ label = 3699LLU; // skip, variable already deleted/unscoped
43917	44254	break;
43918	44255	}
43919		- label = 3660LLU; // continue unrolling stack, delete next variable
	44256	+ label = 3699LLU; // continue unrolling stack, delete next variable
43920	44257	break;
43921	44258	}
43922		- case 3665LLU: // skipped deleter
	44259	+ case 3704LLU: // skipped deleter
43923	44260	{
43924	44261	stack[base + 23] = stack[base + 17]/label/;
43925	44262	// call ParseToken from procblock
43926		- stack[base + 24LLU] = 3666LLU/throw to this address/;
	44263	+ stack[base + 24LLU] = 3705LLU/throw to this address/;
43927	44264	stack[base + 25LLU] = base;
43928		- stack[base + 26LLU] = 3667LLU;
	44265	+ stack[base + 26LLU] = 3706LLU;
43929	44266	// arguments for call to ParseToken
43930	44267	stack[base + 29LLU] = stack[base + 19]/lookahead/;
43931	44268	// set stack-base & callee-address

		@@ -43933,14 +44270,14 @@
43933	44270	label = 3LLU; // ParseToken
43934	44271	break;
43935	44272	}
43936		- case 3666LLU: // copy-back deleter (ParseToken to procblock)
	44273	+ case 3705LLU: // copy-back deleter (ParseToken to procblock)
43937	44274	{
43938	44275	// copy mutable arguments back from call to ParseToken
43939	44276	stack[base + 19]/lookahead/ = stack[base + 29LLU];
43940		- label = 3664LLU; // continue to roll stack
	44277	+ label = 3703LLU; // continue to roll stack
43941	44278	break;
43942	44279	}
43943		- case 3667LLU: // return from ParseToken to procblock
	44280	+ case 3706LLU: // return from ParseToken to procblock
43944	44281	{
43945	44282	// copy mutable arguments back from call to ParseToken
43946	44283	stack[base + 19]/lookahead/ = stack[base + 29LLU];

		@@ -43947,42 +44284,42 @@
43947	44284	// copy back results provided by call to ParseToken
43948	44285	stack[base + 15] = stack[base + 27LLU];
43949	44286	stack[base + 16] = stack[base + 28LLU];
43950		- label = 3669LLU; // skip deleter
	44287	+ label = 3708LLU; // skip deleter
43951	44288	break;
43952	44289	}
43953		- case 3668LLU: // deleter
	44290	+ case 3707LLU: // deleter
43954	44291	{
43955	44292	// throw from procblock
43956	44293	if(!stack[base + 24])
43957	44294	{
43958		- label = 3664LLU; // skip, variable already deleted/unscoped
	44295	+ label = 3703LLU; // skip, variable already deleted/unscoped
43959	44296	break;
43960	44297	}
43961		- label = 3664LLU; // continue unrolling stack, delete next variable
	44298	+ label = 3703LLU; // continue unrolling stack, delete next variable
43962	44299	break;
43963	44300	}
43964		- case 3669LLU: // skipped deleter
	44301	+ case 3708LLU: // skipped deleter
43965	44302	{
43966		- label = 3671LLU; // skip deleter
	44303	+ label = 3710LLU; // skip deleter
43967	44304	break;
43968	44305	}
43969		- case 3670LLU: // deleter
	44306	+ case 3709LLU: // deleter
43970	44307	{
43971	44308	// throw from procblock
43972	44309	if(!stack[base + 25])
43973	44310	{
43974		- label = 3668LLU; // skip, variable already deleted/unscoped
	44311	+ label = 3707LLU; // skip, variable already deleted/unscoped
43975	44312	break;
43976	44313	}
43977		- label = 3668LLU; // continue unrolling stack, delete next variable
	44314	+ label = 3707LLU; // continue unrolling stack, delete next variable
43978	44315	break;
43979	44316	}
43980		- case 3671LLU: // skipped deleter
	44317	+ case 3710LLU: // skipped deleter
43981	44318	{
43982	44319	// call isident from procblock
43983		- stack[base + 26LLU] = 3672LLU/throw to this address/;
	44320	+ stack[base + 26LLU] = 3711LLU/throw to this address/;
43984	44321	stack[base + 27LLU] = base;
43985		- stack[base + 28LLU] = 3673LLU;
	44322	+ stack[base + 28LLU] = 3712LLU;
43986	44323	// arguments for call to isident
43987	44324	stack[base + 30LLU] = stack[base + 15]/variant/;
43988	44325	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -43992,13 +44329,13 @@
43992	44329	label = 184LLU; // isident
43993	44330	break;
43994	44331	}
43995		- case 3672LLU: // copy-back deleter (isident to procblock)
	44332	+ case 3711LLU: // copy-back deleter (isident to procblock)
43996	44333	{
43997	44334	// copy mutable arguments back from call to isident
43998		- label = 3664LLU; // continue to roll stack
	44335	+ label = 3703LLU; // continue to roll stack
43999	44336	break;
44000	44337	}
44001		- case 3673LLU: // return from isident to procblock
	44338	+ case 3712LLU: // return from isident to procblock
44002	44339	{
44003	44340	// copy mutable arguments back from call to isident
44004	44341	// copy back results provided by call to isident

		@@ -44005,15 +44342,15 @@
44005	44342	stack[base + 20] = stack[base + 29LLU];
44006	44343	if(!stack[base + 20]/isequal/)
44007	44344	{
44008		- label = 3674LLU; // jump to alternative
	44345	+ label = 3713LLU; // jump to alternative
44009	44346	break;
44010	44347	}
44011	44348
44012	44349	// consequent
44013	44350	// call ParseToken from procblock
44014		- stack[base + 26LLU] = 3676LLU/throw to this address/;
	44351	+ stack[base + 26LLU] = 3715LLU/throw to this address/;
44015	44352	stack[base + 27LLU] = base;
44016		- stack[base + 28LLU] = 3677LLU;
	44353	+ stack[base + 28LLU] = 3716LLU;
44017	44354	// arguments for call to ParseToken
44018	44355	stack[base + 31LLU] = stack[base + 19]/lookahead/;
44019	44356	// set stack-base & callee-address

		@@ -44021,14 +44358,14 @@
44021	44358	label = 3LLU; // ParseToken
44022	44359	break;
44023	44360	}
44024		- case 3676LLU: // copy-back deleter (ParseToken to procblock)
	44361	+ case 3715LLU: // copy-back deleter (ParseToken to procblock)
44025	44362	{
44026	44363	// copy mutable arguments back from call to ParseToken
44027	44364	stack[base + 19]/lookahead/ = stack[base + 31LLU];
44028		- label = 3664LLU; // continue to roll stack
	44365	+ label = 3703LLU; // continue to roll stack
44029	44366	break;
44030	44367	}
44031		- case 3677LLU: // return from ParseToken to procblock
	44368	+ case 3716LLU: // return from ParseToken to procblock
44032	44369	{
44033	44370	// copy mutable arguments back from call to ParseToken
44034	44371	stack[base + 19]/lookahead/ = stack[base + 31LLU];

		@@ -44035,49 +44372,49 @@
44035	44372	// copy back results provided by call to ParseToken
44036	44373	stack[base + 15] = stack[base + 29LLU];
44037	44374	stack[base + 16] = stack[base + 30LLU];
44038		- label = 3679LLU; // skip deleter
	44375	+ label = 3718LLU; // skip deleter
44039	44376	break;
44040	44377	}
44041		- case 3678LLU: // deleter
	44378	+ case 3717LLU: // deleter
44042	44379	{
44043	44380	// throw from procblock
44044	44381	if(!stack[base + 24])
44045	44382	{
44046		- label = 3664LLU; // skip, variable already deleted/unscoped
	44383	+ label = 3703LLU; // skip, variable already deleted/unscoped
44047	44384	break;
44048	44385	}
44049		- label = 3664LLU; // continue unrolling stack, delete next variable
	44386	+ label = 3703LLU; // continue unrolling stack, delete next variable
44050	44387	break;
44051	44388	}
44052		- case 3679LLU: // skipped deleter
	44389	+ case 3718LLU: // skipped deleter
44053	44390	{
44054	44391	stack[base + 24] = 1;
44055		- label = 3681LLU; // skip deleter
	44392	+ label = 3720LLU; // skip deleter
44056	44393	break;
44057	44394	}
44058		- case 3680LLU: // deleter
	44395	+ case 3719LLU: // deleter
44059	44396	{
44060	44397	// throw from procblock
44061	44398	if(!stack[base + 25])
44062	44399	{
44063		- label = 3678LLU; // skip, variable already deleted/unscoped
	44400	+ label = 3717LLU; // skip, variable already deleted/unscoped
44064	44401	break;
44065	44402	}
44066		- label = 3678LLU; // continue unrolling stack, delete next variable
	44403	+ label = 3717LLU; // continue unrolling stack, delete next variable
44067	44404	break;
44068	44405	}
44069		- case 3681LLU: // skipped deleter
	44406	+ case 3720LLU: // skipped deleter
44070	44407	{
44071	44408	stack[base + 25] = 0;
44072		- label = 3675LLU; // consequent complete
	44409	+ label = 3714LLU; // consequent complete
44073	44410	break;
44074	44411	}
44075		- case 3674LLU: // alternative
	44412	+ case 3713LLU: // alternative
44076	44413	{
44077	44414	// call isident from procblock
44078		- stack[base + 26LLU] = 3682LLU/throw to this address/;
	44415	+ stack[base + 26LLU] = 3721LLU/throw to this address/;
44079	44416	stack[base + 27LLU] = base;
44080		- stack[base + 28LLU] = 3683LLU;
	44417	+ stack[base + 28LLU] = 3722LLU;
44081	44418	// arguments for call to isident
44082	44419	stack[base + 30LLU] = stack[base + 15]/variant/;
44083	44420	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -44087,13 +44424,13 @@
44087	44424	label = 184LLU; // isident
44088	44425	break;
44089	44426	}
44090		- case 3682LLU: // copy-back deleter (isident to procblock)
	44427	+ case 3721LLU: // copy-back deleter (isident to procblock)
44091	44428	{
44092	44429	// copy mutable arguments back from call to isident
44093		- label = 3664LLU; // continue to roll stack
	44430	+ label = 3703LLU; // continue to roll stack
44094	44431	break;
44095	44432	}
44096		- case 3683LLU: // return from isident to procblock
	44433	+ case 3722LLU: // return from isident to procblock
44097	44434	{
44098	44435	// copy mutable arguments back from call to isident
44099	44436	// copy back results provided by call to isident

		@@ -44100,7 +44437,7 @@
44100	44437	stack[base + 20] = stack[base + 29LLU];
44101	44438	if(!stack[base + 20]/isequal/)
44102	44439	{
44103		- label = 3684LLU; // jump to alternative
	44440	+ label = 3723LLU; // jump to alternative
44104	44441	break;
44105	44442	}
44106	44443

		@@ -44107,21 +44444,21 @@
44107	44444	// consequent
44108	44445	if(!stack[base + 7]/fnIO/)
44109	44446	{
44110		- label = 3686LLU; // jump to alternative
	44447	+ label = 3725LLU; // jump to alternative
44111	44448	break;
44112	44449	}
44113	44450
44114	44451	// consequent
44115		- label = 3687LLU; // consequent complete
	44452	+ label = 3726LLU; // consequent complete
44116	44453	break;
44117	44454	}
44118		- case 3686LLU: // alternative
	44455	+ case 3725LLU: // alternative
44119	44456	{
44120	44457	fprintf(stderr, "%s", "in function ");
44121	44458	// call reportid from procblock
44122		- stack[base + 26LLU] = 3688LLU/throw to this address/;
	44459	+ stack[base + 26LLU] = 3727LLU/throw to this address/;
44123	44460	stack[base + 27LLU] = base;
44124		- stack[base + 28LLU] = 3689LLU;
	44461	+ stack[base + 28LLU] = 3728LLU;
44125	44462	// arguments for call to reportid
44126	44463	stack[base + 29LLU] = stack[base + 8]/fnid/;
44127	44464	// set stack-base & callee-address

		@@ -44129,31 +44466,31 @@
44129	44466	label = 18446744073709551586LLU; // reportid
44130	44467	break;
44131	44468	}
44132		- case 3688LLU: // copy-back deleter (reportid to procblock)
	44469	+ case 3727LLU: // copy-back deleter (reportid to procblock)
44133	44470	{
44134	44471	// copy mutable arguments back from call to reportid
44135		- label = 3664LLU; // continue to roll stack
	44472	+ label = 3703LLU; // continue to roll stack
44136	44473	break;
44137	44474	}
44138		- case 3689LLU: // return from reportid to procblock
	44475	+ case 3728LLU: // return from reportid to procblock
44139	44476	{
44140	44477	// copy mutable arguments back from call to reportid
44141	44478	fprintf(stderr, "%s", ": ");
44142	44479	fprintf(stderr, "%s", "while input used in non-IO environment\n");
44143	44480	{
44144		- label = 3664LLU; // throw: begin to unroll stack
	44481	+ label = 3703LLU; // throw: begin to unroll stack
44145	44482	break;
44146	44483	}
44147	44484
44148		- label = 3687LLU; // alternative complete
	44485	+ label = 3726LLU; // alternative complete
44149	44486	break;
44150	44487	}
44151		- case 3687LLU: // completed if-then-else
	44488	+ case 3726LLU: // completed if-then-else
44152	44489	{
44153	44490	// call ParseToken from procblock
44154		- stack[base + 26LLU] = 3690LLU/throw to this address/;
	44491	+ stack[base + 26LLU] = 3729LLU/throw to this address/;
44155	44492	stack[base + 27LLU] = base;
44156		- stack[base + 28LLU] = 3691LLU;
	44493	+ stack[base + 28LLU] = 3730LLU;
44157	44494	// arguments for call to ParseToken
44158	44495	stack[base + 31LLU] = stack[base + 19]/lookahead/;
44159	44496	// set stack-base & callee-address

		@@ -44161,14 +44498,14 @@
44161	44498	label = 3LLU; // ParseToken
44162	44499	break;
44163	44500	}
44164		- case 3690LLU: // copy-back deleter (ParseToken to procblock)
	44501	+ case 3729LLU: // copy-back deleter (ParseToken to procblock)
44165	44502	{
44166	44503	// copy mutable arguments back from call to ParseToken
44167	44504	stack[base + 19]/lookahead/ = stack[base + 31LLU];
44168		- label = 3664LLU; // continue to roll stack
	44505	+ label = 3703LLU; // continue to roll stack
44169	44506	break;
44170	44507	}
44171		- case 3691LLU: // return from ParseToken to procblock
	44508	+ case 3730LLU: // return from ParseToken to procblock
44172	44509	{
44173	44510	// copy mutable arguments back from call to ParseToken
44174	44511	stack[base + 19]/lookahead/ = stack[base + 31LLU];

		@@ -44175,93 +44512,93 @@
44175	44512	// copy back results provided by call to ParseToken
44176	44513	stack[base + 15] = stack[base + 29LLU];
44177	44514	stack[base + 16] = stack[base + 30LLU];
44178		- label = 3693LLU; // skip deleter
	44515	+ label = 3732LLU; // skip deleter
44179	44516	break;
44180	44517	}
44181		- case 3692LLU: // deleter
	44518	+ case 3731LLU: // deleter
44182	44519	{
44183	44520	// throw from procblock
44184	44521	if(!stack[base + 24])
44185	44522	{
44186		- label = 3664LLU; // skip, variable already deleted/unscoped
	44523	+ label = 3703LLU; // skip, variable already deleted/unscoped
44187	44524	break;
44188	44525	}
44189		- label = 3664LLU; // continue unrolling stack, delete next variable
	44526	+ label = 3703LLU; // continue unrolling stack, delete next variable
44190	44527	break;
44191	44528	}
44192		- case 3693LLU: // skipped deleter
	44529	+ case 3732LLU: // skipped deleter
44193	44530	{
44194	44531	stack[base + 24] = 0;
44195		- label = 3695LLU; // skip deleter
	44532	+ label = 3734LLU; // skip deleter
44196	44533	break;
44197	44534	}
44198		- case 3694LLU: // deleter
	44535	+ case 3733LLU: // deleter
44199	44536	{
44200	44537	// throw from procblock
44201	44538	if(!stack[base + 25])
44202	44539	{
44203		- label = 3692LLU; // skip, variable already deleted/unscoped
	44540	+ label = 3731LLU; // skip, variable already deleted/unscoped
44204	44541	break;
44205	44542	}
44206		- label = 3692LLU; // continue unrolling stack, delete next variable
	44543	+ label = 3731LLU; // continue unrolling stack, delete next variable
44207	44544	break;
44208	44545	}
44209		- case 3695LLU: // skipped deleter
	44546	+ case 3734LLU: // skipped deleter
44210	44547	{
44211	44548	stack[base + 25] = 1;
44212		- label = 3685LLU; // consequent complete
	44549	+ label = 3724LLU; // consequent complete
44213	44550	break;
44214	44551	}
44215		- case 3684LLU: // alternative
	44552	+ case 3723LLU: // alternative
44216	44553	{
44217		- label = 3697LLU; // skip deleter
	44554	+ label = 3736LLU; // skip deleter
44218	44555	break;
44219	44556	}
44220		- case 3696LLU: // deleter
	44557	+ case 3735LLU: // deleter
44221	44558	{
44222	44559	// throw from procblock
44223	44560	if(!stack[base + 24])
44224	44561	{
44225		- label = 3664LLU; // skip, variable already deleted/unscoped
	44562	+ label = 3703LLU; // skip, variable already deleted/unscoped
44226	44563	break;
44227	44564	}
44228		- label = 3664LLU; // continue unrolling stack, delete next variable
	44565	+ label = 3703LLU; // continue unrolling stack, delete next variable
44229	44566	break;
44230	44567	}
44231		- case 3697LLU: // skipped deleter
	44568	+ case 3736LLU: // skipped deleter
44232	44569	{
44233	44570	stack[base + 24] = 0;
44234		- label = 3699LLU; // skip deleter
	44571	+ label = 3738LLU; // skip deleter
44235	44572	break;
44236	44573	}
44237		- case 3698LLU: // deleter
	44574	+ case 3737LLU: // deleter
44238	44575	{
44239	44576	// throw from procblock
44240	44577	if(!stack[base + 25])
44241	44578	{
44242		- label = 3696LLU; // skip, variable already deleted/unscoped
	44579	+ label = 3735LLU; // skip, variable already deleted/unscoped
44243	44580	break;
44244	44581	}
44245		- label = 3696LLU; // continue unrolling stack, delete next variable
	44582	+ label = 3735LLU; // continue unrolling stack, delete next variable
44246	44583	break;
44247	44584	}
44248		- case 3699LLU: // skipped deleter
	44585	+ case 3738LLU: // skipped deleter
44249	44586	{
44250	44587	stack[base + 25] = 0;
44251		- label = 3685LLU; // alternative complete
	44588	+ label = 3724LLU; // alternative complete
44252	44589	break;
44253	44590	}
44254		- case 3685LLU: // completed if-then-else
	44591	+ case 3724LLU: // completed if-then-else
44255	44592	{
44256		- label = 3675LLU; // alternative complete
	44593	+ label = 3714LLU; // alternative complete
44257	44594	break;
44258	44595	}
44259		- case 3675LLU: // completed if-then-else
	44596	+ case 3714LLU: // completed if-then-else
44260	44597	{
44261	44598	// call equ from procblock
44262		- stack[base + 26LLU] = 3700LLU/throw to this address/;
	44599	+ stack[base + 26LLU] = 3739LLU/throw to this address/;
44263	44600	stack[base + 27LLU] = base;
44264		- stack[base + 28LLU] = 3701LLU;
	44601	+ stack[base + 28LLU] = 3740LLU;
44265	44602	// arguments for call to equ
44266	44603	stack[base + 30LLU] = stack[base + 15]/variant/;
44267	44604	stack[base + 31LLU] = 0LLU;

		@@ -44270,13 +44607,13 @@
44270	44607	label = 18446744073709551600LLU; // equ
44271	44608	break;
44272	44609	}
44273		- case 3700LLU: // copy-back deleter (equ to procblock)
	44610	+ case 3739LLU: // copy-back deleter (equ to procblock)
44274	44611	{
44275	44612	// copy mutable arguments back from call to equ
44276		- label = 3670LLU; // continue to roll stack
	44613	+ label = 3709LLU; // continue to roll stack
44277	44614	break;
44278	44615	}
44279		- case 3701LLU: // return from equ to procblock
	44616	+ case 3740LLU: // return from equ to procblock
44280	44617	{
44281	44618	// copy mutable arguments back from call to equ
44282	44619	// copy back results provided by call to equ

		@@ -44283,15 +44620,15 @@
44283	44620	stack[base + 20] = stack[base + 29LLU];
44284	44621	if(!stack[base + 20]/isequal/)
44285	44622	{
44286		- label = 3702LLU; // jump to alternative
	44623	+ label = 3741LLU; // jump to alternative
44287	44624	break;
44288	44625	}
44289	44626
44290	44627	// consequent
44291	44628	// call equ from procblock
44292		- stack[base + 26LLU] = 3704LLU/throw to this address/;
	44629	+ stack[base + 26LLU] = 3743LLU/throw to this address/;
44293	44630	stack[base + 27LLU] = base;
44294		- stack[base + 28LLU] = 3705LLU;
	44631	+ stack[base + 28LLU] = 3744LLU;
44295	44632	// arguments for call to equ
44296	44633	stack[base + 30LLU] = stack[base + 16]/content/;
44297	44634	stack[base + 31LLU] = 40LLU;

		@@ -44300,13 +44637,13 @@
44300	44637	label = 18446744073709551600LLU; // equ
44301	44638	break;
44302	44639	}
44303		- case 3704LLU: // copy-back deleter (equ to procblock)
	44640	+ case 3743LLU: // copy-back deleter (equ to procblock)
44304	44641	{
44305	44642	// copy mutable arguments back from call to equ
44306		- label = 3670LLU; // continue to roll stack
	44643	+ label = 3709LLU; // continue to roll stack
44307	44644	break;
44308	44645	}
44309		- case 3705LLU: // return from equ to procblock
	44646	+ case 3744LLU: // return from equ to procblock
44310	44647	{
44311	44648	// copy mutable arguments back from call to equ
44312	44649	// copy back results provided by call to equ

		@@ -44313,21 +44650,21 @@
44313	44650	stack[base + 20] = stack[base + 29LLU];
44314	44651	if(!stack[base + 20]/isequal/)
44315	44652	{
44316		- label = 3706LLU; // jump to alternative
	44653	+ label = 3745LLU; // jump to alternative
44317	44654	break;
44318	44655	}
44319	44656
44320	44657	// consequent
44321		- label = 3707LLU; // consequent complete
	44658	+ label = 3746LLU; // consequent complete
44322	44659	break;
44323	44660	}
44324		- case 3706LLU: // alternative
	44661	+ case 3745LLU: // alternative
44325	44662	{
44326	44663	fprintf(stderr, "%s", "expected '(' but found token ");
44327	44664	// call reporttok from procblock
44328		- stack[base + 26LLU] = 3708LLU/throw to this address/;
	44665	+ stack[base + 26LLU] = 3747LLU/throw to this address/;
44329	44666	stack[base + 27LLU] = base;
44330		- stack[base + 28LLU] = 3709LLU;
	44667	+ stack[base + 28LLU] = 3748LLU;
44331	44668	// arguments for call to reporttok
44332	44669	stack[base + 29LLU] = stack[base + 15]/variant/;
44333	44670	stack[base + 30LLU] = stack[base + 16]/content/;

		@@ -44336,47 +44673,47 @@
44336	44673	label = 18446744073709551582LLU; // reporttok
44337	44674	break;
44338	44675	}
44339		- case 3708LLU: // copy-back deleter (reporttok to procblock)
	44676	+ case 3747LLU: // copy-back deleter (reporttok to procblock)
44340	44677	{
44341	44678	// copy mutable arguments back from call to reporttok
44342		- label = 3670LLU; // continue to roll stack
	44679	+ label = 3709LLU; // continue to roll stack
44343	44680	break;
44344	44681	}
44345		- case 3709LLU: // return from reporttok to procblock
	44682	+ case 3748LLU: // return from reporttok to procblock
44346	44683	{
44347	44684	// copy mutable arguments back from call to reporttok
44348	44685	fprintf(stderr, "%s", "\n");
44349	44686	{
44350		- label = 3670LLU; // throw: begin to unroll stack
	44687	+ label = 3709LLU; // throw: begin to unroll stack
44351	44688	break;
44352	44689	}
44353	44690
44354		- label = 3707LLU; // alternative complete
	44691	+ label = 3746LLU; // alternative complete
44355	44692	break;
44356	44693	}
44357		- case 3707LLU: // completed if-then-else
	44694	+ case 3746LLU: // completed if-then-else
44358	44695	{
44359		- label = 3711LLU; // skip deleter
	44696	+ label = 3750LLU; // skip deleter
44360	44697	break;
44361	44698	}
44362		- case 3710LLU: // deleter
	44699	+ case 3749LLU: // deleter
44363	44700	{
44364	44701	// throw from procblock
44365	44702	if(!stack[base + 26])
44366	44703	{
44367		- label = 3670LLU; // skip, variable already deleted/unscoped
	44704	+ label = 3709LLU; // skip, variable already deleted/unscoped
44368	44705	break;
44369	44706	}
44370		- label = 3670LLU; // continue unrolling stack, delete next variable
	44707	+ label = 3709LLU; // continue unrolling stack, delete next variable
44371	44708	break;
44372	44709	}
44373		- case 3711LLU: // skipped deleter
	44710	+ case 3750LLU: // skipped deleter
44374	44711	{
44375	44712	stack[base + 26] = 0;
44376	44713	// call ParseToken from procblock
44377		- stack[base + 27LLU] = 3712LLU/throw to this address/;
	44714	+ stack[base + 27LLU] = 3751LLU/throw to this address/;
44378	44715	stack[base + 28LLU] = base;
44379		- stack[base + 29LLU] = 3713LLU;
	44716	+ stack[base + 29LLU] = 3752LLU;
44380	44717	// arguments for call to ParseToken
44381	44718	stack[base + 32LLU] = stack[base + 19]/lookahead/;
44382	44719	// set stack-base & callee-address

		@@ -44384,14 +44721,14 @@
44384	44721	label = 3LLU; // ParseToken
44385	44722	break;
44386	44723	}
44387		- case 3712LLU: // copy-back deleter (ParseToken to procblock)
	44724	+ case 3751LLU: // copy-back deleter (ParseToken to procblock)
44388	44725	{
44389	44726	// copy mutable arguments back from call to ParseToken
44390	44727	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44391		- label = 3710LLU; // continue to roll stack
	44728	+ label = 3749LLU; // continue to roll stack
44392	44729	break;
44393	44730	}
44394		- case 3713LLU: // return from ParseToken to procblock
	44731	+ case 3752LLU: // return from ParseToken to procblock
44395	44732	{
44396	44733	// copy mutable arguments back from call to ParseToken
44397	44734	stack[base + 19]/lookahead/ = stack[base + 32LLU];

		@@ -44399,9 +44736,9 @@
44399	44736	stack[base + 15] = stack[base + 30LLU];
44400	44737	stack[base + 26] = stack[base + 31LLU];
44401	44738	// call equ from procblock
44402		- stack[base + 27LLU] = 3714LLU/throw to this address/;
	44739	+ stack[base + 27LLU] = 3753LLU/throw to this address/;
44403	44740	stack[base + 28LLU] = base;
44404		- stack[base + 29LLU] = 3715LLU;
	44741	+ stack[base + 29LLU] = 3754LLU;
44405	44742	// arguments for call to equ
44406	44743	stack[base + 31LLU] = stack[base + 15]/variant/;
44407	44744	stack[base + 32LLU] = 4LLU;

		@@ -44410,13 +44747,13 @@
44410	44747	label = 18446744073709551600LLU; // equ
44411	44748	break;
44412	44749	}
44413		- case 3714LLU: // copy-back deleter (equ to procblock)
	44750	+ case 3753LLU: // copy-back deleter (equ to procblock)
44414	44751	{
44415	44752	// copy mutable arguments back from call to equ
44416		- label = 3710LLU; // continue to roll stack
	44753	+ label = 3749LLU; // continue to roll stack
44417	44754	break;
44418	44755	}
44419		- case 3715LLU: // return from equ to procblock
	44756	+ case 3754LLU: // return from equ to procblock
44420	44757	{
44421	44758	// copy mutable arguments back from call to equ
44422	44759	// copy back results provided by call to equ

		@@ -44423,15 +44760,15 @@
44423	44760	stack[base + 20] = stack[base + 30LLU];
44424	44761	if(!stack[base + 20]/isequal/)
44425	44762	{
44426		- label = 3716LLU; // jump to alternative
	44763	+ label = 3755LLU; // jump to alternative
44427	44764	break;
44428	44765	}
44429	44766
44430	44767	// consequent
44431	44768	// call assertu64 from procblock
44432		- stack[base + 27LLU] = 3718LLU/throw to this address/;
	44769	+ stack[base + 27LLU] = 3757LLU/throw to this address/;
44433	44770	stack[base + 28LLU] = base;
44434		- stack[base + 29LLU] = 3719LLU;
	44771	+ stack[base + 29LLU] = 3758LLU;
44435	44772	// arguments for call to assertu64
44436	44773	stack[base + 30LLU] = stack[base + 8]/fnid/;
44437	44774	stack[base + 31LLU] = 910732593752702976LLU;

		@@ -44443,25 +44780,25 @@
44443	44780	label = 3085LLU; // assertu64
44444	44781	break;
44445	44782	}
44446		- case 3718LLU: // copy-back deleter (assertu64 to procblock)
	44783	+ case 3757LLU: // copy-back deleter (assertu64 to procblock)
44447	44784	{
44448	44785	// copy mutable arguments back from call to assertu64
44449		- label = 3710LLU; // continue to roll stack
	44786	+ label = 3749LLU; // continue to roll stack
44450	44787	break;
44451	44788	}
44452		- case 3719LLU: // return from assertu64 to procblock
	44789	+ case 3758LLU: // return from assertu64 to procblock
44453	44790	{
44454	44791	// copy mutable arguments back from call to assertu64
44455		- label = 3717LLU; // consequent complete
	44792	+ label = 3756LLU; // consequent complete
44456	44793	break;
44457	44794	}
44458		- case 3716LLU: // alternative
	44795	+ case 3755LLU: // alternative
44459	44796	{
44460	44797	fprintf(stderr, "%s", "expected identifier in while but found ");
44461	44798	// call reporttok from procblock
44462		- stack[base + 27LLU] = 3720LLU/throw to this address/;
	44799	+ stack[base + 27LLU] = 3759LLU/throw to this address/;
44463	44800	stack[base + 28LLU] = base;
44464		- stack[base + 29LLU] = 3721LLU;
	44801	+ stack[base + 29LLU] = 3760LLU;
44465	44802	// arguments for call to reporttok
44466	44803	stack[base + 30LLU] = stack[base + 15]/variant/;
44467	44804	stack[base + 31LLU] = stack[base + 26]/loopid/;

		@@ -44470,30 +44807,30 @@
44470	44807	label = 18446744073709551582LLU; // reporttok
44471	44808	break;
44472	44809	}
44473		- case 3720LLU: // copy-back deleter (reporttok to procblock)
	44810	+ case 3759LLU: // copy-back deleter (reporttok to procblock)
44474	44811	{
44475	44812	// copy mutable arguments back from call to reporttok
44476		- label = 3710LLU; // continue to roll stack
	44813	+ label = 3749LLU; // continue to roll stack
44477	44814	break;
44478	44815	}
44479		- case 3721LLU: // return from reporttok to procblock
	44816	+ case 3760LLU: // return from reporttok to procblock
44480	44817	{
44481	44818	// copy mutable arguments back from call to reporttok
44482	44819	fprintf(stderr, "%s", "\n");
44483	44820	{
44484		- label = 3710LLU; // throw: begin to unroll stack
	44821	+ label = 3749LLU; // throw: begin to unroll stack
44485	44822	break;
44486	44823	}
44487	44824
44488		- label = 3717LLU; // alternative complete
	44825	+ label = 3756LLU; // alternative complete
44489	44826	break;
44490	44827	}
44491		- case 3717LLU: // completed if-then-else
	44828	+ case 3756LLU: // completed if-then-else
44492	44829	{
44493	44830	// call matchsym from procblock
44494		- stack[base + 27LLU] = 3722LLU/throw to this address/;
	44831	+ stack[base + 27LLU] = 3761LLU/throw to this address/;
44495	44832	stack[base + 28LLU] = base;
44496		- stack[base + 29LLU] = 3723LLU;
	44833	+ stack[base + 29LLU] = 3762LLU;
44497	44834	// arguments for call to matchsym
44498	44835	stack[base + 30LLU] = stack[base + 8]/fnid/;
44499	44836	stack[base + 31LLU] = 41LLU;

		@@ -44503,28 +44840,28 @@
44503	44840	label = 222LLU; // matchsym
44504	44841	break;
44505	44842	}
44506		- case 3722LLU: // copy-back deleter (matchsym to procblock)
	44843	+ case 3761LLU: // copy-back deleter (matchsym to procblock)
44507	44844	{
44508	44845	// copy mutable arguments back from call to matchsym
44509	44846	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44510		- label = 3710LLU; // continue to roll stack
	44847	+ label = 3749LLU; // continue to roll stack
44511	44848	break;
44512	44849	}
44513		- case 3723LLU: // return from matchsym to procblock
	44850	+ case 3762LLU: // return from matchsym to procblock
44514	44851	{
44515	44852	// copy mutable arguments back from call to matchsym
44516	44853	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44517	44854	if(!stack[base + 24]/decflag/)
44518	44855	{
44519		- label = 3724LLU; // jump to alternative
	44856	+ label = 3763LLU; // jump to alternative
44520	44857	break;
44521	44858	}
44522	44859
44523	44860	// consequent
44524	44861	// call matchsym from procblock
44525		- stack[base + 27LLU] = 3726LLU/throw to this address/;
	44862	+ stack[base + 27LLU] = 3765LLU/throw to this address/;
44526	44863	stack[base + 28LLU] = base;
44527		- stack[base + 29LLU] = 3727LLU;
	44864	+ stack[base + 29LLU] = 3766LLU;
44528	44865	// arguments for call to matchsym
44529	44866	stack[base + 30LLU] = stack[base + 8]/fnid/;
44530	44867	stack[base + 31LLU] = 45LLU;

		@@ -44534,21 +44871,21 @@
44534	44871	label = 222LLU; // matchsym
44535	44872	break;
44536	44873	}
44537		- case 3726LLU: // copy-back deleter (matchsym to procblock)
	44874	+ case 3765LLU: // copy-back deleter (matchsym to procblock)
44538	44875	{
44539	44876	// copy mutable arguments back from call to matchsym
44540	44877	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44541		- label = 3710LLU; // continue to roll stack
	44878	+ label = 3749LLU; // continue to roll stack
44542	44879	break;
44543	44880	}
44544		- case 3727LLU: // return from matchsym to procblock
	44881	+ case 3766LLU: // return from matchsym to procblock
44545	44882	{
44546	44883	// copy mutable arguments back from call to matchsym
44547	44884	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44548	44885	// call matchsym from procblock
44549		- stack[base + 27LLU] = 3728LLU/throw to this address/;
	44886	+ stack[base + 27LLU] = 3767LLU/throw to this address/;
44550	44887	stack[base + 28LLU] = base;
44551		- stack[base + 29LLU] = 3729LLU;
	44888	+ stack[base + 29LLU] = 3768LLU;
44552	44889	// arguments for call to matchsym
44553	44890	stack[base + 30LLU] = stack[base + 8]/fnid/;
44554	44891	stack[base + 31LLU] = 62LLU;

		@@ -44558,21 +44895,21 @@
44558	44895	label = 222LLU; // matchsym
44559	44896	break;
44560	44897	}
44561		- case 3728LLU: // copy-back deleter (matchsym to procblock)
	44898	+ case 3767LLU: // copy-back deleter (matchsym to procblock)
44562	44899	{
44563	44900	// copy mutable arguments back from call to matchsym
44564	44901	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44565		- label = 3710LLU; // continue to roll stack
	44902	+ label = 3749LLU; // continue to roll stack
44566	44903	break;
44567	44904	}
44568		- case 3729LLU: // return from matchsym to procblock
	44905	+ case 3768LLU: // return from matchsym to procblock
44569	44906	{
44570	44907	// copy mutable arguments back from call to matchsym
44571	44908	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44572	44909	// call matchsym from procblock
44573		- stack[base + 27LLU] = 3730LLU/throw to this address/;
	44910	+ stack[base + 27LLU] = 3769LLU/throw to this address/;
44574	44911	stack[base + 28LLU] = base;
44575		- stack[base + 29LLU] = 3731LLU;
	44912	+ stack[base + 29LLU] = 3770LLU;
44576	44913	// arguments for call to matchsym
44577	44914	stack[base + 30LLU] = stack[base + 8]/fnid/;
44578	44915	stack[base + 31LLU] = 40LLU;

		@@ -44582,38 +44919,38 @@
44582	44919	label = 222LLU; // matchsym
44583	44920	break;
44584	44921	}
44585		- case 3730LLU: // copy-back deleter (matchsym to procblock)
	44922	+ case 3769LLU: // copy-back deleter (matchsym to procblock)
44586	44923	{
44587	44924	// copy mutable arguments back from call to matchsym
44588	44925	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44589		- label = 3710LLU; // continue to roll stack
	44926	+ label = 3749LLU; // continue to roll stack
44590	44927	break;
44591	44928	}
44592		- case 3731LLU: // return from matchsym to procblock
	44929	+ case 3770LLU: // return from matchsym to procblock
44593	44930	{
44594	44931	// copy mutable arguments back from call to matchsym
44595	44932	stack[base + 19]/lookahead/ = stack[base + 32LLU];
44596		- label = 3733LLU; // skip deleter
	44933	+ label = 3772LLU; // skip deleter
44597	44934	break;
44598	44935	}
44599		- case 3732LLU: // deleter
	44936	+ case 3771LLU: // deleter
44600	44937	{
44601	44938	// throw from procblock
44602	44939	if(!stack[base + 27])
44603	44940	{
44604		- label = 3710LLU; // skip, variable already deleted/unscoped
	44941	+ label = 3749LLU; // skip, variable already deleted/unscoped
44605	44942	break;
44606	44943	}
44607		- label = 3710LLU; // continue unrolling stack, delete next variable
	44944	+ label = 3749LLU; // continue unrolling stack, delete next variable
44608	44945	break;
44609	44946	}
44610		- case 3733LLU: // skipped deleter
	44947	+ case 3772LLU: // skipped deleter
44611	44948	{
44612	44949	stack[base + 27] = 0;
44613	44950	// call ParseToken from procblock
44614		- stack[base + 28LLU] = 3734LLU/throw to this address/;
	44951	+ stack[base + 28LLU] = 3773LLU/throw to this address/;
44615	44952	stack[base + 29LLU] = base;
44616		- stack[base + 30LLU] = 3735LLU;
	44953	+ stack[base + 30LLU] = 3774LLU;
44617	44954	// arguments for call to ParseToken
44618	44955	stack[base + 33LLU] = stack[base + 19]/lookahead/;
44619	44956	// set stack-base & callee-address

		@@ -44621,14 +44958,14 @@
44621	44958	label = 3LLU; // ParseToken
44622	44959	break;
44623	44960	}
44624		- case 3734LLU: // copy-back deleter (ParseToken to procblock)
	44961	+ case 3773LLU: // copy-back deleter (ParseToken to procblock)
44625	44962	{
44626	44963	// copy mutable arguments back from call to ParseToken
44627	44964	stack[base + 19]/lookahead/ = stack[base + 33LLU];
44628		- label = 3732LLU; // continue to roll stack
	44965	+ label = 3771LLU; // continue to roll stack
44629	44966	break;
44630	44967	}
44631		- case 3735LLU: // return from ParseToken to procblock
	44968	+ case 3774LLU: // return from ParseToken to procblock
44632	44969	{
44633	44970	// copy mutable arguments back from call to ParseToken
44634	44971	stack[base + 19]/lookahead/ = stack[base + 33LLU];

		@@ -44636,9 +44973,9 @@
44636	44973	stack[base + 15] = stack[base + 31LLU];
44637	44974	stack[base + 27] = stack[base + 32LLU];
44638	44975	// call equ from procblock
44639		- stack[base + 28LLU] = 3736LLU/throw to this address/;
	44976	+ stack[base + 28LLU] = 3775LLU/throw to this address/;
44640	44977	stack[base + 29LLU] = base;
44641		- stack[base + 30LLU] = 3737LLU;
	44978	+ stack[base + 30LLU] = 3776LLU;
44642	44979	// arguments for call to equ
44643	44980	stack[base + 32LLU] = stack[base + 15]/variant/;
44644	44981	stack[base + 33LLU] = 4LLU;

		@@ -44647,13 +44984,13 @@
44647	44984	label = 18446744073709551600LLU; // equ
44648	44985	break;
44649	44986	}
44650		- case 3736LLU: // copy-back deleter (equ to procblock)
	44987	+ case 3775LLU: // copy-back deleter (equ to procblock)
44651	44988	{
44652	44989	// copy mutable arguments back from call to equ
44653		- label = 3732LLU; // continue to roll stack
	44990	+ label = 3771LLU; // continue to roll stack
44654	44991	break;
44655	44992	}
44656		- case 3737LLU: // return from equ to procblock
	44993	+ case 3776LLU: // return from equ to procblock
44657	44994	{
44658	44995	// copy mutable arguments back from call to equ
44659	44996	// copy back results provided by call to equ

		@@ -44660,15 +44997,15 @@
44660	44997	stack[base + 20] = stack[base + 31LLU];
44661	44998	if(!stack[base + 20]/isequal/)
44662	44999	{
44663		- label = 3738LLU; // jump to alternative
	45000	+ label = 3777LLU; // jump to alternative
44664	45001	break;
44665	45002	}
44666	45003
44667	45004	// consequent
44668	45005	// call assertu64 from procblock
44669		- stack[base + 28LLU] = 3740LLU/throw to this address/;
	45006	+ stack[base + 28LLU] = 3779LLU/throw to this address/;
44670	45007	stack[base + 29LLU] = base;
44671		- stack[base + 30LLU] = 3741LLU;
	45008	+ stack[base + 30LLU] = 3780LLU;
44672	45009	// arguments for call to assertu64
44673	45010	stack[base + 31LLU] = stack[base + 8]/fnid/;
44674	45011	stack[base + 32LLU] = 910732593752702976LLU;

		@@ -44680,25 +45017,25 @@
44680	45017	label = 3085LLU; // assertu64
44681	45018	break;
44682	45019	}
44683		- case 3740LLU: // copy-back deleter (assertu64 to procblock)
	45020	+ case 3779LLU: // copy-back deleter (assertu64 to procblock)
44684	45021	{
44685	45022	// copy mutable arguments back from call to assertu64
44686		- label = 3732LLU; // continue to roll stack
	45023	+ label = 3771LLU; // continue to roll stack
44687	45024	break;
44688	45025	}
44689		- case 3741LLU: // return from assertu64 to procblock
	45026	+ case 3780LLU: // return from assertu64 to procblock
44690	45027	{
44691	45028	// copy mutable arguments back from call to assertu64
44692		- label = 3739LLU; // consequent complete
	45029	+ label = 3778LLU; // consequent complete
44693	45030	break;
44694	45031	}
44695		- case 3738LLU: // alternative
	45032	+ case 3777LLU: // alternative
44696	45033	{
44697	45034	fprintf(stderr, "%s", "expected identifier in while but found ");
44698	45035	// call reporttok from procblock
44699		- stack[base + 28LLU] = 3742LLU/throw to this address/;
	45036	+ stack[base + 28LLU] = 3781LLU/throw to this address/;
44700	45037	stack[base + 29LLU] = base;
44701		- stack[base + 30LLU] = 3743LLU;
	45038	+ stack[base + 30LLU] = 3782LLU;
44702	45039	// arguments for call to reporttok
44703	45040	stack[base + 31LLU] = stack[base + 15]/variant/;
44704	45041	stack[base + 32LLU] = stack[base + 27]/counterid/;

		@@ -44707,30 +45044,30 @@
44707	45044	label = 18446744073709551582LLU; // reporttok
44708	45045	break;
44709	45046	}
44710		- case 3742LLU: // copy-back deleter (reporttok to procblock)
	45047	+ case 3781LLU: // copy-back deleter (reporttok to procblock)
44711	45048	{
44712	45049	// copy mutable arguments back from call to reporttok
44713		- label = 3732LLU; // continue to roll stack
	45050	+ label = 3771LLU; // continue to roll stack
44714	45051	break;
44715	45052	}
44716		- case 3743LLU: // return from reporttok to procblock
	45053	+ case 3782LLU: // return from reporttok to procblock
44717	45054	{
44718	45055	// copy mutable arguments back from call to reporttok
44719	45056	fprintf(stderr, "%s", "\n");
44720	45057	{
44721		- label = 3732LLU; // throw: begin to unroll stack
	45058	+ label = 3771LLU; // throw: begin to unroll stack
44722	45059	break;
44723	45060	}
44724	45061
44725		- label = 3739LLU; // alternative complete
	45062	+ label = 3778LLU; // alternative complete
44726	45063	break;
44727	45064	}
44728		- case 3739LLU: // completed if-then-else
	45065	+ case 3778LLU: // completed if-then-else
44729	45066	{
44730	45067	// call matchsym from procblock
44731		- stack[base + 28LLU] = 3744LLU/throw to this address/;
	45068	+ stack[base + 28LLU] = 3783LLU/throw to this address/;
44732	45069	stack[base + 29LLU] = base;
44733		- stack[base + 30LLU] = 3745LLU;
	45070	+ stack[base + 30LLU] = 3784LLU;
44734	45071	// arguments for call to matchsym
44735	45072	stack[base + 31LLU] = stack[base + 8]/fnid/;
44736	45073	stack[base + 32LLU] = 41LLU;

		@@ -44740,26 +45077,26 @@
44740	45077	label = 222LLU; // matchsym
44741	45078	break;
44742	45079	}
44743		- case 3744LLU: // copy-back deleter (matchsym to procblock)
	45080	+ case 3783LLU: // copy-back deleter (matchsym to procblock)
44744	45081	{
44745	45082	// copy mutable arguments back from call to matchsym
44746	45083	stack[base + 19]/lookahead/ = stack[base + 33LLU];
44747		- label = 3732LLU; // continue to roll stack
	45084	+ label = 3771LLU; // continue to roll stack
44748	45085	break;
44749	45086	}
44750		- case 3745LLU: // return from matchsym to procblock
	45087	+ case 3784LLU: // return from matchsym to procblock
44751	45088	{
44752	45089	// copy mutable arguments back from call to matchsym
44753	45090	stack[base + 19]/lookahead/ = stack[base + 33LLU];
44754		- label = 3747LLU; // skip deleter
	45091	+ label = 3786LLU; // skip deleter
44755	45092	break;
44756	45093	}
44757		- case 3746LLU: // deleter
	45094	+ case 3785LLU: // deleter
44758	45095	{
44759	45096	// throw from procblock
44760	45097	if(!stack[base + 28])
44761	45098	{
44762		- label = 3732LLU; // skip, variable already deleted/unscoped
	45099	+ label = 3771LLU; // skip, variable already deleted/unscoped
44763	45100	break;
44764	45101	}
44765	45102

		@@ -44768,7 +45105,7 @@
44768	45105	newstack[0] = (uint64_t)stack; // backup stack location
44769	45106	newstack[1] = 1234567890;
44770	45107	newstack[2] = base;
44771		- newstack[3] = 3748LLU;
	45108	+ newstack[3] = 3787LLU;
44772	45109	stack = newstack;
44773	45110	// set stack-base & callee-address
44774	45111	base = 4/deloffset/;

		@@ -44775,21 +45112,21 @@
44775	45112	label = 306LLU; // ~type
44776	45113	break;
44777	45114	}
44778		- case 3748LLU: // return from ~type to procblock
	45115	+ case 3787LLU: // return from ~type to procblock
44779	45116	{
44780	45117	stack = (uint64_t *)stack[0];
44781	45118	// releasing toplevel container
44782	45119	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
44783	45120
44784		- label = 3732LLU; // continue unrolling stack, delete next variable
	45121	+ label = 3771LLU; // continue unrolling stack, delete next variable
44785	45122	break;
44786	45123	}
44787		- case 3747LLU: // skipped deleter
	45124	+ case 3786LLU: // skipped deleter
44788	45125	{
44789	45126	// call mktypename from procblock
44790		- stack[base + 29LLU] = 3749LLU/throw to this address/;
	45127	+ stack[base + 29LLU] = 3788LLU/throw to this address/;
44791	45128	stack[base + 30LLU] = base;
44792		- stack[base + 31LLU] = 3750LLU;
	45129	+ stack[base + 31LLU] = 3789LLU;
44793	45130	// arguments for call to mktypename
44794	45131	stack[base + 33LLU] = 881834713755418624LLU;
44795	45132	// set stack-base & callee-address

		@@ -44797,37 +45134,37 @@
44797	45134	label = 310LLU; // mktypename
44798	45135	break;
44799	45136	}
44800		- case 3749LLU: // copy-back deleter (mktypename to procblock)
	45137	+ case 3788LLU: // copy-back deleter (mktypename to procblock)
44801	45138	{
44802	45139	// copy mutable arguments back from call to mktypename
44803		- label = 3732LLU; // continue to roll stack
	45140	+ label = 3771LLU; // continue to roll stack
44804	45141	break;
44805	45142	}
44806		- case 3750LLU: // return from mktypename to procblock
	45143	+ case 3789LLU: // return from mktypename to procblock
44807	45144	{
44808	45145	// copy mutable arguments back from call to mktypename
44809	45146	// copy back results provided by call to mktypename
44810	45147	stack[base + 28] = stack[base + 32LLU];
44811		- label = 3752LLU; // skip deleter
	45148	+ label = 3791LLU; // skip deleter
44812	45149	break;
44813	45150	}
44814		- case 3751LLU: // deleter
	45151	+ case 3790LLU: // deleter
44815	45152	{
44816	45153	// throw from procblock
44817	45154	if(!stack[base + 29])
44818	45155	{
44819		- label = 3746LLU; // skip, variable already deleted/unscoped
	45156	+ label = 3785LLU; // skip, variable already deleted/unscoped
44820	45157	break;
44821	45158	}
44822		- label = 3746LLU; // continue unrolling stack, delete next variable
	45159	+ label = 3785LLU; // continue unrolling stack, delete next variable
44823	45160	break;
44824	45161	}
44825		- case 3752LLU: // skipped deleter
	45162	+ case 3791LLU: // skipped deleter
44826	45163	{
44827	45164	// call newvarraw from procblock
44828		- stack[base + 30LLU] = 3753LLU/throw to this address/;
	45165	+ stack[base + 30LLU] = 3792LLU/throw to this address/;
44829	45166	stack[base + 31LLU] = base;
44830		- stack[base + 32LLU] = 3754LLU;
	45167	+ stack[base + 32LLU] = 3793LLU;
44831	45168	// arguments for call to newvarraw
44832	45169	stack[base + 34LLU] = stack[base + 28]/counttype/;
44833	45170	stack[base + 35LLU] = stack[base + 27]/counterid/;

		@@ -44843,16 +45180,16 @@
44843	45180	label = 755LLU; // newvarraw
44844	45181	break;
44845	45182	}
44846		- case 3753LLU: // copy-back deleter (newvarraw to procblock)
	45183	+ case 3792LLU: // copy-back deleter (newvarraw to procblock)
44847	45184	{
44848	45185	// copy mutable arguments back from call to newvarraw
44849	45186	stack[base + 3]/scope/ = stack[base + 41LLU];
44850	45187	stack[base + 18]/varcount/ = stack[base + 40LLU];
44851	45188	stack[base + 12]/fnmaxcount/ = stack[base + 39LLU];
44852		- label = 3746LLU; // continue to roll stack
	45189	+ label = 3785LLU; // continue to roll stack
44853	45190	break;
44854	45191	}
44855		- case 3754LLU: // return from newvarraw to procblock
	45192	+ case 3793LLU: // return from newvarraw to procblock
44856	45193	{
44857	45194	// copy mutable arguments back from call to newvarraw
44858	45195	stack[base + 3]/scope/ = stack[base + 41LLU];

		@@ -44862,9 +45199,9 @@
44862	45199	stack[base + 29] = stack[base + 33LLU];
44863	45200	printf("%s", "\n ");
44864	45201	// call emitvaridx from procblock
44865		- stack[base + 30LLU] = 3755LLU/throw to this address/;
	45202	+ stack[base + 30LLU] = 3794LLU/throw to this address/;
44866	45203	stack[base + 31LLU] = base;
44867		- stack[base + 32LLU] = 3756LLU;
	45204	+ stack[base + 32LLU] = 3795LLU;
44868	45205	// arguments for call to emitvaridx
44869	45206	stack[base + 33LLU] = stack[base + 29]/counteridx/;
44870	45207	// set stack-base & callee-address

		@@ -44872,20 +45209,20 @@
44872	45209	label = 741LLU; // emitvaridx
44873	45210	break;
44874	45211	}
44875		- case 3755LLU: // copy-back deleter (emitvaridx to procblock)
	45212	+ case 3794LLU: // copy-back deleter (emitvaridx to procblock)
44876	45213	{
44877	45214	// copy mutable arguments back from call to emitvaridx
44878		- label = 3751LLU; // continue to roll stack
	45215	+ label = 3790LLU; // continue to roll stack
44879	45216	break;
44880	45217	}
44881		- case 3756LLU: // return from emitvaridx to procblock
	45218	+ case 3795LLU: // return from emitvaridx to procblock
44882	45219	{
44883	45220	// copy mutable arguments back from call to emitvaridx
44884	45221	printf("%s", " = ");
44885	45222	// call emitvar from procblock
44886		- stack[base + 30LLU] = 3757LLU/throw to this address/;
	45223	+ stack[base + 30LLU] = 3796LLU/throw to this address/;
44887	45224	stack[base + 31LLU] = base;
44888		- stack[base + 32LLU] = 3758LLU;
	45225	+ stack[base + 32LLU] = 3797LLU;
44889	45226	// arguments for call to emitvar
44890	45227	stack[base + 33LLU] = stack[base + 8]/fnid/;
44891	45228	stack[base + 34LLU] = stack[base + 26]/loopid/;

		@@ -44896,21 +45233,21 @@
44896	45233	label = 745LLU; // emitvar
44897	45234	break;
44898	45235	}
44899		- case 3757LLU: // copy-back deleter (emitvar to procblock)
	45236	+ case 3796LLU: // copy-back deleter (emitvar to procblock)
44900	45237	{
44901	45238	// copy mutable arguments back from call to emitvar
44902		- label = 3751LLU; // continue to roll stack
	45239	+ label = 3790LLU; // continue to roll stack
44903	45240	break;
44904	45241	}
44905		- case 3758LLU: // return from emitvar to procblock
	45242	+ case 3797LLU: // return from emitvar to procblock
44906	45243	{
44907	45244	// copy mutable arguments back from call to emitvar
44908	45245	printf("%s", ";\n");
44909	45246	printf("%s", "\n label = ");
44910	45247	// call printnr from procblock
44911		- stack[base + 30LLU] = 3759LLU/throw to this address/;
	45248	+ stack[base + 30LLU] = 3798LLU/throw to this address/;
44912	45249	stack[base + 31LLU] = base;
44913		- stack[base + 32LLU] = 3760LLU;
	45250	+ stack[base + 32LLU] = 3799LLU;
44914	45251	// arguments for call to printnr
44915	45252	stack[base + 33LLU] = stack[base + 22]/labelloop/;
44916	45253	// set stack-base & callee-address

		@@ -44918,13 +45255,13 @@
44918	45255	label = 18446744073709551590LLU; // printnr
44919	45256	break;
44920	45257	}
44921		- case 3759LLU: // copy-back deleter (printnr to procblock)
	45258	+ case 3798LLU: // copy-back deleter (printnr to procblock)
44922	45259	{
44923	45260	// copy mutable arguments back from call to printnr
44924		- label = 3751LLU; // continue to roll stack
	45261	+ label = 3790LLU; // continue to roll stack
44925	45262	break;
44926	45263	}
44927		- case 3760LLU: // return from printnr to procblock
	45264	+ case 3799LLU: // return from printnr to procblock
44928	45265	{
44929	45266	// copy mutable arguments back from call to printnr
44930	45267	printf("%s", "LLU; // start to repeat");

		@@ -44932,9 +45269,9 @@
44932	45269	printf("%s", "\n }");
44933	45270	printf("%s", "\n case ");
44934	45271	// call printnr from procblock
44935		- stack[base + 30LLU] = 3761LLU/throw to this address/;
	45272	+ stack[base + 30LLU] = 3800LLU/throw to this address/;
44936	45273	stack[base + 31LLU] = base;
44937		- stack[base + 32LLU] = 3762LLU;
	45274	+ stack[base + 32LLU] = 3801LLU;
44938	45275	// arguments for call to printnr
44939	45276	stack[base + 33LLU] = stack[base + 22]/labelloop/;
44940	45277	// set stack-base & callee-address

		@@ -44942,13 +45279,13 @@
44942	45279	label = 18446744073709551590LLU; // printnr
44943	45280	break;
44944	45281	}
44945		- case 3761LLU: // copy-back deleter (printnr to procblock)
	45282	+ case 3800LLU: // copy-back deleter (printnr to procblock)
44946	45283	{
44947	45284	// copy mutable arguments back from call to printnr
44948		- label = 3751LLU; // continue to roll stack
	45285	+ label = 3790LLU; // continue to roll stack
44949	45286	break;
44950	45287	}
44951		- case 3762LLU: // return from printnr to procblock
	45288	+ case 3801LLU: // return from printnr to procblock
44952	45289	{
44953	45290	// copy mutable arguments back from call to printnr
44954	45291	printf("%s", "LLU: // repeat from here");

		@@ -44955,9 +45292,9 @@
44955	45292	printf("%s", "\n {");
44956	45293	printf("%s", "\n if(!");
44957	45294	// call emitvaridx from procblock
44958		- stack[base + 30LLU] = 3763LLU/throw to this address/;
	45295	+ stack[base + 30LLU] = 3802LLU/throw to this address/;
44959	45296	stack[base + 31LLU] = base;
44960		- stack[base + 32LLU] = 3764LLU;
	45297	+ stack[base + 32LLU] = 3803LLU;
44961	45298	// arguments for call to emitvaridx
44962	45299	stack[base + 33LLU] = stack[base + 29]/counteridx/;
44963	45300	// set stack-base & callee-address

		@@ -44965,13 +45302,13 @@
44965	45302	label = 741LLU; // emitvaridx
44966	45303	break;
44967	45304	}
44968		- case 3763LLU: // copy-back deleter (emitvaridx to procblock)
	45305	+ case 3802LLU: // copy-back deleter (emitvaridx to procblock)
44969	45306	{
44970	45307	// copy mutable arguments back from call to emitvaridx
44971		- label = 3751LLU; // continue to roll stack
	45308	+ label = 3790LLU; // continue to roll stack
44972	45309	break;
44973	45310	}
44974		- case 3764LLU: // return from emitvaridx to procblock
	45311	+ case 3803LLU: // return from emitvaridx to procblock
44975	45312	{
44976	45313	// copy mutable arguments back from call to emitvaridx
44977	45314	printf("%s", "--)");

		@@ -44981,7 +45318,7 @@
44981	45318	newstack[0] = (uint64_t)stack; // backup stack location
44982	45319	newstack[1] = 1234567890;
44983	45320	newstack[2] = base;
44984		- newstack[3] = 3765LLU;
	45321	+ newstack[3] = 3804LLU;
44985	45322	stack = newstack;
44986	45323	// set stack-base & callee-address
44987	45324	base = 4/deloffset/;

		@@ -44988,22 +45325,22 @@
44988	45325	label = 306LLU; // ~type
44989	45326	break;
44990	45327	}
44991		- case 3765LLU: // return from ~type to procblock
	45328	+ case 3804LLU: // return from ~type to procblock
44992	45329	{
44993	45330	stack = (uint64_t *)stack[0];
44994	45331	// releasing toplevel container
44995	45332	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
44996	45333
44997		- label = 3725LLU; // consequent complete
	45334	+ label = 3764LLU; // consequent complete
44998	45335	break;
44999	45336	}
45000		- case 3724LLU: // alternative
	45337	+ case 3763LLU: // alternative
45001	45338	{
45002	45339	printf("%s", "\n label = ");
45003	45340	// call printnr from procblock
45004		- stack[base + 27LLU] = 3766LLU/throw to this address/;
	45341	+ stack[base + 27LLU] = 3805LLU/throw to this address/;
45005	45342	stack[base + 28LLU] = base;
45006		- stack[base + 29LLU] = 3767LLU;
	45343	+ stack[base + 29LLU] = 3806LLU;
45007	45344	// arguments for call to printnr
45008	45345	stack[base + 30LLU] = stack[base + 22]/labelloop/;
45009	45346	// set stack-base & callee-address

		@@ -45011,13 +45348,13 @@
45011	45348	label = 18446744073709551590LLU; // printnr
45012	45349	break;
45013	45350	}
45014		- case 3766LLU: // copy-back deleter (printnr to procblock)
	45351	+ case 3805LLU: // copy-back deleter (printnr to procblock)
45015	45352	{
45016	45353	// copy mutable arguments back from call to printnr
45017		- label = 3710LLU; // continue to roll stack
	45354	+ label = 3749LLU; // continue to roll stack
45018	45355	break;
45019	45356	}
45020		- case 3767LLU: // return from printnr to procblock
	45357	+ case 3806LLU: // return from printnr to procblock
45021	45358	{
45022	45359	// copy mutable arguments back from call to printnr
45023	45360	printf("%s", "LLU; // start to repeat");

		@@ -45025,9 +45362,9 @@
45025	45362	printf("%s", "\n }");
45026	45363	printf("%s", "\n case ");
45027	45364	// call printnr from procblock
45028		- stack[base + 27LLU] = 3768LLU/throw to this address/;
	45365	+ stack[base + 27LLU] = 3807LLU/throw to this address/;
45029	45366	stack[base + 28LLU] = base;
45030		- stack[base + 29LLU] = 3769LLU;
	45367	+ stack[base + 29LLU] = 3808LLU;
45031	45368	// arguments for call to printnr
45032	45369	stack[base + 30LLU] = stack[base + 22]/labelloop/;
45033	45370	// set stack-base & callee-address

		@@ -45035,13 +45372,13 @@
45035	45372	label = 18446744073709551590LLU; // printnr
45036	45373	break;
45037	45374	}
45038		- case 3768LLU: // copy-back deleter (printnr to procblock)
	45375	+ case 3807LLU: // copy-back deleter (printnr to procblock)
45039	45376	{
45040	45377	// copy mutable arguments back from call to printnr
45041		- label = 3710LLU; // continue to roll stack
	45378	+ label = 3749LLU; // continue to roll stack
45042	45379	break;
45043	45380	}
45044		- case 3769LLU: // return from printnr to procblock
	45381	+ case 3808LLU: // return from printnr to procblock
45045	45382	{
45046	45383	// copy mutable arguments back from call to printnr
45047	45384	printf("%s", "LLU: // repeat from here");

		@@ -45048,31 +45385,31 @@
45048	45385	printf("%s", "\n {");
45049	45386	if(!stack[base + 25]/inputflag/)
45050	45387	{
45051		- label = 3770LLU; // jump to alternative
	45388	+ label = 3809LLU; // jump to alternative
45052	45389	break;
45053	45390	}
45054	45391
45055	45392	// consequent
45056		- label = 3773LLU; // skip deleter
	45393	+ label = 3812LLU; // skip deleter
45057	45394	break;
45058	45395	}
45059		- case 3772LLU: // deleter
	45396	+ case 3811LLU: // deleter
45060	45397	{
45061	45398	// throw from procblock
45062	45399	if(!stack[base + 27])
45063	45400	{
45064		- label = 3710LLU; // skip, variable already deleted/unscoped
	45401	+ label = 3749LLU; // skip, variable already deleted/unscoped
45065	45402	break;
45066	45403	}
45067		- label = 3710LLU; // continue unrolling stack, delete next variable
	45404	+ label = 3749LLU; // continue unrolling stack, delete next variable
45068	45405	break;
45069	45406	}
45070		- case 3773LLU: // skipped deleter
	45407	+ case 3812LLU: // skipped deleter
45071	45408	{
45072	45409	// call findletmut from procblock
45073		- stack[base + 28LLU] = 3774LLU/throw to this address/;
	45410	+ stack[base + 28LLU] = 3813LLU/throw to this address/;
45074	45411	stack[base + 29LLU] = base;
45075		- stack[base + 30LLU] = 3775LLU;
	45412	+ stack[base + 30LLU] = 3814LLU;
45076	45413	// arguments for call to findletmut
45077	45414	stack[base + 32LLU] = stack[base + 8]/fnid/;
45078	45415	stack[base + 33LLU] = stack[base + 26]/loopid/;

		@@ -45083,13 +45420,13 @@
45083	45420	label = 714LLU; // findletmut
45084	45421	break;
45085	45422	}
45086		- case 3774LLU: // copy-back deleter (findletmut to procblock)
	45423	+ case 3813LLU: // copy-back deleter (findletmut to procblock)
45087	45424	{
45088	45425	// copy mutable arguments back from call to findletmut
45089		- label = 3710LLU; // continue to roll stack
	45426	+ label = 3749LLU; // continue to roll stack
45090	45427	break;
45091	45428	}
45092		- case 3775LLU: // return from findletmut to procblock
	45429	+ case 3814LLU: // return from findletmut to procblock
45093	45430	{
45094	45431	// copy mutable arguments back from call to findletmut
45095	45432	// copy back results provided by call to findletmut

		@@ -45096,21 +45433,21 @@
45096	45433	stack[base + 27] = stack[base + 31LLU];
45097	45434	if(!stack[base + 27]/mutable/)
45098	45435	{
45099		- label = 3776LLU; // jump to alternative
	45436	+ label = 3815LLU; // jump to alternative
45100	45437	break;
45101	45438	}
45102	45439
45103	45440	// consequent
45104		- label = 3777LLU; // consequent complete
	45441	+ label = 3816LLU; // consequent complete
45105	45442	break;
45106	45443	}
45107		- case 3776LLU: // alternative
	45444	+ case 3815LLU: // alternative
45108	45445	{
45109	45446	fprintf(stderr, "%s", "in function ");
45110	45447	// call reportid from procblock
45111		- stack[base + 28LLU] = 3778LLU/throw to this address/;
	45448	+ stack[base + 28LLU] = 3817LLU/throw to this address/;
45112	45449	stack[base + 29LLU] = base;
45113		- stack[base + 30LLU] = 3779LLU;
	45450	+ stack[base + 30LLU] = 3818LLU;
45114	45451	// arguments for call to reportid
45115	45452	stack[base + 31LLU] = stack[base + 8]/fnid/;
45116	45453	// set stack-base & callee-address

		@@ -45118,21 +45455,21 @@
45118	45455	label = 18446744073709551586LLU; // reportid
45119	45456	break;
45120	45457	}
45121		- case 3778LLU: // copy-back deleter (reportid to procblock)
	45458	+ case 3817LLU: // copy-back deleter (reportid to procblock)
45122	45459	{
45123	45460	// copy mutable arguments back from call to reportid
45124		- label = 3772LLU; // continue to roll stack
	45461	+ label = 3811LLU; // continue to roll stack
45125	45462	break;
45126	45463	}
45127		- case 3779LLU: // return from reportid to procblock
	45464	+ case 3818LLU: // return from reportid to procblock
45128	45465	{
45129	45466	// copy mutable arguments back from call to reportid
45130	45467	fprintf(stderr, "%s", ": ");
45131	45468	fprintf(stderr, "%s", "while input requires mutable variable but found constant ");
45132	45469	// call reportid from procblock
45133		- stack[base + 28LLU] = 3780LLU/throw to this address/;
	45470	+ stack[base + 28LLU] = 3819LLU/throw to this address/;
45134	45471	stack[base + 29LLU] = base;
45135		- stack[base + 30LLU] = 3781LLU;
	45472	+ stack[base + 30LLU] = 3820LLU;
45136	45473	// arguments for call to reportid
45137	45474	stack[base + 31LLU] = stack[base + 26]/loopid/;
45138	45475	// set stack-base & callee-address

		@@ -45140,31 +45477,31 @@
45140	45477	label = 18446744073709551586LLU; // reportid
45141	45478	break;
45142	45479	}
45143		- case 3780LLU: // copy-back deleter (reportid to procblock)
	45480	+ case 3819LLU: // copy-back deleter (reportid to procblock)
45144	45481	{
45145	45482	// copy mutable arguments back from call to reportid
45146		- label = 3772LLU; // continue to roll stack
	45483	+ label = 3811LLU; // continue to roll stack
45147	45484	break;
45148	45485	}
45149		- case 3781LLU: // return from reportid to procblock
	45486	+ case 3820LLU: // return from reportid to procblock
45150	45487	{
45151	45488	// copy mutable arguments back from call to reportid
45152	45489	fprintf(stderr, "%s", "\n");
45153	45490	{
45154		- label = 3772LLU; // throw: begin to unroll stack
	45491	+ label = 3811LLU; // throw: begin to unroll stack
45155	45492	break;
45156	45493	}
45157	45494
45158		- label = 3777LLU; // alternative complete
	45495	+ label = 3816LLU; // alternative complete
45159	45496	break;
45160	45497	}
45161		- case 3777LLU: // completed if-then-else
	45498	+ case 3816LLU: // completed if-then-else
45162	45499	{
45163	45500	printf("%s", "\n if(");
45164	45501	// call emitvar from procblock
45165		- stack[base + 28LLU] = 3782LLU/throw to this address/;
	45502	+ stack[base + 28LLU] = 3821LLU/throw to this address/;
45166	45503	stack[base + 29LLU] = base;
45167		- stack[base + 30LLU] = 3783LLU;
	45504	+ stack[base + 30LLU] = 3822LLU;
45168	45505	// arguments for call to emitvar
45169	45506	stack[base + 31LLU] = stack[base + 8]/fnid/;
45170	45507	stack[base + 32LLU] = stack[base + 26]/loopid/;

		@@ -45175,26 +45512,26 @@
45175	45512	label = 745LLU; // emitvar
45176	45513	break;
45177	45514	}
45178		- case 3782LLU: // copy-back deleter (emitvar to procblock)
	45515	+ case 3821LLU: // copy-back deleter (emitvar to procblock)
45179	45516	{
45180	45517	// copy mutable arguments back from call to emitvar
45181		- label = 3772LLU; // continue to roll stack
	45518	+ label = 3811LLU; // continue to roll stack
45182	45519	break;
45183	45520	}
45184		- case 3783LLU: // return from emitvar to procblock
	45521	+ case 3822LLU: // return from emitvar to procblock
45185	45522	{
45186	45523	// copy mutable arguments back from call to emitvar
45187	45524	printf("%s", " > 0xFF)");
45188		- label = 3771LLU; // consequent complete
	45525	+ label = 3810LLU; // consequent complete
45189	45526	break;
45190	45527	}
45191		- case 3770LLU: // alternative
	45528	+ case 3809LLU: // alternative
45192	45529	{
45193	45530	printf("%s", "\n if(!");
45194	45531	// call emitvar from procblock
45195		- stack[base + 27LLU] = 3784LLU/throw to this address/;
	45532	+ stack[base + 27LLU] = 3823LLU/throw to this address/;
45196	45533	stack[base + 28LLU] = base;
45197		- stack[base + 29LLU] = 3785LLU;
	45534	+ stack[base + 29LLU] = 3824LLU;
45198	45535	// arguments for call to emitvar
45199	45536	stack[base + 30LLU] = stack[base + 8]/fnid/;
45200	45537	stack[base + 31LLU] = stack[base + 26]/loopid/;

		@@ -45205,21 +45542,21 @@
45205	45542	label = 745LLU; // emitvar
45206	45543	break;
45207	45544	}
45208		- case 3784LLU: // copy-back deleter (emitvar to procblock)
	45545	+ case 3823LLU: // copy-back deleter (emitvar to procblock)
45209	45546	{
45210	45547	// copy mutable arguments back from call to emitvar
45211		- label = 3710LLU; // continue to roll stack
	45548	+ label = 3749LLU; // continue to roll stack
45212	45549	break;
45213	45550	}
45214		- case 3785LLU: // return from emitvar to procblock
	45551	+ case 3824LLU: // return from emitvar to procblock
45215	45552	{
45216	45553	// copy mutable arguments back from call to emitvar
45217	45554	printf("%s", ")");
45218	45555	fprintf(stderr, "%s", "in function ");
45219	45556	// call reportid from procblock
45220		- stack[base + 27LLU] = 3786LLU/throw to this address/;
	45557	+ stack[base + 27LLU] = 3825LLU/throw to this address/;
45221	45558	stack[base + 28LLU] = base;
45222		- stack[base + 29LLU] = 3787LLU;
	45559	+ stack[base + 29LLU] = 3826LLU;
45223	45560	// arguments for call to reportid
45224	45561	stack[base + 30LLU] = stack[base + 8]/fnid/;
45225	45562	// set stack-base & callee-address

		@@ -45227,35 +45564,35 @@
45227	45564	label = 18446744073709551586LLU; // reportid
45228	45565	break;
45229	45566	}
45230		- case 3786LLU: // copy-back deleter (reportid to procblock)
	45567	+ case 3825LLU: // copy-back deleter (reportid to procblock)
45231	45568	{
45232	45569	// copy mutable arguments back from call to reportid
45233		- label = 3710LLU; // continue to roll stack
	45570	+ label = 3749LLU; // continue to roll stack
45234	45571	break;
45235	45572	}
45236		- case 3787LLU: // return from reportid to procblock
	45573	+ case 3826LLU: // return from reportid to procblock
45237	45574	{
45238	45575	// copy mutable arguments back from call to reportid
45239	45576	fprintf(stderr, "%s", ": plain while loop deactivated\n");
45240	45577	{
45241		- label = 3710LLU; // throw: begin to unroll stack
	45578	+ label = 3749LLU; // throw: begin to unroll stack
45242	45579	break;
45243	45580	}
45244	45581
45245		- label = 3771LLU; // alternative complete
	45582	+ label = 3810LLU; // alternative complete
45246	45583	break;
45247	45584	}
45248		- case 3771LLU: // completed if-then-else
	45585	+ case 3810LLU: // completed if-then-else
45249	45586	{
45250		- label = 3725LLU; // alternative complete
	45587	+ label = 3764LLU; // alternative complete
45251	45588	break;
45252	45589	}
45253		- case 3725LLU: // completed if-then-else
	45590	+ case 3764LLU: // completed if-then-else
45254	45591	{
45255	45592	// call matchsym from procblock
45256		- stack[base + 27LLU] = 3788LLU/throw to this address/;
	45593	+ stack[base + 27LLU] = 3827LLU/throw to this address/;
45257	45594	stack[base + 28LLU] = base;
45258		- stack[base + 29LLU] = 3789LLU;
	45595	+ stack[base + 29LLU] = 3828LLU;
45259	45596	// arguments for call to matchsym
45260	45597	stack[base + 30LLU] = stack[base + 8]/fnid/;
45261	45598	stack[base + 31LLU] = 123LLU;

		@@ -45265,14 +45602,14 @@
45265	45602	label = 222LLU; // matchsym
45266	45603	break;
45267	45604	}
45268		- case 3788LLU: // copy-back deleter (matchsym to procblock)
	45605	+ case 3827LLU: // copy-back deleter (matchsym to procblock)
45269	45606	{
45270	45607	// copy mutable arguments back from call to matchsym
45271	45608	stack[base + 19]/lookahead/ = stack[base + 32LLU];
45272		- label = 3710LLU; // continue to roll stack
	45609	+ label = 3749LLU; // continue to roll stack
45273	45610	break;
45274	45611	}
45275		- case 3789LLU: // return from matchsym to procblock
	45612	+ case 3828LLU: // return from matchsym to procblock
45276	45613	{
45277	45614	// copy mutable arguments back from call to matchsym
45278	45615	stack[base + 19]/lookahead/ = stack[base + 32LLU];

		@@ -45279,9 +45616,9 @@
45279	45616	printf("%s", "\n {");
45280	45617	printf("%s", "\n label = ");
45281	45618	// call printnr from procblock
45282		- stack[base + 27LLU] = 3790LLU/throw to this address/;
	45619	+ stack[base + 27LLU] = 3829LLU/throw to this address/;
45283	45620	stack[base + 28LLU] = base;
45284		- stack[base + 29LLU] = 3791LLU;
	45621	+ stack[base + 29LLU] = 3830LLU;
45285	45622	// arguments for call to printnr
45286	45623	stack[base + 30LLU] = stack[base + 23]/labelskip/;
45287	45624	// set stack-base & callee-address

		@@ -45289,13 +45626,13 @@
45289	45626	label = 18446744073709551590LLU; // printnr
45290	45627	break;
45291	45628	}
45292		- case 3790LLU: // copy-back deleter (printnr to procblock)
	45629	+ case 3829LLU: // copy-back deleter (printnr to procblock)
45293	45630	{
45294	45631	// copy mutable arguments back from call to printnr
45295		- label = 3710LLU; // continue to roll stack
	45632	+ label = 3749LLU; // continue to roll stack
45296	45633	break;
45297	45634	}
45298		- case 3791LLU: // return from printnr to procblock
	45635	+ case 3830LLU: // return from printnr to procblock
45299	45636	{
45300	45637	// copy mutable arguments back from call to printnr
45301	45638	printf("%s", "LLU; // break loop");

		@@ -45303,26 +45640,26 @@
45303	45640	printf("%s", "\n }");
45304	45641	printf("%s", "\n");
45305	45642	printf("%s", "\n // loop body");
45306		- label = 3793LLU; // skip deleter
	45643	+ label = 3832LLU; // skip deleter
45307	45644	break;
45308	45645	}
45309		- case 3792LLU: // deleter
	45646	+ case 3831LLU: // deleter
45310	45647	{
45311	45648	// throw from procblock
45312	45649	if(!stack[base + 27])
45313	45650	{
45314		- label = 3710LLU; // skip, variable already deleted/unscoped
	45651	+ label = 3749LLU; // skip, variable already deleted/unscoped
45315	45652	break;
45316	45653	}
45317	45654	// delete list
45318		- label = 3794LLU; // start to repeat
	45655	+ label = 3833LLU; // start to repeat
45319	45656	break;
45320	45657	}
45321		- case 3794LLU: // repeat from here
	45658	+ case 3833LLU: // repeat from here
45322	45659	{
45323	45660	if(!stack[base + 27])
45324	45661	{
45325		- label = 3795LLU; // break loop
	45662	+ label = 3834LLU; // break loop
45326	45663	break;
45327	45664	}
45328	45665

		@@ -45333,7 +45670,7 @@
45333	45670	newstack[0] = (uint64_t)stack; // backup stack location
45334	45671	newstack[1] = 1234567890;
45335	45672	newstack[2] = base;
45336		- newstack[3] = 3796LLU;
	45673	+ newstack[3] = 3835LLU;
45337	45674	stack = newstack;
45338	45675	// set stack-base & callee-address
45339	45676	base = 4/deloffset/;

		@@ -45340,7 +45677,7 @@
45340	45677	label = 395LLU; // ~typeidx
45341	45678	break;
45342	45679	}
45343		- case 3796LLU: // return from ~typeidx to procblock
	45680	+ case 3835LLU: // return from ~typeidx to procblock
45344	45681	{
45345	45682	stack = (uint64_t *)stack[0];
45346	45683	// releasing toplevel container

		@@ -45351,21 +45688,21 @@
45351	45688	stack[base + 27] = (uint64_t)list->next;
45352	45689	Free(1, sizeof(struct listnode), list);
45353	45690	}
45354		- label = 3794LLU; // repeat
	45691	+ label = 3833LLU; // repeat
45355	45692	break;
45356	45693	}
45357		- case 3795LLU: // loop finished
	45694	+ case 3834LLU: // loop finished
45358	45695	{
45359		- label = 3710LLU; // continue unrolling stack, delete next variable
	45696	+ label = 3749LLU; // continue unrolling stack, delete next variable
45360	45697	break;
45361	45698	}
45362		- case 3793LLU: // skipped deleter
	45699	+ case 3832LLU: // skipped deleter
45363	45700	{
45364	45701	stack[base + 27] = 0;
45365	45702	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
45366	45703	if(!newstack)
45367	45704	{
45368		- label = 3792LLU; // throw: begin to unroll stack
	45705	+ label = 3831LLU; // throw: begin to unroll stack
45369	45706	break;
45370	45707	}
45371	45708

		@@ -45372,9 +45709,9 @@
45372	45709	newstack[160LLU] = 9876543210LLU; // overflow-marker
45373	45710	// call procblock from procblock
45374	45711	newstack[0] = (uint64_t)stack; // backup stack location
45375		- newstack[1] = 3797LLU;
	45712	+ newstack[1] = 3836LLU;
45376	45713	newstack[2] = base;
45377		- newstack[3] = 3798LLU;
	45714	+ newstack[3] = 3837LLU;
45378	45715	// arguments for call to procblock
45379	45716	newstack[4LLU] = stack[base + 0]/fndefs/;
45380	45717	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -45400,7 +45737,7 @@
45400	45737	label = 3319LLU; // procblock
45401	45738	break;
45402	45739	}
45403		- case 3797LLU: // copy-back deleter (procblock to procblock)
	45740	+ case 3836LLU: // copy-back deleter (procblock to procblock)
45404	45741	{
45405	45742	uint64_t oldstack = (uint64_t )stack[0];
45406	45743	// copy mutable arguments back from call to procblock

		@@ -45417,10 +45754,10 @@
45417	45754	}
45418	45755	Free(160LLU + 1, sizeof(uint64_t), stack);
45419	45756	stack = oldstack;
45420		- label = 3792LLU; // continue to unroll stack
	45757	+ label = 3831LLU; // continue to unroll stack
45421	45758	break;
45422	45759	}
45423		- case 3798LLU: // return from procblock to procblock
	45760	+ case 3837LLU: // return from procblock to procblock
45424	45761	{
45425	45762	uint64_t oldstack = (uint64_t )stack[0];
45426	45763	// copy mutable arguments back from call to procblock

		@@ -45438,14 +45775,14 @@
45438	45775	Free(160LLU + 1, sizeof(uint64_t), stack);
45439	45776	stack = oldstack;
45440	45777	// delete list
45441		- label = 3799LLU; // start to repeat
	45778	+ label = 3838LLU; // start to repeat
45442	45779	break;
45443	45780	}
45444		- case 3799LLU: // repeat from here
	45781	+ case 3838LLU: // repeat from here
45445	45782	{
45446	45783	if(!stack[base + 27])
45447	45784	{
45448		- label = 3800LLU; // break loop
	45785	+ label = 3839LLU; // break loop
45449	45786	break;
45450	45787	}
45451	45788

		@@ -45456,7 +45793,7 @@
45456	45793	newstack[0] = (uint64_t)stack; // backup stack location
45457	45794	newstack[1] = 1234567890;
45458	45795	newstack[2] = base;
45459		- newstack[3] = 3801LLU;
	45796	+ newstack[3] = 3840LLU;
45460	45797	stack = newstack;
45461	45798	// set stack-base & callee-address
45462	45799	base = 4/deloffset/;

		@@ -45463,7 +45800,7 @@
45463	45800	label = 395LLU; // ~typeidx
45464	45801	break;
45465	45802	}
45466		- case 3801LLU: // return from ~typeidx to procblock
	45803	+ case 3840LLU: // return from ~typeidx to procblock
45467	45804	{
45468	45805	stack = (uint64_t *)stack[0];
45469	45806	// releasing toplevel container

		@@ -45474,14 +45811,14 @@
45474	45811	stack[base + 27] = (uint64_t)list->next;
45475	45812	Free(1, sizeof(struct listnode), list);
45476	45813	}
45477		- label = 3799LLU; // repeat
	45814	+ label = 3838LLU; // repeat
45478	45815	break;
45479	45816	}
45480		- case 3800LLU: // loop finished
	45817	+ case 3839LLU: // loop finished
45481	45818	{
45482	45819	if(!stack[base + 25]/inputflag/)
45483	45820	{
45484		- label = 3802LLU; // jump to alternative
	45821	+ label = 3841LLU; // jump to alternative
45485	45822	break;
45486	45823	}
45487	45824

		@@ -45488,9 +45825,9 @@
45488	45825	// consequent
45489	45826	printf("%s", "\n if(");
45490	45827	// call emitvar from procblock
45491		- stack[base + 27LLU] = 3804LLU/throw to this address/;
	45828	+ stack[base + 27LLU] = 3843LLU/throw to this address/;
45492	45829	stack[base + 28LLU] = base;
45493		- stack[base + 29LLU] = 3805LLU;
	45830	+ stack[base + 29LLU] = 3844LLU;
45494	45831	// arguments for call to emitvar
45495	45832	stack[base + 30LLU] = stack[base + 8]/fnid/;
45496	45833	stack[base + 31LLU] = stack[base + 26]/loopid/;

		@@ -45501,20 +45838,20 @@
45501	45838	label = 745LLU; // emitvar
45502	45839	break;
45503	45840	}
45504		- case 3804LLU: // copy-back deleter (emitvar to procblock)
	45841	+ case 3843LLU: // copy-back deleter (emitvar to procblock)
45505	45842	{
45506	45843	// copy mutable arguments back from call to emitvar
45507		- label = 3710LLU; // continue to roll stack
	45844	+ label = 3749LLU; // continue to roll stack
45508	45845	break;
45509	45846	}
45510		- case 3805LLU: // return from emitvar to procblock
	45847	+ case 3844LLU: // return from emitvar to procblock
45511	45848	{
45512	45849	// copy mutable arguments back from call to emitvar
45513	45850	printf("%s", " <= 0xFF) ");
45514	45851	// call emitvar from procblock
45515		- stack[base + 27LLU] = 3806LLU/throw to this address/;
	45852	+ stack[base + 27LLU] = 3845LLU/throw to this address/;
45516	45853	stack[base + 28LLU] = base;
45517		- stack[base + 29LLU] = 3807LLU;
	45854	+ stack[base + 29LLU] = 3846LLU;
45518	45855	// arguments for call to emitvar
45519	45856	stack[base + 30LLU] = stack[base + 8]/fnid/;
45520	45857	stack[base + 31LLU] = stack[base + 26]/loopid/;

		@@ -45525,31 +45862,31 @@
45525	45862	label = 745LLU; // emitvar
45526	45863	break;
45527	45864	}
45528		- case 3806LLU: // copy-back deleter (emitvar to procblock)
	45865	+ case 3845LLU: // copy-back deleter (emitvar to procblock)
45529	45866	{
45530	45867	// copy mutable arguments back from call to emitvar
45531		- label = 3710LLU; // continue to roll stack
	45868	+ label = 3749LLU; // continue to roll stack
45532	45869	break;
45533	45870	}
45534		- case 3807LLU: // return from emitvar to procblock
	45871	+ case 3846LLU: // return from emitvar to procblock
45535	45872	{
45536	45873	// copy mutable arguments back from call to emitvar
45537	45874	printf("%s", " = getchar();");
45538		- label = 3803LLU; // consequent complete
	45875	+ label = 3842LLU; // consequent complete
45539	45876	break;
45540	45877	}
45541		- case 3802LLU: // alternative
	45878	+ case 3841LLU: // alternative
45542	45879	{
45543		- label = 3803LLU; // alternative complete
	45880	+ label = 3842LLU; // alternative complete
45544	45881	break;
45545	45882	}
45546		- case 3803LLU: // completed if-then-else
	45883	+ case 3842LLU: // completed if-then-else
45547	45884	{
45548	45885	printf("%s", "\n label = ");
45549	45886	// call printnr from procblock
45550		- stack[base + 27LLU] = 3808LLU/throw to this address/;
	45887	+ stack[base + 27LLU] = 3847LLU/throw to this address/;
45551	45888	stack[base + 28LLU] = base;
45552		- stack[base + 29LLU] = 3809LLU;
	45889	+ stack[base + 29LLU] = 3848LLU;
45553	45890	// arguments for call to printnr
45554	45891	stack[base + 30LLU] = stack[base + 22]/labelloop/;
45555	45892	// set stack-base & callee-address

		@@ -45557,13 +45894,13 @@
45557	45894	label = 18446744073709551590LLU; // printnr
45558	45895	break;
45559	45896	}
45560		- case 3808LLU: // copy-back deleter (printnr to procblock)
	45897	+ case 3847LLU: // copy-back deleter (printnr to procblock)
45561	45898	{
45562	45899	// copy mutable arguments back from call to printnr
45563		- label = 3710LLU; // continue to roll stack
	45900	+ label = 3749LLU; // continue to roll stack
45564	45901	break;
45565	45902	}
45566		- case 3809LLU: // return from printnr to procblock
	45903	+ case 3848LLU: // return from printnr to procblock
45567	45904	{
45568	45905	// copy mutable arguments back from call to printnr
45569	45906	printf("%s", "LLU; // repeat");

		@@ -45571,9 +45908,9 @@
45571	45908	printf("%s", "\n }");
45572	45909	printf("%s", "\n case ");
45573	45910	// call printnr from procblock
45574		- stack[base + 27LLU] = 3810LLU/throw to this address/;
	45911	+ stack[base + 27LLU] = 3849LLU/throw to this address/;
45575	45912	stack[base + 28LLU] = base;
45576		- stack[base + 29LLU] = 3811LLU;
	45913	+ stack[base + 29LLU] = 3850LLU;
45577	45914	// arguments for call to printnr
45578	45915	stack[base + 30LLU] = stack[base + 23]/labelskip/;
45579	45916	// set stack-base & callee-address

		@@ -45581,25 +45918,25 @@
45581	45918	label = 18446744073709551590LLU; // printnr
45582	45919	break;
45583	45920	}
45584		- case 3810LLU: // copy-back deleter (printnr to procblock)
	45921	+ case 3849LLU: // copy-back deleter (printnr to procblock)
45585	45922	{
45586	45923	// copy mutable arguments back from call to printnr
45587		- label = 3710LLU; // continue to roll stack
	45924	+ label = 3749LLU; // continue to roll stack
45588	45925	break;
45589	45926	}
45590		- case 3811LLU: // return from printnr to procblock
	45927	+ case 3850LLU: // return from printnr to procblock
45591	45928	{
45592	45929	// copy mutable arguments back from call to printnr
45593	45930	printf("%s", "LLU: // loop finished");
45594	45931	printf("%s", "\n {");
45595		- label = 3703LLU; // consequent complete
	45932	+ label = 3742LLU; // consequent complete
45596	45933	break;
45597	45934	}
45598		- case 3702LLU: // alternative
	45935	+ case 3741LLU: // alternative
45599	45936	{
45600	45937	if(!stack[base + 24]/decflag/)
45601	45938	{
45602		- label = 3812LLU; // jump to alternative
	45939	+ label = 3851LLU; // jump to alternative
45603	45940	break;
45604	45941	}
45605	45942

		@@ -45606,9 +45943,9 @@
45606	45943	// consequent
45607	45944	fprintf(stderr, "%s", "in function ");
45608	45945	// call reportid from procblock
45609		- stack[base + 26LLU] = 3814LLU/throw to this address/;
	45946	+ stack[base + 26LLU] = 3853LLU/throw to this address/;
45610	45947	stack[base + 27LLU] = base;
45611		- stack[base + 28LLU] = 3815LLU;
	45948	+ stack[base + 28LLU] = 3854LLU;
45612	45949	// arguments for call to reportid
45613	45950	stack[base + 29LLU] = stack[base + 8]/fnid/;
45614	45951	// set stack-base & callee-address

		@@ -45616,20 +45953,20 @@
45616	45953	label = 18446744073709551586LLU; // reportid
45617	45954	break;
45618	45955	}
45619		- case 3814LLU: // copy-back deleter (reportid to procblock)
	45956	+ case 3853LLU: // copy-back deleter (reportid to procblock)
45620	45957	{
45621	45958	// copy mutable arguments back from call to reportid
45622		- label = 3670LLU; // continue to roll stack
	45959	+ label = 3709LLU; // continue to roll stack
45623	45960	break;
45624	45961	}
45625		- case 3815LLU: // return from reportid to procblock
	45962	+ case 3854LLU: // return from reportid to procblock
45626	45963	{
45627	45964	// copy mutable arguments back from call to reportid
45628	45965	fprintf(stderr, "%s", ": while dec expected '(' but found ");
45629	45966	// call reporttok from procblock
45630		- stack[base + 26LLU] = 3816LLU/throw to this address/;
	45967	+ stack[base + 26LLU] = 3855LLU/throw to this address/;
45631	45968	stack[base + 27LLU] = base;
45632		- stack[base + 28LLU] = 3817LLU;
	45969	+ stack[base + 28LLU] = 3856LLU;
45633	45970	// arguments for call to reporttok
45634	45971	stack[base + 29LLU] = stack[base + 15]/variant/;
45635	45972	stack[base + 30LLU] = stack[base + 16]/content/;

		@@ -45638,34 +45975,34 @@
45638	45975	label = 18446744073709551582LLU; // reporttok
45639	45976	break;
45640	45977	}
45641		- case 3816LLU: // copy-back deleter (reporttok to procblock)
	45978	+ case 3855LLU: // copy-back deleter (reporttok to procblock)
45642	45979	{
45643	45980	// copy mutable arguments back from call to reporttok
45644		- label = 3670LLU; // continue to roll stack
	45981	+ label = 3709LLU; // continue to roll stack
45645	45982	break;
45646	45983	}
45647		- case 3817LLU: // return from reporttok to procblock
	45984	+ case 3856LLU: // return from reporttok to procblock
45648	45985	{
45649	45986	// copy mutable arguments back from call to reporttok
45650	45987	fprintf(stderr, "%s", "\n");
45651	45988	{
45652		- label = 3670LLU; // throw: begin to unroll stack
	45989	+ label = 3709LLU; // throw: begin to unroll stack
45653	45990	break;
45654	45991	}
45655	45992
45656		- label = 3813LLU; // consequent complete
	45993	+ label = 3852LLU; // consequent complete
45657	45994	break;
45658	45995	}
45659		- case 3812LLU: // alternative
	45996	+ case 3851LLU: // alternative
45660	45997	{
45661		- label = 3813LLU; // alternative complete
	45998	+ label = 3852LLU; // alternative complete
45662	45999	break;
45663	46000	}
45664		- case 3813LLU: // completed if-then-else
	46001	+ case 3852LLU: // completed if-then-else
45665	46002	{
45666	46003	if(!stack[base + 25]/inputflag/)
45667	46004	{
45668		- label = 3818LLU; // jump to alternative
	46005	+ label = 3857LLU; // jump to alternative
45669	46006	break;
45670	46007	}
45671	46008

		@@ -45672,9 +46009,9 @@
45672	46009	// consequent
45673	46010	fprintf(stderr, "%s", "in function ");
45674	46011	// call reportid from procblock
45675		- stack[base + 26LLU] = 3820LLU/throw to this address/;
	46012	+ stack[base + 26LLU] = 3859LLU/throw to this address/;
45676	46013	stack[base + 27LLU] = base;
45677		- stack[base + 28LLU] = 3821LLU;
	46014	+ stack[base + 28LLU] = 3860LLU;
45678	46015	// arguments for call to reportid
45679	46016	stack[base + 29LLU] = stack[base + 8]/fnid/;
45680	46017	// set stack-base & callee-address

		@@ -45682,20 +46019,20 @@
45682	46019	label = 18446744073709551586LLU; // reportid
45683	46020	break;
45684	46021	}
45685		- case 3820LLU: // copy-back deleter (reportid to procblock)
	46022	+ case 3859LLU: // copy-back deleter (reportid to procblock)
45686	46023	{
45687	46024	// copy mutable arguments back from call to reportid
45688		- label = 3670LLU; // continue to roll stack
	46025	+ label = 3709LLU; // continue to roll stack
45689	46026	break;
45690	46027	}
45691		- case 3821LLU: // return from reportid to procblock
	46028	+ case 3860LLU: // return from reportid to procblock
45692	46029	{
45693	46030	// copy mutable arguments back from call to reportid
45694	46031	fprintf(stderr, "%s", ": while input expected '(' but found ");
45695	46032	// call reporttok from procblock
45696		- stack[base + 26LLU] = 3822LLU/throw to this address/;
	46033	+ stack[base + 26LLU] = 3861LLU/throw to this address/;
45697	46034	stack[base + 27LLU] = base;
45698		- stack[base + 28LLU] = 3823LLU;
	46035	+ stack[base + 28LLU] = 3862LLU;
45699	46036	// arguments for call to reporttok
45700	46037	stack[base + 29LLU] = stack[base + 15]/variant/;
45701	46038	stack[base + 30LLU] = stack[base + 16]/content/;

		@@ -45704,35 +46041,35 @@
45704	46041	label = 18446744073709551582LLU; // reporttok
45705	46042	break;
45706	46043	}
45707		- case 3822LLU: // copy-back deleter (reporttok to procblock)
	46044	+ case 3861LLU: // copy-back deleter (reporttok to procblock)
45708	46045	{
45709	46046	// copy mutable arguments back from call to reporttok
45710		- label = 3670LLU; // continue to roll stack
	46047	+ label = 3709LLU; // continue to roll stack
45711	46048	break;
45712	46049	}
45713		- case 3823LLU: // return from reporttok to procblock
	46050	+ case 3862LLU: // return from reporttok to procblock
45714	46051	{
45715	46052	// copy mutable arguments back from call to reporttok
45716	46053	fprintf(stderr, "%s", "\n");
45717	46054	{
45718		- label = 3670LLU; // throw: begin to unroll stack
	46055	+ label = 3709LLU; // throw: begin to unroll stack
45719	46056	break;
45720	46057	}
45721	46058
45722		- label = 3819LLU; // consequent complete
	46059	+ label = 3858LLU; // consequent complete
45723	46060	break;
45724	46061	}
45725		- case 3818LLU: // alternative
	46062	+ case 3857LLU: // alternative
45726	46063	{
45727		- label = 3819LLU; // alternative complete
	46064	+ label = 3858LLU; // alternative complete
45728	46065	break;
45729	46066	}
45730		- case 3819LLU: // completed if-then-else
	46067	+ case 3858LLU: // completed if-then-else
45731	46068	{
45732	46069	// call equ from procblock
45733		- stack[base + 26LLU] = 3824LLU/throw to this address/;
	46070	+ stack[base + 26LLU] = 3863LLU/throw to this address/;
45734	46071	stack[base + 27LLU] = base;
45735		- stack[base + 28LLU] = 3825LLU;
	46072	+ stack[base + 28LLU] = 3864LLU;
45736	46073	// arguments for call to equ
45737	46074	stack[base + 30LLU] = stack[base + 16]/content/;
45738	46075	stack[base + 31LLU] = 747825068330975232LLU;

		@@ -45741,66 +46078,66 @@
45741	46078	label = 18446744073709551600LLU; // equ
45742	46079	break;
45743	46080	}
45744		- case 3824LLU: // copy-back deleter (equ to procblock)
	46081	+ case 3863LLU: // copy-back deleter (equ to procblock)
45745	46082	{
45746	46083	// copy mutable arguments back from call to equ
45747		- label = 3670LLU; // continue to roll stack
	46084	+ label = 3709LLU; // continue to roll stack
45748	46085	break;
45749	46086	}
45750		- case 3825LLU: // return from equ to procblock
	46087	+ case 3864LLU: // return from equ to procblock
45751	46088	{
45752	46089	// copy mutable arguments back from call to equ
45753	46090	// copy back results provided by call to equ
45754	46091	stack[base + 20] = stack[base + 29LLU];
45755		- label = 3827LLU; // skip deleter
	46092	+ label = 3866LLU; // skip deleter
45756	46093	break;
45757	46094	}
45758		- case 3826LLU: // deleter
	46095	+ case 3865LLU: // deleter
45759	46096	{
45760	46097	// throw from procblock
45761	46098	if(!stack[base + 26])
45762	46099	{
45763		- label = 3670LLU; // skip, variable already deleted/unscoped
	46100	+ label = 3709LLU; // skip, variable already deleted/unscoped
45764	46101	break;
45765	46102	}
45766		- label = 3670LLU; // continue unrolling stack, delete next variable
	46103	+ label = 3709LLU; // continue unrolling stack, delete next variable
45767	46104	break;
45768	46105	}
45769		- case 3827LLU: // skipped deleter
	46106	+ case 3866LLU: // skipped deleter
45770	46107	{
45771	46108	if(!stack[base + 20]/isequal/)
45772	46109	{
45773		- label = 3828LLU; // jump to alternative
	46110	+ label = 3867LLU; // jump to alternative
45774	46111	break;
45775	46112	}
45776	46113
45777	46114	// consequent
45778		- label = 3831LLU; // skip deleter
	46115	+ label = 3870LLU; // skip deleter
45779	46116	break;
45780	46117	}
45781		- case 3830LLU: // deleter
	46118	+ case 3869LLU: // deleter
45782	46119	{
45783	46120	// throw from procblock
45784	46121	if(!stack[base + 26])
45785	46122	{
45786		- label = 3670LLU; // skip, variable already deleted/unscoped
	46123	+ label = 3709LLU; // skip, variable already deleted/unscoped
45787	46124	break;
45788	46125	}
45789		- label = 3670LLU; // continue unrolling stack, delete next variable
	46126	+ label = 3709LLU; // continue unrolling stack, delete next variable
45790	46127	break;
45791	46128	}
45792		- case 3831LLU: // skipped deleter
	46129	+ case 3870LLU: // skipped deleter
45793	46130	{
45794	46131	stack[base + 26] = 0;
45795		- label = 3829LLU; // consequent complete
	46132	+ label = 3868LLU; // consequent complete
45796	46133	break;
45797	46134	}
45798		- case 3828LLU: // alternative
	46135	+ case 3867LLU: // alternative
45799	46136	{
45800	46137	// call equ from procblock
45801		- stack[base + 27LLU] = 3832LLU/throw to this address/;
	46138	+ stack[base + 27LLU] = 3871LLU/throw to this address/;
45802	46139	stack[base + 28LLU] = base;
45803		- stack[base + 29LLU] = 3833LLU;
	46140	+ stack[base + 29LLU] = 3872LLU;
45804	46141	// arguments for call to equ
45805	46142	stack[base + 31LLU] = stack[base + 16]/content/;
45806	46143	stack[base + 32LLU] = 786630200929550336LLU;

		@@ -45809,13 +46146,13 @@
45809	46146	label = 18446744073709551600LLU; // equ
45810	46147	break;
45811	46148	}
45812		- case 3832LLU: // copy-back deleter (equ to procblock)
	46149	+ case 3871LLU: // copy-back deleter (equ to procblock)
45813	46150	{
45814	46151	// copy mutable arguments back from call to equ
45815		- label = 3670LLU; // continue to roll stack
	46152	+ label = 3709LLU; // continue to roll stack
45816	46153	break;
45817	46154	}
45818		- case 3833LLU: // return from equ to procblock
	46155	+ case 3872LLU: // return from equ to procblock
45819	46156	{
45820	46157	// copy mutable arguments back from call to equ
45821	46158	// copy back results provided by call to equ

		@@ -45822,38 +46159,38 @@
45822	46159	stack[base + 20] = stack[base + 30LLU];
45823	46160	if(!stack[base + 20]/isequal/)
45824	46161	{
45825		- label = 3834LLU; // jump to alternative
	46162	+ label = 3873LLU; // jump to alternative
45826	46163	break;
45827	46164	}
45828	46165
45829	46166	// consequent
45830		- label = 3837LLU; // skip deleter
	46167	+ label = 3876LLU; // skip deleter
45831	46168	break;
45832	46169	}
45833		- case 3836LLU: // deleter
	46170	+ case 3875LLU: // deleter
45834	46171	{
45835	46172	// throw from procblock
45836	46173	if(!stack[base + 26])
45837	46174	{
45838		- label = 3670LLU; // skip, variable already deleted/unscoped
	46175	+ label = 3709LLU; // skip, variable already deleted/unscoped
45839	46176	break;
45840	46177	}
45841		- label = 3670LLU; // continue unrolling stack, delete next variable
	46178	+ label = 3709LLU; // continue unrolling stack, delete next variable
45842	46179	break;
45843	46180	}
45844		- case 3837LLU: // skipped deleter
	46181	+ case 3876LLU: // skipped deleter
45845	46182	{
45846	46183	stack[base + 26] = 1;
45847		- label = 3835LLU; // consequent complete
	46184	+ label = 3874LLU; // consequent complete
45848	46185	break;
45849	46186	}
45850		- case 3834LLU: // alternative
	46187	+ case 3873LLU: // alternative
45851	46188	{
45852	46189	fprintf(stderr, "%s", "expected next but found token ");
45853	46190	// call reporttok from procblock
45854		- stack[base + 27LLU] = 3838LLU/throw to this address/;
	46191	+ stack[base + 27LLU] = 3877LLU/throw to this address/;
45855	46192	stack[base + 28LLU] = base;
45856		- stack[base + 29LLU] = 3839LLU;
	46193	+ stack[base + 29LLU] = 3878LLU;
45857	46194	// arguments for call to reporttok
45858	46195	stack[base + 30LLU] = stack[base + 15]/variant/;
45859	46196	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -45862,35 +46199,35 @@
45862	46199	label = 18446744073709551582LLU; // reporttok
45863	46200	break;
45864	46201	}
45865		- case 3838LLU: // copy-back deleter (reporttok to procblock)
	46202	+ case 3877LLU: // copy-back deleter (reporttok to procblock)
45866	46203	{
45867	46204	// copy mutable arguments back from call to reporttok
45868		- label = 3670LLU; // continue to roll stack
	46205	+ label = 3709LLU; // continue to roll stack
45869	46206	break;
45870	46207	}
45871		- case 3839LLU: // return from reporttok to procblock
	46208	+ case 3878LLU: // return from reporttok to procblock
45872	46209	{
45873	46210	// copy mutable arguments back from call to reporttok
45874	46211	fprintf(stderr, "%s", "\n");
45875	46212	{
45876		- label = 3670LLU; // throw: begin to unroll stack
	46213	+ label = 3709LLU; // throw: begin to unroll stack
45877	46214	break;
45878	46215	}
45879	46216
45880		- label = 3835LLU; // alternative complete
	46217	+ label = 3874LLU; // alternative complete
45881	46218	break;
45882	46219	}
45883		- case 3835LLU: // completed if-then-else
	46220	+ case 3874LLU: // completed if-then-else
45884	46221	{
45885		- label = 3829LLU; // alternative complete
	46222	+ label = 3868LLU; // alternative complete
45886	46223	break;
45887	46224	}
45888		- case 3829LLU: // completed if-then-else
	46225	+ case 3868LLU: // completed if-then-else
45889	46226	{
45890	46227	// call matchsym from procblock
45891		- stack[base + 27LLU] = 3840LLU/throw to this address/;
	46228	+ stack[base + 27LLU] = 3879LLU/throw to this address/;
45892	46229	stack[base + 28LLU] = base;
45893		- stack[base + 29LLU] = 3841LLU;
	46230	+ stack[base + 29LLU] = 3880LLU;
45894	46231	// arguments for call to matchsym
45895	46232	stack[base + 30LLU] = stack[base + 8]/fnid/;
45896	46233	stack[base + 31LLU] = 40LLU;

		@@ -45900,38 +46237,38 @@
45900	46237	label = 222LLU; // matchsym
45901	46238	break;
45902	46239	}
45903		- case 3840LLU: // copy-back deleter (matchsym to procblock)
	46240	+ case 3879LLU: // copy-back deleter (matchsym to procblock)
45904	46241	{
45905	46242	// copy mutable arguments back from call to matchsym
45906	46243	stack[base + 19]/lookahead/ = stack[base + 32LLU];
45907		- label = 3826LLU; // continue to roll stack
	46244	+ label = 3865LLU; // continue to roll stack
45908	46245	break;
45909	46246	}
45910		- case 3841LLU: // return from matchsym to procblock
	46247	+ case 3880LLU: // return from matchsym to procblock
45911	46248	{
45912	46249	// copy mutable arguments back from call to matchsym
45913	46250	stack[base + 19]/lookahead/ = stack[base + 32LLU];
45914		- label = 3843LLU; // skip deleter
	46251	+ label = 3882LLU; // skip deleter
45915	46252	break;
45916	46253	}
45917		- case 3842LLU: // deleter
	46254	+ case 3881LLU: // deleter
45918	46255	{
45919	46256	// throw from procblock
45920	46257	if(!stack[base + 27])
45921	46258	{
45922		- label = 3826LLU; // skip, variable already deleted/unscoped
	46259	+ label = 3865LLU; // skip, variable already deleted/unscoped
45923	46260	break;
45924	46261	}
45925		- label = 3826LLU; // continue unrolling stack, delete next variable
	46262	+ label = 3865LLU; // continue unrolling stack, delete next variable
45926	46263	break;
45927	46264	}
45928		- case 3843LLU: // skipped deleter
	46265	+ case 3882LLU: // skipped deleter
45929	46266	{
45930	46267	stack[base + 27] = 0;
45931	46268	// call ParseToken from procblock
45932		- stack[base + 28LLU] = 3844LLU/throw to this address/;
	46269	+ stack[base + 28LLU] = 3883LLU/throw to this address/;
45933	46270	stack[base + 29LLU] = base;
45934		- stack[base + 30LLU] = 3845LLU;
	46271	+ stack[base + 30LLU] = 3884LLU;
45935	46272	// arguments for call to ParseToken
45936	46273	stack[base + 33LLU] = stack[base + 19]/lookahead/;
45937	46274	// set stack-base & callee-address

		@@ -45939,14 +46276,14 @@
45939	46276	label = 3LLU; // ParseToken
45940	46277	break;
45941	46278	}
45942		- case 3844LLU: // copy-back deleter (ParseToken to procblock)
	46279	+ case 3883LLU: // copy-back deleter (ParseToken to procblock)
45943	46280	{
45944	46281	// copy mutable arguments back from call to ParseToken
45945	46282	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45946		- label = 3842LLU; // continue to roll stack
	46283	+ label = 3881LLU; // continue to roll stack
45947	46284	break;
45948	46285	}
45949		- case 3845LLU: // return from ParseToken to procblock
	46286	+ case 3884LLU: // return from ParseToken to procblock
45950	46287	{
45951	46288	// copy mutable arguments back from call to ParseToken
45952	46289	stack[base + 19]/lookahead/ = stack[base + 33LLU];

		@@ -45954,9 +46291,9 @@
45954	46291	stack[base + 15] = stack[base + 31LLU];
45955	46292	stack[base + 27] = stack[base + 32LLU];
45956	46293	// call equ from procblock
45957		- stack[base + 28LLU] = 3846LLU/throw to this address/;
	46294	+ stack[base + 28LLU] = 3885LLU/throw to this address/;
45958	46295	stack[base + 29LLU] = base;
45959		- stack[base + 30LLU] = 3847LLU;
	46296	+ stack[base + 30LLU] = 3886LLU;
45960	46297	// arguments for call to equ
45961	46298	stack[base + 32LLU] = stack[base + 15]/variant/;
45962	46299	stack[base + 33LLU] = 4LLU;

		@@ -45965,13 +46302,13 @@
45965	46302	label = 18446744073709551600LLU; // equ
45966	46303	break;
45967	46304	}
45968		- case 3846LLU: // copy-back deleter (equ to procblock)
	46305	+ case 3885LLU: // copy-back deleter (equ to procblock)
45969	46306	{
45970	46307	// copy mutable arguments back from call to equ
45971		- label = 3842LLU; // continue to roll stack
	46308	+ label = 3881LLU; // continue to roll stack
45972	46309	break;
45973	46310	}
45974		- case 3847LLU: // return from equ to procblock
	46311	+ case 3886LLU: // return from equ to procblock
45975	46312	{
45976	46313	// copy mutable arguments back from call to equ
45977	46314	// copy back results provided by call to equ

		@@ -45978,21 +46315,21 @@
45978	46315	stack[base + 20] = stack[base + 31LLU];
45979	46316	if(!stack[base + 20]/isequal/)
45980	46317	{
45981		- label = 3848LLU; // jump to alternative
	46318	+ label = 3887LLU; // jump to alternative
45982	46319	break;
45983	46320	}
45984	46321
45985	46322	// consequent
45986		- label = 3849LLU; // consequent complete
	46323	+ label = 3888LLU; // consequent complete
45987	46324	break;
45988	46325	}
45989		- case 3848LLU: // alternative
	46326	+ case 3887LLU: // alternative
45990	46327	{
45991	46328	fprintf(stderr, "%s", "expected identifier in while next but found ");
45992	46329	// call reporttok from procblock
45993		- stack[base + 28LLU] = 3850LLU/throw to this address/;
	46330	+ stack[base + 28LLU] = 3889LLU/throw to this address/;
45994	46331	stack[base + 29LLU] = base;
45995		- stack[base + 30LLU] = 3851LLU;
	46332	+ stack[base + 30LLU] = 3890LLU;
45996	46333	// arguments for call to reporttok
45997	46334	stack[base + 31LLU] = stack[base + 15]/variant/;
45998	46335	stack[base + 32LLU] = stack[base + 27]/listid/;

		@@ -46001,35 +46338,35 @@
46001	46338	label = 18446744073709551582LLU; // reporttok
46002	46339	break;
46003	46340	}
46004		- case 3850LLU: // copy-back deleter (reporttok to procblock)
	46341	+ case 3889LLU: // copy-back deleter (reporttok to procblock)
46005	46342	{
46006	46343	// copy mutable arguments back from call to reporttok
46007		- label = 3842LLU; // continue to roll stack
	46344	+ label = 3881LLU; // continue to roll stack
46008	46345	break;
46009	46346	}
46010		- case 3851LLU: // return from reporttok to procblock
	46347	+ case 3890LLU: // return from reporttok to procblock
46011	46348	{
46012	46349	// copy mutable arguments back from call to reporttok
46013	46350	fprintf(stderr, "%s", "\n");
46014	46351	{
46015		- label = 3842LLU; // throw: begin to unroll stack
	46352	+ label = 3881LLU; // throw: begin to unroll stack
46016	46353	break;
46017	46354	}
46018	46355
46019		- label = 3849LLU; // alternative complete
	46356	+ label = 3888LLU; // alternative complete
46020	46357	break;
46021	46358	}
46022		- case 3849LLU: // completed if-then-else
	46359	+ case 3888LLU: // completed if-then-else
46023	46360	{
46024		- label = 3853LLU; // skip deleter
	46361	+ label = 3892LLU; // skip deleter
46025	46362	break;
46026	46363	}
46027		- case 3852LLU: // deleter
	46364	+ case 3891LLU: // deleter
46028	46365	{
46029	46366	// throw from procblock
46030	46367	if(!stack[base + 28])
46031	46368	{
46032		- label = 3842LLU; // skip, variable already deleted/unscoped
	46369	+ label = 3881LLU; // skip, variable already deleted/unscoped
46033	46370	break;
46034	46371	}
46035	46372

		@@ -46038,7 +46375,7 @@
46038	46375	newstack[0] = (uint64_t)stack; // backup stack location
46039	46376	newstack[1] = 1234567890;
46040	46377	newstack[2] = base;
46041		- newstack[3] = 3854LLU;
	46378	+ newstack[3] = 3893LLU;
46042	46379	stack = newstack;
46043	46380	// set stack-base & callee-address
46044	46381	base = 4/deloffset/;

		@@ -46045,21 +46382,21 @@
46045	46382	label = 482LLU; // ~letdef
46046	46383	break;
46047	46384	}
46048		- case 3854LLU: // return from ~letdef to procblock
	46385	+ case 3893LLU: // return from ~letdef to procblock
46049	46386	{
46050	46387	stack = (uint64_t *)stack[0];
46051	46388	// releasing toplevel container
46052	46389	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
46053	46390
46054		- label = 3842LLU; // continue unrolling stack, delete next variable
	46391	+ label = 3881LLU; // continue unrolling stack, delete next variable
46055	46392	break;
46056	46393	}
46057		- case 3853LLU: // skipped deleter
	46394	+ case 3892LLU: // skipped deleter
46058	46395	{
46059	46396	// call FindLetNew from procblock
46060		- stack[base + 29LLU] = 3855LLU/throw to this address/;
	46397	+ stack[base + 29LLU] = 3894LLU/throw to this address/;
46061	46398	stack[base + 30LLU] = base;
46062		- stack[base + 31LLU] = 3856LLU;
	46399	+ stack[base + 31LLU] = 3895LLU;
46063	46400	// arguments for call to FindLetNew
46064	46401	stack[base + 33LLU] = stack[base + 8]/fnid/;
46065	46402	stack[base + 34LLU] = stack[base + 27]/listid/;

		@@ -46070,13 +46407,13 @@
46070	46407	label = 615LLU; // FindLetNew
46071	46408	break;
46072	46409	}
46073		- case 3855LLU: // copy-back deleter (FindLetNew to procblock)
	46410	+ case 3894LLU: // copy-back deleter (FindLetNew to procblock)
46074	46411	{
46075	46412	// copy mutable arguments back from call to FindLetNew
46076		- label = 3842LLU; // continue to roll stack
	46413	+ label = 3881LLU; // continue to roll stack
46077	46414	break;
46078	46415	}
46079		- case 3856LLU: // return from FindLetNew to procblock
	46416	+ case 3895LLU: // return from FindLetNew to procblock
46080	46417	{
46081	46418	// copy mutable arguments back from call to FindLetNew
46082	46419	// copy back results provided by call to FindLetNew

		@@ -46083,7 +46420,7 @@
46083	46420	stack[base + 28] = stack[base + 32LLU];
46084	46421	if(/letdef/0 != ((uint64_t )(stack[base + 28]/letdef*/))[0])
46085	46422	{
46086		- label = 3858LLU; // jump to alternative
	46423	+ label = 3897LLU; // jump to alternative
46087	46424	break;
46088	46425	}
46089	46426

		@@ -46094,71 +46431,71 @@
46094	46431	/substruct/stack[base + 33] = ((uint64_t *)(stack[base + 28]/letdef/))[1][4]/substruct*/;
46095	46432
46096	46433	// case
46097		- label = 3861LLU; // skip deleter
	46434	+ label = 3900LLU; // skip deleter
46098	46435	break;
46099	46436	}
46100		- case 3860LLU: // deleter
	46437	+ case 3899LLU: // deleter
46101	46438	{
46102	46439	// throw from procblock
46103	46440	if(!stack[base + 34])
46104	46441	{
46105		- label = 3859LLU; // skip, variable already deleted/unscoped
	46442	+ label = 3898LLU; // skip, variable already deleted/unscoped
46106	46443	break;
46107	46444	}
46108		- label = 3859LLU; // continue unrolling stack, delete next variable
	46445	+ label = 3898LLU; // continue unrolling stack, delete next variable
46109	46446	break;
46110	46447	}
46111		- case 3861LLU: // skipped deleter
	46448	+ case 3900LLU: // skipped deleter
46112	46449	{
46113	46450	if(!stack[base + 32]/mutable/)
46114	46451	{
46115		- label = 3862LLU; // jump to alternative
	46452	+ label = 3901LLU; // jump to alternative
46116	46453	break;
46117	46454	}
46118	46455
46119	46456	// consequent
46120		- label = 3865LLU; // skip deleter
	46457	+ label = 3904LLU; // skip deleter
46121	46458	break;
46122	46459	}
46123		- case 3864LLU: // deleter
	46460	+ case 3903LLU: // deleter
46124	46461	{
46125	46462	// throw from procblock
46126	46463	if(!stack[base + 34])
46127	46464	{
46128		- label = 3859LLU; // skip, variable already deleted/unscoped
	46465	+ label = 3898LLU; // skip, variable already deleted/unscoped
46129	46466	break;
46130	46467	}
46131		- label = 3859LLU; // continue unrolling stack, delete next variable
	46468	+ label = 3898LLU; // continue unrolling stack, delete next variable
46132	46469	break;
46133	46470	}
46134		- case 3865LLU: // skipped deleter
	46471	+ case 3904LLU: // skipped deleter
46135	46472	{
46136	46473	stack[base + 34] = 0;
46137		- label = 3863LLU; // consequent complete
	46474	+ label = 3902LLU; // consequent complete
46138	46475	break;
46139	46476	}
46140		- case 3862LLU: // alternative
	46477	+ case 3901LLU: // alternative
46141	46478	{
46142		- label = 3867LLU; // skip deleter
	46479	+ label = 3906LLU; // skip deleter
46143	46480	break;
46144	46481	}
46145		- case 3866LLU: // deleter
	46482	+ case 3905LLU: // deleter
46146	46483	{
46147	46484	// throw from procblock
46148	46485	if(!stack[base + 35])
46149	46486	{
46150		- label = 3859LLU; // skip, variable already deleted/unscoped
	46487	+ label = 3898LLU; // skip, variable already deleted/unscoped
46151	46488	break;
46152	46489	}
46153		- label = 3859LLU; // continue unrolling stack, delete next variable
	46490	+ label = 3898LLU; // continue unrolling stack, delete next variable
46154	46491	break;
46155	46492	}
46156		- case 3867LLU: // skipped deleter
	46493	+ case 3906LLU: // skipped deleter
46157	46494	{
46158	46495	// call isparam from procblock
46159		- stack[base + 36LLU] = 3868LLU/throw to this address/;
	46496	+ stack[base + 36LLU] = 3907LLU/throw to this address/;
46160	46497	stack[base + 37LLU] = base;
46161		- stack[base + 38LLU] = 3869LLU;
	46498	+ stack[base + 38LLU] = 3908LLU;
46162	46499	// arguments for call to isparam
46163	46500	stack[base + 40LLU] = stack[base + 10]/fnrescount/;
46164	46501	stack[base + 41LLU] = stack[base + 11]/fnargcount/;

		@@ -46168,21 +46505,21 @@
46168	46505	label = 1621LLU; // isparam
46169	46506	break;
46170	46507	}
46171		- case 3868LLU: // copy-back deleter (isparam to procblock)
	46508	+ case 3907LLU: // copy-back deleter (isparam to procblock)
46172	46509	{
46173	46510	// copy mutable arguments back from call to isparam
46174		- label = 3859LLU; // continue to roll stack
	46511	+ label = 3898LLU; // continue to roll stack
46175	46512	break;
46176	46513	}
46177		- case 3869LLU: // return from isparam to procblock
	46514	+ case 3908LLU: // return from isparam to procblock
46178	46515	{
46179	46516	// copy mutable arguments back from call to isparam
46180	46517	// copy back results provided by call to isparam
46181	46518	stack[base + 35] = stack[base + 39LLU];
46182	46519	// call or from procblock
46183		- stack[base + 36LLU] = 3870LLU/throw to this address/;
	46520	+ stack[base + 36LLU] = 3909LLU/throw to this address/;
46184	46521	stack[base + 37LLU] = base;
46185		- stack[base + 38LLU] = 3871LLU;
	46522	+ stack[base + 38LLU] = 3910LLU;
46186	46523	// arguments for call to or
46187	46524	stack[base + 40LLU] = stack[base + 33]/substruct/;
46188	46525	stack[base + 41LLU] = stack[base + 35]/param/;

		@@ -46191,41 +46528,41 @@
46191	46528	label = 18446744073709551611LLU; // or
46192	46529	break;
46193	46530	}
46194		- case 3870LLU: // copy-back deleter (or to procblock)
	46531	+ case 3909LLU: // copy-back deleter (or to procblock)
46195	46532	{
46196	46533	// copy mutable arguments back from call to or
46197		- label = 3866LLU; // continue to roll stack
	46534	+ label = 3905LLU; // continue to roll stack
46198	46535	break;
46199	46536	}
46200		- case 3871LLU: // return from or to procblock
	46537	+ case 3910LLU: // return from or to procblock
46201	46538	{
46202	46539	// copy mutable arguments back from call to or
46203	46540	// copy back results provided by call to or
46204	46541	stack[base + 34] = stack[base + 39LLU];
46205		- label = 3863LLU; // alternative complete
	46542	+ label = 3902LLU; // alternative complete
46206	46543	break;
46207	46544	}
46208		- case 3863LLU: // completed if-then-else
	46545	+ case 3902LLU: // completed if-then-else
46209	46546	{
46210		- label = 3873LLU; // skip deleter
	46547	+ label = 3912LLU; // skip deleter
46211	46548	break;
46212	46549	}
46213		- case 3872LLU: // deleter
	46550	+ case 3911LLU: // deleter
46214	46551	{
46215	46552	// throw from procblock
46216	46553	if(!stack[base + 35])
46217	46554	{
46218		- label = 3860LLU; // skip, variable already deleted/unscoped
	46555	+ label = 3899LLU; // skip, variable already deleted/unscoped
46219	46556	break;
46220	46557	}
46221		- label = 3860LLU; // continue unrolling stack, delete next variable
	46558	+ label = 3899LLU; // continue unrolling stack, delete next variable
46222	46559	break;
46223	46560	}
46224		- case 3873LLU: // skipped deleter
	46561	+ case 3912LLU: // skipped deleter
46225	46562	{
46226	46563	if(!stack[base + 26]/consume/)
46227	46564	{
46228		- label = 3874LLU; // jump to alternative
	46565	+ label = 3913LLU; // jump to alternative
46229	46566	break;
46230	46567	}
46231	46568

		@@ -46232,21 +46569,21 @@
46232	46569	// consequent
46233	46570	if(!stack[base + 32]/mutable/)
46234	46571	{
46235		- label = 3876LLU; // jump to alternative
	46572	+ label = 3915LLU; // jump to alternative
46236	46573	break;
46237	46574	}
46238	46575
46239	46576	// consequent
46240		- label = 3877LLU; // consequent complete
	46577	+ label = 3916LLU; // consequent complete
46241	46578	break;
46242	46579	}
46243		- case 3876LLU: // alternative
	46580	+ case 3915LLU: // alternative
46244	46581	{
46245	46582	fprintf(stderr, "%s", "in function ");
46246	46583	// call reportid from procblock
46247		- stack[base + 36LLU] = 3878LLU/throw to this address/;
	46584	+ stack[base + 36LLU] = 3917LLU/throw to this address/;
46248	46585	stack[base + 37LLU] = base;
46249		- stack[base + 38LLU] = 3879LLU;
	46586	+ stack[base + 38LLU] = 3918LLU;
46250	46587	// arguments for call to reportid
46251	46588	stack[base + 39LLU] = stack[base + 8]/fnid/;
46252	46589	// set stack-base & callee-address

		@@ -46254,13 +46591,13 @@
46254	46591	label = 18446744073709551586LLU; // reportid
46255	46592	break;
46256	46593	}
46257		- case 3878LLU: // copy-back deleter (reportid to procblock)
	46594	+ case 3917LLU: // copy-back deleter (reportid to procblock)
46258	46595	{
46259	46596	// copy mutable arguments back from call to reportid
46260		- label = 3860LLU; // continue to roll stack
	46597	+ label = 3899LLU; // continue to roll stack
46261	46598	break;
46262	46599	}
46263		- case 3879LLU: // return from reportid to procblock
	46600	+ case 3918LLU: // return from reportid to procblock
46264	46601	{
46265	46602	// copy mutable arguments back from call to reportid
46266	46603	fprintf(stderr, "%s", ": ");

		@@ -46268,7 +46605,7 @@
46268	46605	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
46269	46606	if(!newstack)
46270	46607	{
46271		- label = 3860LLU; // throw: begin to unroll stack
	46608	+ label = 3899LLU; // throw: begin to unroll stack
46272	46609	break;
46273	46610	}
46274	46611

		@@ -46275,9 +46612,9 @@
46275	46612	newstack[10LLU] = 9876543210LLU; // overflow-marker
46276	46613	// call reporttype from procblock
46277	46614	newstack[0] = (uint64_t)stack; // backup stack location
46278		- newstack[1] = 3880LLU;
	46615	+ newstack[1] = 3919LLU;
46279	46616	newstack[2] = base;
46280		- newstack[3] = 3881LLU;
	46617	+ newstack[3] = 3920LLU;
46281	46618	// arguments for call to reporttype
46282	46619	newstack[4LLU] = stack[base + 29]/listtype/;
46283	46620	stack = newstack;

		@@ -46286,7 +46623,7 @@
46286	46623	label = 326LLU; // reporttype
46287	46624	break;
46288	46625	}
46289		- case 3880LLU: // copy-back deleter (reporttype to procblock)
	46626	+ case 3919LLU: // copy-back deleter (reporttype to procblock)
46290	46627	{
46291	46628	uint64_t oldstack = (uint64_t )stack[0];
46292	46629	// copy mutable arguments back from call to reporttype

		@@ -46297,10 +46634,10 @@
46297	46634	}
46298	46635	Free(10LLU + 1, sizeof(uint64_t), stack);
46299	46636	stack = oldstack;
46300		- label = 3860LLU; // continue to unroll stack
	46637	+ label = 3899LLU; // continue to unroll stack
46301	46638	break;
46302	46639	}
46303		- case 3881LLU: // return from reporttype to procblock
	46640	+ case 3920LLU: // return from reporttype to procblock
46304	46641	{
46305	46642	uint64_t oldstack = (uint64_t )stack[0];
46306	46643	// copy mutable arguments back from call to reporttype

		@@ -46313,18 +46650,18 @@
46313	46650	stack = oldstack;
46314	46651	fprintf(stderr, "%s", "\n");
46315	46652	{
46316		- label = 3860LLU; // throw: begin to unroll stack
	46653	+ label = 3899LLU; // throw: begin to unroll stack
46317	46654	break;
46318	46655	}
46319	46656
46320		- label = 3877LLU; // alternative complete
	46657	+ label = 3916LLU; // alternative complete
46321	46658	break;
46322	46659	}
46323		- case 3877LLU: // completed if-then-else
	46660	+ case 3916LLU: // completed if-then-else
46324	46661	{
46325	46662	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
46326	46663	{
46327		- label = 3883LLU; // jump to alternative
	46664	+ label = 3922LLU; // jump to alternative
46328	46665	break;
46329	46666	}
46330	46667

		@@ -46332,15 +46669,15 @@
46332	46669	/letdefs/stack[base + 37] = ((uint64_t *)(stack[base + 3]/scope/))[1][1]/letdefs*/;
46333	46670
46334	46671	// case
46335		- label = 3886LLU; // skip deleter
	46672	+ label = 3925LLU; // skip deleter
46336	46673	break;
46337	46674	}
46338		- case 3885LLU: // deleter
	46675	+ case 3924LLU: // deleter
46339	46676	{
46340	46677	// throw from procblock
46341	46678	if(!stack[base + 38])
46342	46679	{
46343		- label = 3884LLU; // skip, variable already deleted/unscoped
	46680	+ label = 3923LLU; // skip, variable already deleted/unscoped
46344	46681	break;
46345	46682	}
46346	46683

		@@ -46349,7 +46686,7 @@
46349	46686	newstack[0] = (uint64_t)stack; // backup stack location
46350	46687	newstack[1] = 1234567890;
46351	46688	newstack[2] = base;
46352		- newstack[3] = 3887LLU;
	46689	+ newstack[3] = 3926LLU;
46353	46690	stack = newstack;
46354	46691	// set stack-base & callee-address
46355	46692	base = 4/deloffset/;

		@@ -46356,21 +46693,21 @@
46356	46693	label = 306LLU; // ~type
46357	46694	break;
46358	46695	}
46359		- case 3887LLU: // return from ~type to procblock
	46696	+ case 3926LLU: // return from ~type to procblock
46360	46697	{
46361	46698	stack = (uint64_t *)stack[0];
46362	46699	// releasing toplevel container
46363	46700	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 38] - sizeof(uint64_t) 4));
46364	46701
46365		- label = 3884LLU; // continue unrolling stack, delete next variable
	46702	+ label = 3923LLU; // continue unrolling stack, delete next variable
46366	46703	break;
46367	46704	}
46368		- case 3886LLU: // skipped deleter
	46705	+ case 3925LLU: // skipped deleter
46369	46706	{
46370	46707	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
46371	46708	if(!newstack)
46372	46709	{
46373		- label = 3884LLU; // throw: begin to unroll stack
	46710	+ label = 3923LLU; // throw: begin to unroll stack
46374	46711	break;
46375	46712	}
46376	46713

		@@ -46377,9 +46714,9 @@
46377	46714	newstack[15LLU] = 9876543210LLU; // overflow-marker
46378	46715	// call copytype from procblock
46379	46716	newstack[0] = (uint64_t)stack; // backup stack location
46380		- newstack[1] = 3888LLU;
	46717	+ newstack[1] = 3927LLU;
46381	46718	newstack[2] = base;
46382		- newstack[3] = 3889LLU;
	46719	+ newstack[3] = 3928LLU;
46383	46720	// arguments for call to copytype
46384	46721	newstack[5LLU] = stack[base + 29]/listtype/;
46385	46722	stack = newstack;

		@@ -46388,7 +46725,7 @@
46388	46725	label = 337LLU; // copytype
46389	46726	break;
46390	46727	}
46391		- case 3888LLU: // copy-back deleter (copytype to procblock)
	46728	+ case 3927LLU: // copy-back deleter (copytype to procblock)
46392	46729	{
46393	46730	uint64_t oldstack = (uint64_t )stack[0];
46394	46731	// copy mutable arguments back from call to copytype

		@@ -46399,10 +46736,10 @@
46399	46736	}
46400	46737	Free(15LLU + 1, sizeof(uint64_t), stack);
46401	46738	stack = oldstack;
46402		- label = 3884LLU; // continue to unroll stack
	46739	+ label = 3923LLU; // continue to unroll stack
46403	46740	break;
46404	46741	}
46405		- case 3889LLU: // return from copytype to procblock
	46742	+ case 3928LLU: // return from copytype to procblock
46406	46743	{
46407	46744	uint64_t oldstack = (uint64_t )stack[0];
46408	46745	// copy mutable arguments back from call to copytype

		@@ -46415,49 +46752,49 @@
46415	46752	}
46416	46753	Free(15LLU + 1, sizeof(uint64_t), stack);
46417	46754	stack = oldstack;
46418		- label = 3891LLU; // skip deleter
	46755	+ label = 3930LLU; // skip deleter
46419	46756	break;
46420	46757	}
46421		- case 3890LLU: // deleter
	46758	+ case 3929LLU: // deleter
46422	46759	{
46423	46760	// throw from procblock
46424	46761	if(!stack[base + 39])
46425	46762	{
46426		- label = 3885LLU; // skip, variable already deleted/unscoped
	46763	+ label = 3924LLU; // skip, variable already deleted/unscoped
46427	46764	break;
46428	46765	}
46429		- label = 3885LLU; // continue unrolling stack, delete next variable
	46766	+ label = 3924LLU; // continue unrolling stack, delete next variable
46430	46767	break;
46431	46768	}
46432		- case 3891LLU: // skipped deleter
	46769	+ case 3930LLU: // skipped deleter
46433	46770	{
46434	46771	stack[base + 39] = 0;
46435		- label = 3893LLU; // skip deleter
	46772	+ label = 3932LLU; // skip deleter
46436	46773	break;
46437	46774	}
46438		- case 3892LLU: // deleter
	46775	+ case 3931LLU: // deleter
46439	46776	{
46440	46777	// throw from procblock
46441	46778	if(!stack[base + 40])
46442	46779	{
46443		- label = 3890LLU; // skip, variable already deleted/unscoped
	46780	+ label = 3929LLU; // skip, variable already deleted/unscoped
46444	46781	break;
46445	46782	}
46446		- label = 3890LLU; // continue unrolling stack, delete next variable
	46783	+ label = 3929LLU; // continue unrolling stack, delete next variable
46447	46784	break;
46448	46785	}
46449		- case 3893LLU: // skipped deleter
	46786	+ case 3932LLU: // skipped deleter
46450	46787	{
46451	46788	stack[base + 40] = 0;
46452		- label = 3895LLU; // skip deleter
	46789	+ label = 3934LLU; // skip deleter
46453	46790	break;
46454	46791	}
46455		- case 3894LLU: // deleter
	46792	+ case 3933LLU: // deleter
46456	46793	{
46457	46794	// throw from procblock
46458	46795	if(!stack[base + 41])
46459	46796	{
46460		- label = 3892LLU; // skip, variable already deleted/unscoped
	46797	+ label = 3931LLU; // skip, variable already deleted/unscoped
46461	46798	break;
46462	46799	}
46463	46800

		@@ -46466,7 +46803,7 @@
46466	46803	newstack[0] = (uint64_t)stack; // backup stack location
46467	46804	newstack[1] = 1234567890;
46468	46805	newstack[2] = base;
46469		- newstack[3] = 3896LLU;
	46806	+ newstack[3] = 3935LLU;
46470	46807	stack = newstack;
46471	46808	// set stack-base & callee-address
46472	46809	base = 4/deloffset/;

		@@ -46473,21 +46810,21 @@
46473	46810	label = 482LLU; // ~letdef
46474	46811	break;
46475	46812	}
46476		- case 3896LLU: // return from ~letdef to procblock
	46813	+ case 3935LLU: // return from ~letdef to procblock
46477	46814	{
46478	46815	stack = (uint64_t *)stack[0];
46479	46816	// releasing toplevel container
46480	46817	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 41] - sizeof(uint64_t) 4));
46481	46818
46482		- label = 3892LLU; // continue unrolling stack, delete next variable
	46819	+ label = 3931LLU; // continue unrolling stack, delete next variable
46483	46820	break;
46484	46821	}
46485		- case 3895LLU: // skipped deleter
	46822	+ case 3934LLU: // skipped deleter
46486	46823	{
46487	46824	// construct letdef.letdef
46488	46825	if(!(stack[base + 41] = construct(5)))
46489	46826	{
46490		- label = 3892LLU; // throw: begin to unroll stack
	46827	+ label = 3931LLU; // throw: begin to unroll stack
46491	46828	break;
46492	46829	}
46493	46830

		@@ -46513,50 +46850,50 @@
46513	46850	}
46514	46851	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 37];
46515	46852	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 36];
46516		- label = 3882LLU; // case complete
	46853	+ label = 3921LLU; // case complete
46517	46854	break;
46518	46855	}
46519		- case 3884LLU: // copy-back deleter (switch)
	46856	+ case 3923LLU: // copy-back deleter (switch)
46520	46857	{
46521	46858	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 37];
46522	46859	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 36];
46523		- label = 3860LLU; // continue to unroll stack
	46860	+ label = 3899LLU; // continue to unroll stack
46524	46861	break;
46525	46862	}
46526		- case 3883LLU: // try next case
	46863	+ case 3922LLU: // try next case
46527	46864	{
46528	46865	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
46529	46866	exit(-1);
46530	46867	}
46531		- case 3882LLU: // completed switch
	46868	+ case 3921LLU: // completed switch
46532	46869	{
46533		- label = 3898LLU; // skip deleter
	46870	+ label = 3937LLU; // skip deleter
46534	46871	break;
46535	46872	}
46536		- case 3897LLU: // deleter
	46873	+ case 3936LLU: // deleter
46537	46874	{
46538	46875	// throw from procblock
46539	46876	if(!stack[base + 35])
46540	46877	{
46541		- label = 3860LLU; // skip, variable already deleted/unscoped
	46878	+ label = 3899LLU; // skip, variable already deleted/unscoped
46542	46879	break;
46543	46880	}
46544		- label = 3860LLU; // continue unrolling stack, delete next variable
	46881	+ label = 3899LLU; // continue unrolling stack, delete next variable
46545	46882	break;
46546	46883	}
46547		- case 3898LLU: // skipped deleter
	46884	+ case 3937LLU: // skipped deleter
46548	46885	{
46549	46886	stack[base + 35] = stack[base + 31]/listindex/;
46550		- label = 3875LLU; // consequent complete
	46887	+ label = 3914LLU; // consequent complete
46551	46888	break;
46552	46889	}
46553		- case 3874LLU: // alternative
	46890	+ case 3913LLU: // alternative
46554	46891	{
46555	46892	printf("%s", "\n flippedassign(");
46556	46893	// call emitvar from procblock
46557		- stack[base + 36LLU] = 3899LLU/throw to this address/;
	46894	+ stack[base + 36LLU] = 3938LLU/throw to this address/;
46558	46895	stack[base + 37LLU] = base;
46559		- stack[base + 38LLU] = 3900LLU;
	46896	+ stack[base + 38LLU] = 3939LLU;
46560	46897	// arguments for call to emitvar
46561	46898	stack[base + 39LLU] = stack[base + 8]/fnid/;
46562	46899	stack[base + 40LLU] = stack[base + 30]/listid/;

		@@ -46567,36 +46904,36 @@
46567	46904	label = 745LLU; // emitvar
46568	46905	break;
46569	46906	}
46570		- case 3899LLU: // copy-back deleter (emitvar to procblock)
	46907	+ case 3938LLU: // copy-back deleter (emitvar to procblock)
46571	46908	{
46572	46909	// copy mutable arguments back from call to emitvar
46573		- label = 3860LLU; // continue to roll stack
	46910	+ label = 3899LLU; // continue to roll stack
46574	46911	break;
46575	46912	}
46576		- case 3900LLU: // return from emitvar to procblock
	46913	+ case 3939LLU: // return from emitvar to procblock
46577	46914	{
46578	46915	// copy mutable arguments back from call to emitvar
46579	46916	printf("%s", ", &");
46580		- label = 3902LLU; // skip deleter
	46917	+ label = 3941LLU; // skip deleter
46581	46918	break;
46582	46919	}
46583		- case 3901LLU: // deleter
	46920	+ case 3940LLU: // deleter
46584	46921	{
46585	46922	// throw from procblock
46586	46923	if(!stack[base + 36])
46587	46924	{
46588		- label = 3860LLU; // skip, variable already deleted/unscoped
	46925	+ label = 3899LLU; // skip, variable already deleted/unscoped
46589	46926	break;
46590	46927	}
46591		- label = 3860LLU; // continue unrolling stack, delete next variable
	46928	+ label = 3899LLU; // continue unrolling stack, delete next variable
46592	46929	break;
46593	46930	}
46594		- case 3902LLU: // skipped deleter
	46931	+ case 3941LLU: // skipped deleter
46595	46932	{
46596	46933	// call newvarraw from procblock
46597		- stack[base + 37LLU] = 3903LLU/throw to this address/;
	46934	+ stack[base + 37LLU] = 3942LLU/throw to this address/;
46598	46935	stack[base + 38LLU] = base;
46599		- stack[base + 39LLU] = 3904LLU;
	46936	+ stack[base + 39LLU] = 3943LLU;
46600	46937	// arguments for call to newvarraw
46601	46938	stack[base + 41LLU] = stack[base + 29]/listtype/;
46602	46939	stack[base + 42LLU] = stack[base + 30]/listid/;

		@@ -46612,16 +46949,16 @@
46612	46949	label = 755LLU; // newvarraw
46613	46950	break;
46614	46951	}
46615		- case 3903LLU: // copy-back deleter (newvarraw to procblock)
	46952	+ case 3942LLU: // copy-back deleter (newvarraw to procblock)
46616	46953	{
46617	46954	// copy mutable arguments back from call to newvarraw
46618	46955	stack[base + 3]/scope/ = stack[base + 48LLU];
46619	46956	stack[base + 18]/varcount/ = stack[base + 47LLU];
46620	46957	stack[base + 12]/fnmaxcount/ = stack[base + 46LLU];
46621		- label = 3860LLU; // continue to roll stack
	46958	+ label = 3899LLU; // continue to roll stack
46622	46959	break;
46623	46960	}
46624		- case 3904LLU: // return from newvarraw to procblock
	46961	+ case 3943LLU: // return from newvarraw to procblock
46625	46962	{
46626	46963	// copy mutable arguments back from call to newvarraw
46627	46964	stack[base + 3]/scope/ = stack[base + 48LLU];

		@@ -46630,9 +46967,9 @@
46630	46967	// copy back results provided by call to newvarraw
46631	46968	stack[base + 36] = stack[base + 40LLU];
46632	46969	// call emitvaridx from procblock
46633		- stack[base + 37LLU] = 3905LLU/throw to this address/;
	46970	+ stack[base + 37LLU] = 3944LLU/throw to this address/;
46634	46971	stack[base + 38LLU] = base;
46635		- stack[base + 39LLU] = 3906LLU;
	46972	+ stack[base + 39LLU] = 3945LLU;
46636	46973	// arguments for call to emitvaridx
46637	46974	stack[base + 40LLU] = stack[base + 36]/shadowidx/;
46638	46975	// set stack-base & callee-address

		@@ -46640,43 +46977,43 @@
46640	46977	label = 741LLU; // emitvaridx
46641	46978	break;
46642	46979	}
46643		- case 3905LLU: // copy-back deleter (emitvaridx to procblock)
	46980	+ case 3944LLU: // copy-back deleter (emitvaridx to procblock)
46644	46981	{
46645	46982	// copy mutable arguments back from call to emitvaridx
46646		- label = 3901LLU; // continue to roll stack
	46983	+ label = 3940LLU; // continue to roll stack
46647	46984	break;
46648	46985	}
46649		- case 3906LLU: // return from emitvaridx to procblock
	46986	+ case 3945LLU: // return from emitvaridx to procblock
46650	46987	{
46651	46988	// copy mutable arguments back from call to emitvaridx
46652	46989	printf("%s", ");");
46653		- label = 3908LLU; // skip deleter
	46990	+ label = 3947LLU; // skip deleter
46654	46991	break;
46655	46992	}
46656		- case 3907LLU: // deleter
	46993	+ case 3946LLU: // deleter
46657	46994	{
46658	46995	// throw from procblock
46659	46996	if(!stack[base + 35])
46660	46997	{
46661		- label = 3901LLU; // skip, variable already deleted/unscoped
	46998	+ label = 3940LLU; // skip, variable already deleted/unscoped
46662	46999	break;
46663	47000	}
46664		- label = 3901LLU; // continue unrolling stack, delete next variable
	47001	+ label = 3940LLU; // continue unrolling stack, delete next variable
46665	47002	break;
46666	47003	}
46667		- case 3908LLU: // skipped deleter
	47004	+ case 3947LLU: // skipped deleter
46668	47005	{
46669	47006	stack[base + 35] = stack[base + 36]/shadowidx/;
46670		- label = 3875LLU; // alternative complete
	47007	+ label = 3914LLU; // alternative complete
46671	47008	break;
46672	47009	}
46673		- case 3875LLU: // completed if-then-else
	47010	+ case 3914LLU: // completed if-then-else
46674	47011	{
46675	47012	printf("%s", "\n label = ");
46676	47013	// call printnr from procblock
46677		- stack[base + 36LLU] = 3909LLU/throw to this address/;
	47014	+ stack[base + 36LLU] = 3948LLU/throw to this address/;
46678	47015	stack[base + 37LLU] = base;
46679		- stack[base + 38LLU] = 3910LLU;
	47016	+ stack[base + 38LLU] = 3949LLU;
46680	47017	// arguments for call to printnr
46681	47018	stack[base + 39LLU] = stack[base + 22]/labelloop/;
46682	47019	// set stack-base & callee-address

		@@ -46684,13 +47021,13 @@
46684	47021	label = 18446744073709551590LLU; // printnr
46685	47022	break;
46686	47023	}
46687		- case 3909LLU: // copy-back deleter (printnr to procblock)
	47024	+ case 3948LLU: // copy-back deleter (printnr to procblock)
46688	47025	{
46689	47026	// copy mutable arguments back from call to printnr
46690		- label = 3872LLU; // continue to roll stack
	47027	+ label = 3911LLU; // continue to roll stack
46691	47028	break;
46692	47029	}
46693		- case 3910LLU: // return from printnr to procblock
	47030	+ case 3949LLU: // return from printnr to procblock
46694	47031	{
46695	47032	// copy mutable arguments back from call to printnr
46696	47033	printf("%s", "LLU; // start to repeat");

		@@ -46698,9 +47035,9 @@
46698	47035	printf("%s", "\n }");
46699	47036	printf("%s", "\n case ");
46700	47037	// call printnr from procblock
46701		- stack[base + 36LLU] = 3911LLU/throw to this address/;
	47038	+ stack[base + 36LLU] = 3950LLU/throw to this address/;
46702	47039	stack[base + 37LLU] = base;
46703		- stack[base + 38LLU] = 3912LLU;
	47040	+ stack[base + 38LLU] = 3951LLU;
46704	47041	// arguments for call to printnr
46705	47042	stack[base + 39LLU] = stack[base + 22]/labelloop/;
46706	47043	// set stack-base & callee-address

		@@ -46708,13 +47045,13 @@
46708	47045	label = 18446744073709551590LLU; // printnr
46709	47046	break;
46710	47047	}
46711		- case 3911LLU: // copy-back deleter (printnr to procblock)
	47048	+ case 3950LLU: // copy-back deleter (printnr to procblock)
46712	47049	{
46713	47050	// copy mutable arguments back from call to printnr
46714		- label = 3872LLU; // continue to roll stack
	47051	+ label = 3911LLU; // continue to roll stack
46715	47052	break;
46716	47053	}
46717		- case 3912LLU: // return from printnr to procblock
	47054	+ case 3951LLU: // return from printnr to procblock
46718	47055	{
46719	47056	// copy mutable arguments back from call to printnr
46720	47057	printf("%s", "LLU: // repeat from here");

		@@ -46721,9 +47058,9 @@
46721	47058	printf("%s", "\n {");
46722	47059	printf("%s", "\n if(!");
46723	47060	// call emitvaridx from procblock
46724		- stack[base + 36LLU] = 3913LLU/throw to this address/;
	47061	+ stack[base + 36LLU] = 3952LLU/throw to this address/;
46725	47062	stack[base + 37LLU] = base;
46726		- stack[base + 38LLU] = 3914LLU;
	47063	+ stack[base + 38LLU] = 3953LLU;
46727	47064	// arguments for call to emitvaridx
46728	47065	stack[base + 39LLU] = stack[base + 35]/listindex/;
46729	47066	// set stack-base & callee-address

		@@ -46731,19 +47068,19 @@
46731	47068	label = 741LLU; // emitvaridx
46732	47069	break;
46733	47070	}
46734		- case 3913LLU: // copy-back deleter (emitvaridx to procblock)
	47071	+ case 3952LLU: // copy-back deleter (emitvaridx to procblock)
46735	47072	{
46736	47073	// copy mutable arguments back from call to emitvaridx
46737		- label = 3872LLU; // continue to roll stack
	47074	+ label = 3911LLU; // continue to roll stack
46738	47075	break;
46739	47076	}
46740		- case 3914LLU: // return from emitvaridx to procblock
	47077	+ case 3953LLU: // return from emitvaridx to procblock
46741	47078	{
46742	47079	// copy mutable arguments back from call to emitvaridx
46743	47080	// call matchsym from procblock
46744		- stack[base + 36LLU] = 3915LLU/throw to this address/;
	47081	+ stack[base + 36LLU] = 3954LLU/throw to this address/;
46745	47082	stack[base + 37LLU] = base;
46746		- stack[base + 38LLU] = 3916LLU;
	47083	+ stack[base + 38LLU] = 3955LLU;
46747	47084	// arguments for call to matchsym
46748	47085	stack[base + 39LLU] = stack[base + 8]/fnid/;
46749	47086	stack[base + 40LLU] = 41LLU;

		@@ -46753,21 +47090,21 @@
46753	47090	label = 222LLU; // matchsym
46754	47091	break;
46755	47092	}
46756		- case 3915LLU: // copy-back deleter (matchsym to procblock)
	47093	+ case 3954LLU: // copy-back deleter (matchsym to procblock)
46757	47094	{
46758	47095	// copy mutable arguments back from call to matchsym
46759	47096	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46760		- label = 3872LLU; // continue to roll stack
	47097	+ label = 3911LLU; // continue to roll stack
46761	47098	break;
46762	47099	}
46763		- case 3916LLU: // return from matchsym to procblock
	47100	+ case 3955LLU: // return from matchsym to procblock
46764	47101	{
46765	47102	// copy mutable arguments back from call to matchsym
46766	47103	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46767	47104	// call matchsym from procblock
46768		- stack[base + 36LLU] = 3917LLU/throw to this address/;
	47105	+ stack[base + 36LLU] = 3956LLU/throw to this address/;
46769	47106	stack[base + 37LLU] = base;
46770		- stack[base + 38LLU] = 3918LLU;
	47107	+ stack[base + 38LLU] = 3957LLU;
46771	47108	// arguments for call to matchsym
46772	47109	stack[base + 39LLU] = stack[base + 8]/fnid/;
46773	47110	stack[base + 40LLU] = 45LLU;

		@@ -46777,21 +47114,21 @@
46777	47114	label = 222LLU; // matchsym
46778	47115	break;
46779	47116	}
46780		- case 3917LLU: // copy-back deleter (matchsym to procblock)
	47117	+ case 3956LLU: // copy-back deleter (matchsym to procblock)
46781	47118	{
46782	47119	// copy mutable arguments back from call to matchsym
46783	47120	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46784		- label = 3872LLU; // continue to roll stack
	47121	+ label = 3911LLU; // continue to roll stack
46785	47122	break;
46786	47123	}
46787		- case 3918LLU: // return from matchsym to procblock
	47124	+ case 3957LLU: // return from matchsym to procblock
46788	47125	{
46789	47126	// copy mutable arguments back from call to matchsym
46790	47127	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46791	47128	// call matchsym from procblock
46792		- stack[base + 36LLU] = 3919LLU/throw to this address/;
	47129	+ stack[base + 36LLU] = 3958LLU/throw to this address/;
46793	47130	stack[base + 37LLU] = base;
46794		- stack[base + 38LLU] = 3920LLU;
	47131	+ stack[base + 38LLU] = 3959LLU;
46795	47132	// arguments for call to matchsym
46796	47133	stack[base + 39LLU] = stack[base + 8]/fnid/;
46797	47134	stack[base + 40LLU] = 62LLU;

		@@ -46801,21 +47138,21 @@
46801	47138	label = 222LLU; // matchsym
46802	47139	break;
46803	47140	}
46804		- case 3919LLU: // copy-back deleter (matchsym to procblock)
	47141	+ case 3958LLU: // copy-back deleter (matchsym to procblock)
46805	47142	{
46806	47143	// copy mutable arguments back from call to matchsym
46807	47144	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46808		- label = 3872LLU; // continue to roll stack
	47145	+ label = 3911LLU; // continue to roll stack
46809	47146	break;
46810	47147	}
46811		- case 3920LLU: // return from matchsym to procblock
	47148	+ case 3959LLU: // return from matchsym to procblock
46812	47149	{
46813	47150	// copy mutable arguments back from call to matchsym
46814	47151	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46815	47152	// call matchsym from procblock
46816		- stack[base + 36LLU] = 3921LLU/throw to this address/;
	47153	+ stack[base + 36LLU] = 3960LLU/throw to this address/;
46817	47154	stack[base + 37LLU] = base;
46818		- stack[base + 38LLU] = 3922LLU;
	47155	+ stack[base + 38LLU] = 3961LLU;
46819	47156	// arguments for call to matchsym
46820	47157	stack[base + 39LLU] = stack[base + 8]/fnid/;
46821	47158	stack[base + 40LLU] = 40LLU;

		@@ -46825,38 +47162,38 @@
46825	47162	label = 222LLU; // matchsym
46826	47163	break;
46827	47164	}
46828		- case 3921LLU: // copy-back deleter (matchsym to procblock)
	47165	+ case 3960LLU: // copy-back deleter (matchsym to procblock)
46829	47166	{
46830	47167	// copy mutable arguments back from call to matchsym
46831	47168	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46832		- label = 3872LLU; // continue to roll stack
	47169	+ label = 3911LLU; // continue to roll stack
46833	47170	break;
46834	47171	}
46835		- case 3922LLU: // return from matchsym to procblock
	47172	+ case 3961LLU: // return from matchsym to procblock
46836	47173	{
46837	47174	// copy mutable arguments back from call to matchsym
46838	47175	stack[base + 19]/lookahead/ = stack[base + 41LLU];
46839		- label = 3924LLU; // skip deleter
	47176	+ label = 3963LLU; // skip deleter
46840	47177	break;
46841	47178	}
46842		- case 3923LLU: // deleter
	47179	+ case 3962LLU: // deleter
46843	47180	{
46844	47181	// throw from procblock
46845	47182	if(!stack[base + 36])
46846	47183	{
46847		- label = 3872LLU; // skip, variable already deleted/unscoped
	47184	+ label = 3911LLU; // skip, variable already deleted/unscoped
46848	47185	break;
46849	47186	}
46850		- label = 3872LLU; // continue unrolling stack, delete next variable
	47187	+ label = 3911LLU; // continue unrolling stack, delete next variable
46851	47188	break;
46852	47189	}
46853		- case 3924LLU: // skipped deleter
	47190	+ case 3963LLU: // skipped deleter
46854	47191	{
46855	47192	stack[base + 36] = 0;
46856	47193	// call ParseToken from procblock
46857		- stack[base + 37LLU] = 3925LLU/throw to this address/;
	47194	+ stack[base + 37LLU] = 3964LLU/throw to this address/;
46858	47195	stack[base + 38LLU] = base;
46859		- stack[base + 39LLU] = 3926LLU;
	47196	+ stack[base + 39LLU] = 3965LLU;
46860	47197	// arguments for call to ParseToken
46861	47198	stack[base + 42LLU] = stack[base + 19]/lookahead/;
46862	47199	// set stack-base & callee-address

		@@ -46864,14 +47201,14 @@
46864	47201	label = 3LLU; // ParseToken
46865	47202	break;
46866	47203	}
46867		- case 3925LLU: // copy-back deleter (ParseToken to procblock)
	47204	+ case 3964LLU: // copy-back deleter (ParseToken to procblock)
46868	47205	{
46869	47206	// copy mutable arguments back from call to ParseToken
46870	47207	stack[base + 19]/lookahead/ = stack[base + 42LLU];
46871		- label = 3923LLU; // continue to roll stack
	47208	+ label = 3962LLU; // continue to roll stack
46872	47209	break;
46873	47210	}
46874		- case 3926LLU: // return from ParseToken to procblock
	47211	+ case 3965LLU: // return from ParseToken to procblock
46875	47212	{
46876	47213	// copy mutable arguments back from call to ParseToken
46877	47214	stack[base + 19]/lookahead/ = stack[base + 42LLU];

		@@ -46879,9 +47216,9 @@
46879	47216	stack[base + 15] = stack[base + 40LLU];
46880	47217	stack[base + 36] = stack[base + 41LLU];
46881	47218	// call equ from procblock
46882		- stack[base + 37LLU] = 3927LLU/throw to this address/;
	47219	+ stack[base + 37LLU] = 3966LLU/throw to this address/;
46883	47220	stack[base + 38LLU] = base;
46884		- stack[base + 39LLU] = 3928LLU;
	47221	+ stack[base + 39LLU] = 3967LLU;
46885	47222	// arguments for call to equ
46886	47223	stack[base + 41LLU] = stack[base + 15]/variant/;
46887	47224	stack[base + 42LLU] = 4LLU;

		@@ -46890,13 +47227,13 @@
46890	47227	label = 18446744073709551600LLU; // equ
46891	47228	break;
46892	47229	}
46893		- case 3927LLU: // copy-back deleter (equ to procblock)
	47230	+ case 3966LLU: // copy-back deleter (equ to procblock)
46894	47231	{
46895	47232	// copy mutable arguments back from call to equ
46896		- label = 3923LLU; // continue to roll stack
	47233	+ label = 3962LLU; // continue to roll stack
46897	47234	break;
46898	47235	}
46899		- case 3928LLU: // return from equ to procblock
	47236	+ case 3967LLU: // return from equ to procblock
46900	47237	{
46901	47238	// copy mutable arguments back from call to equ
46902	47239	// copy back results provided by call to equ

		@@ -46903,21 +47240,21 @@
46903	47240	stack[base + 20] = stack[base + 40LLU];
46904	47241	if(!stack[base + 20]/isequal/)
46905	47242	{
46906		- label = 3929LLU; // jump to alternative
	47243	+ label = 3968LLU; // jump to alternative
46907	47244	break;
46908	47245	}
46909	47246
46910	47247	// consequent
46911		- label = 3930LLU; // consequent complete
	47248	+ label = 3969LLU; // consequent complete
46912	47249	break;
46913	47250	}
46914		- case 3929LLU: // alternative
	47251	+ case 3968LLU: // alternative
46915	47252	{
46916	47253	fprintf(stderr, "%s", "expected identifier in while next but found ");
46917	47254	// call reporttok from procblock
46918		- stack[base + 37LLU] = 3931LLU/throw to this address/;
	47255	+ stack[base + 37LLU] = 3970LLU/throw to this address/;
46919	47256	stack[base + 38LLU] = base;
46920		- stack[base + 39LLU] = 3932LLU;
	47257	+ stack[base + 39LLU] = 3971LLU;
46921	47258	// arguments for call to reporttok
46922	47259	stack[base + 40LLU] = stack[base + 15]/variant/;
46923	47260	stack[base + 41LLU] = stack[base + 36]/elemid/;

		@@ -46926,33 +47263,33 @@
46926	47263	label = 18446744073709551582LLU; // reporttok
46927	47264	break;
46928	47265	}
46929		- case 3931LLU: // copy-back deleter (reporttok to procblock)
	47266	+ case 3970LLU: // copy-back deleter (reporttok to procblock)
46930	47267	{
46931	47268	// copy mutable arguments back from call to reporttok
46932		- label = 3923LLU; // continue to roll stack
	47269	+ label = 3962LLU; // continue to roll stack
46933	47270	break;
46934	47271	}
46935		- case 3932LLU: // return from reporttok to procblock
	47272	+ case 3971LLU: // return from reporttok to procblock
46936	47273	{
46937	47274	// copy mutable arguments back from call to reporttok
46938	47275	fprintf(stderr, "%s", "\n");
46939	47276	{
46940		- label = 3923LLU; // throw: begin to unroll stack
	47277	+ label = 3962LLU; // throw: begin to unroll stack
46941	47278	break;
46942	47279	}
46943	47280
46944		- label = 3930LLU; // alternative complete
	47281	+ label = 3969LLU; // alternative complete
46945	47282	break;
46946	47283	}
46947		- case 3930LLU: // completed if-then-else
	47284	+ case 3969LLU: // completed if-then-else
46948	47285	{
46949	47286	printf("%s", ")");
46950	47287	printf("%s", "\n {");
46951	47288	printf("%s", "\n label = ");
46952	47289	// call printnr from procblock
46953		- stack[base + 37LLU] = 3933LLU/throw to this address/;
	47290	+ stack[base + 37LLU] = 3972LLU/throw to this address/;
46954	47291	stack[base + 38LLU] = base;
46955		- stack[base + 39LLU] = 3934LLU;
	47292	+ stack[base + 39LLU] = 3973LLU;
46956	47293	// arguments for call to printnr
46957	47294	stack[base + 40LLU] = stack[base + 23]/labelskip/;
46958	47295	// set stack-base & callee-address

		@@ -46960,13 +47297,13 @@
46960	47297	label = 18446744073709551590LLU; // printnr
46961	47298	break;
46962	47299	}
46963		- case 3933LLU: // copy-back deleter (printnr to procblock)
	47300	+ case 3972LLU: // copy-back deleter (printnr to procblock)
46964	47301	{
46965	47302	// copy mutable arguments back from call to printnr
46966		- label = 3923LLU; // continue to roll stack
	47303	+ label = 3962LLU; // continue to roll stack
46967	47304	break;
46968	47305	}
46969		- case 3934LLU: // return from printnr to procblock
	47306	+ case 3973LLU: // return from printnr to procblock
46970	47307	{
46971	47308	// copy mutable arguments back from call to printnr
46972	47309	printf("%s", "LLU; // break loop");

		@@ -46976,7 +47313,7 @@
46976	47313	printf("%s", "\n // loop body");
46977	47314	if(/typelist/1 != ((uint64_t )(stack[base + 29]/listtype*/))[0])
46978	47315	{
46979		- label = 3936LLU; // jump to alternative
	47316	+ label = 3975LLU; // jump to alternative
46980	47317	break;
46981	47318	}
46982	47319

		@@ -46983,26 +47320,26 @@
46983	47320	/elemtype/stack[base + 37] = ((uint64_t *)(stack[base + 29]/listtype/))[1][0]/subtype*/;
46984	47321
46985	47322	// case
46986		- label = 3939LLU; // skip deleter
	47323	+ label = 3978LLU; // skip deleter
46987	47324	break;
46988	47325	}
46989		- case 3938LLU: // deleter
	47326	+ case 3977LLU: // deleter
46990	47327	{
46991	47328	// throw from procblock
46992	47329	if(!stack[base + 38])
46993	47330	{
46994		- label = 3937LLU; // skip, variable already deleted/unscoped
	47331	+ label = 3976LLU; // skip, variable already deleted/unscoped
46995	47332	break;
46996	47333	}
46997		- label = 3937LLU; // continue unrolling stack, delete next variable
	47334	+ label = 3976LLU; // continue unrolling stack, delete next variable
46998	47335	break;
46999	47336	}
47000		- case 3939LLU: // skipped deleter
	47337	+ case 3978LLU: // skipped deleter
47001	47338	{
47002	47339	// call newvarraw from procblock
47003		- stack[base + 39LLU] = 3940LLU/throw to this address/;
	47340	+ stack[base + 39LLU] = 3979LLU/throw to this address/;
47004	47341	stack[base + 40LLU] = base;
47005		- stack[base + 41LLU] = 3941LLU;
	47342	+ stack[base + 41LLU] = 3980LLU;
47006	47343	// arguments for call to newvarraw
47007	47344	stack[base + 43LLU] = stack[base + 37]/elemtype/;
47008	47345	stack[base + 44LLU] = stack[base + 36]/elemid/;

		@@ -47018,16 +47355,16 @@
47018	47355	label = 755LLU; // newvarraw
47019	47356	break;
47020	47357	}
47021		- case 3940LLU: // copy-back deleter (newvarraw to procblock)
	47358	+ case 3979LLU: // copy-back deleter (newvarraw to procblock)
47022	47359	{
47023	47360	// copy mutable arguments back from call to newvarraw
47024	47361	stack[base + 3]/scope/ = stack[base + 50LLU];
47025	47362	stack[base + 18]/varcount/ = stack[base + 49LLU];
47026	47363	stack[base + 12]/fnmaxcount/ = stack[base + 48LLU];
47027		- label = 3937LLU; // continue to roll stack
	47364	+ label = 3976LLU; // continue to roll stack
47028	47365	break;
47029	47366	}
47030		- case 3941LLU: // return from newvarraw to procblock
	47367	+ case 3980LLU: // return from newvarraw to procblock
47031	47368	{
47032	47369	// copy mutable arguments back from call to newvarraw
47033	47370	stack[base + 3]/scope/ = stack[base + 50LLU];

		@@ -47037,9 +47374,9 @@
47037	47374	stack[base + 38] = stack[base + 42LLU];
47038	47375	printf("%s", "\n ");
47039	47376	// call emitvaridx from procblock
47040		- stack[base + 39LLU] = 3942LLU/throw to this address/;
	47377	+ stack[base + 39LLU] = 3981LLU/throw to this address/;
47041	47378	stack[base + 40LLU] = base;
47042		- stack[base + 41LLU] = 3943LLU;
	47379	+ stack[base + 41LLU] = 3982LLU;
47043	47380	// arguments for call to emitvaridx
47044	47381	stack[base + 42LLU] = stack[base + 38]/elemindex/;
47045	47382	// set stack-base & callee-address

		@@ -47047,20 +47384,20 @@
47047	47384	label = 741LLU; // emitvaridx
47048	47385	break;
47049	47386	}
47050		- case 3942LLU: // copy-back deleter (emitvaridx to procblock)
	47387	+ case 3981LLU: // copy-back deleter (emitvaridx to procblock)
47051	47388	{
47052	47389	// copy mutable arguments back from call to emitvaridx
47053		- label = 3938LLU; // continue to roll stack
	47390	+ label = 3977LLU; // continue to roll stack
47054	47391	break;
47055	47392	}
47056		- case 3943LLU: // return from emitvaridx to procblock
	47393	+ case 3982LLU: // return from emitvaridx to procblock
47057	47394	{
47058	47395	// copy mutable arguments back from call to emitvaridx
47059	47396	printf("%s", " = (uint64_t)(((const struct listnode *)(");
47060	47397	// call emitvaridx from procblock
47061		- stack[base + 39LLU] = 3944LLU/throw to this address/;
	47398	+ stack[base + 39LLU] = 3983LLU/throw to this address/;
47062	47399	stack[base + 40LLU] = base;
47063		- stack[base + 41LLU] = 3945LLU;
	47400	+ stack[base + 41LLU] = 3984LLU;
47064	47401	// arguments for call to emitvaridx
47065	47402	stack[base + 42LLU] = stack[base + 35]/listindex/;
47066	47403	// set stack-base & callee-address

		@@ -47068,20 +47405,20 @@
47068	47405	label = 741LLU; // emitvaridx
47069	47406	break;
47070	47407	}
47071		- case 3944LLU: // copy-back deleter (emitvaridx to procblock)
	47408	+ case 3983LLU: // copy-back deleter (emitvaridx to procblock)
47072	47409	{
47073	47410	// copy mutable arguments back from call to emitvaridx
47074		- label = 3938LLU; // continue to roll stack
	47411	+ label = 3977LLU; // continue to roll stack
47075	47412	break;
47076	47413	}
47077		- case 3945LLU: // return from emitvaridx to procblock
	47414	+ case 3984LLU: // return from emitvaridx to procblock
47078	47415	{
47079	47416	// copy mutable arguments back from call to emitvaridx
47080	47417	printf("%s", "))->data);");
47081	47418	// call matchsym from procblock
47082		- stack[base + 39LLU] = 3946LLU/throw to this address/;
	47419	+ stack[base + 39LLU] = 3985LLU/throw to this address/;
47083	47420	stack[base + 40LLU] = base;
47084		- stack[base + 41LLU] = 3947LLU;
	47421	+ stack[base + 41LLU] = 3986LLU;
47085	47422	// arguments for call to matchsym
47086	47423	stack[base + 42LLU] = stack[base + 8]/fnid/;
47087	47424	stack[base + 43LLU] = 41LLU;

		@@ -47091,21 +47428,21 @@
47091	47428	label = 222LLU; // matchsym
47092	47429	break;
47093	47430	}
47094		- case 3946LLU: // copy-back deleter (matchsym to procblock)
	47431	+ case 3985LLU: // copy-back deleter (matchsym to procblock)
47095	47432	{
47096	47433	// copy mutable arguments back from call to matchsym
47097	47434	stack[base + 19]/lookahead/ = stack[base + 44LLU];
47098		- label = 3938LLU; // continue to roll stack
	47435	+ label = 3977LLU; // continue to roll stack
47099	47436	break;
47100	47437	}
47101		- case 3947LLU: // return from matchsym to procblock
	47438	+ case 3986LLU: // return from matchsym to procblock
47102	47439	{
47103	47440	// copy mutable arguments back from call to matchsym
47104	47441	stack[base + 19]/lookahead/ = stack[base + 44LLU];
47105	47442	// call matchsym from procblock
47106		- stack[base + 39LLU] = 3948LLU/throw to this address/;
	47443	+ stack[base + 39LLU] = 3987LLU/throw to this address/;
47107	47444	stack[base + 40LLU] = base;
47108		- stack[base + 41LLU] = 3949LLU;
	47445	+ stack[base + 41LLU] = 3988LLU;
47109	47446	// arguments for call to matchsym
47110	47447	stack[base + 42LLU] = stack[base + 8]/fnid/;
47111	47448	stack[base + 43LLU] = 123LLU;

		@@ -47115,20 +47452,20 @@
47115	47452	label = 222LLU; // matchsym
47116	47453	break;
47117	47454	}
47118		- case 3948LLU: // copy-back deleter (matchsym to procblock)
	47455	+ case 3987LLU: // copy-back deleter (matchsym to procblock)
47119	47456	{
47120	47457	// copy mutable arguments back from call to matchsym
47121	47458	stack[base + 19]/lookahead/ = stack[base + 44LLU];
47122		- label = 3938LLU; // continue to roll stack
	47459	+ label = 3977LLU; // continue to roll stack
47123	47460	break;
47124	47461	}
47125		- case 3949LLU: // return from matchsym to procblock
	47462	+ case 3988LLU: // return from matchsym to procblock
47126	47463	{
47127	47464	// copy mutable arguments back from call to matchsym
47128	47465	stack[base + 19]/lookahead/ = stack[base + 44LLU];
47129	47466	if(!stack[base + 26]/consume/)
47130	47467	{
47131		- label = 3950LLU; // jump to alternative
	47468	+ label = 3989LLU; // jump to alternative
47132	47469	break;
47133	47470	}
47134	47471

		@@ -47136,9 +47473,9 @@
47136	47473	printf("%s", "\n {");
47137	47474	printf("%s", "\n struct listnode list = (struct listnode )(");
47138	47475	// call emitvaridx from procblock
47139		- stack[base + 39LLU] = 3952LLU/throw to this address/;
	47476	+ stack[base + 39LLU] = 3991LLU/throw to this address/;
47140	47477	stack[base + 40LLU] = base;
47141		- stack[base + 41LLU] = 3953LLU;
	47478	+ stack[base + 41LLU] = 3992LLU;
47142	47479	// arguments for call to emitvaridx
47143	47480	stack[base + 42LLU] = stack[base + 35]/listindex/;
47144	47481	// set stack-base & callee-address

		@@ -47146,21 +47483,21 @@
47146	47483	label = 741LLU; // emitvaridx
47147	47484	break;
47148	47485	}
47149		- case 3952LLU: // copy-back deleter (emitvaridx to procblock)
	47486	+ case 3991LLU: // copy-back deleter (emitvaridx to procblock)
47150	47487	{
47151	47488	// copy mutable arguments back from call to emitvaridx
47152		- label = 3938LLU; // continue to roll stack
	47489	+ label = 3977LLU; // continue to roll stack
47153	47490	break;
47154	47491	}
47155		- case 3953LLU: // return from emitvaridx to procblock
	47492	+ case 3992LLU: // return from emitvaridx to procblock
47156	47493	{
47157	47494	// copy mutable arguments back from call to emitvaridx
47158	47495	printf("%s", ");");
47159	47496	printf("%s", "\n ");
47160	47497	// call emitvaridx from procblock
47161		- stack[base + 39LLU] = 3954LLU/throw to this address/;
	47498	+ stack[base + 39LLU] = 3993LLU/throw to this address/;
47162	47499	stack[base + 40LLU] = base;
47163		- stack[base + 41LLU] = 3955LLU;
	47500	+ stack[base + 41LLU] = 3994LLU;
47164	47501	// arguments for call to emitvaridx
47165	47502	stack[base + 42LLU] = stack[base + 35]/listindex/;
47166	47503	// set stack-base & callee-address

		@@ -47168,38 +47505,38 @@
47168	47505	label = 741LLU; // emitvaridx
47169	47506	break;
47170	47507	}
47171		- case 3954LLU: // copy-back deleter (emitvaridx to procblock)
	47508	+ case 3993LLU: // copy-back deleter (emitvaridx to procblock)
47172	47509	{
47173	47510	// copy mutable arguments back from call to emitvaridx
47174		- label = 3938LLU; // continue to roll stack
	47511	+ label = 3977LLU; // continue to roll stack
47175	47512	break;
47176	47513	}
47177		- case 3955LLU: // return from emitvaridx to procblock
	47514	+ case 3994LLU: // return from emitvaridx to procblock
47178	47515	{
47179	47516	// copy mutable arguments back from call to emitvaridx
47180	47517	printf("%s", " = (uint64_t)list->next;");
47181	47518	printf("%s", "\n Free(1, sizeof(struct listnode), list);");
47182	47519	printf("%s", "\n }");
47183		- label = 3957LLU; // skip deleter
	47520	+ label = 3996LLU; // skip deleter
47184	47521	break;
47185	47522	}
47186		- case 3956LLU: // deleter
	47523	+ case 3995LLU: // deleter
47187	47524	{
47188	47525	// throw from procblock
47189	47526	if(!stack[base + 39])
47190	47527	{
47191		- label = 3938LLU; // skip, variable already deleted/unscoped
	47528	+ label = 3977LLU; // skip, variable already deleted/unscoped
47192	47529	break;
47193	47530	}
47194	47531	// delete list
47195		- label = 3958LLU; // start to repeat
	47532	+ label = 3997LLU; // start to repeat
47196	47533	break;
47197	47534	}
47198		- case 3958LLU: // repeat from here
	47535	+ case 3997LLU: // repeat from here
47199	47536	{
47200	47537	if(!stack[base + 39])
47201	47538	{
47202		- label = 3959LLU; // break loop
	47539	+ label = 3998LLU; // break loop
47203	47540	break;
47204	47541	}
47205	47542

		@@ -47210,7 +47547,7 @@
47210	47547	newstack[0] = (uint64_t)stack; // backup stack location
47211	47548	newstack[1] = 1234567890;
47212	47549	newstack[2] = base;
47213		- newstack[3] = 3960LLU;
	47550	+ newstack[3] = 3999LLU;
47214	47551	stack = newstack;
47215	47552	// set stack-base & callee-address
47216	47553	base = 4/deloffset/;

		@@ -47217,7 +47554,7 @@
47217	47554	label = 395LLU; // ~typeidx
47218	47555	break;
47219	47556	}
47220		- case 3960LLU: // return from ~typeidx to procblock
	47557	+ case 3999LLU: // return from ~typeidx to procblock
47221	47558	{
47222	47559	stack = (uint64_t *)stack[0];
47223	47560	// releasing toplevel container

		@@ -47228,21 +47565,21 @@
47228	47565	stack[base + 39] = (uint64_t)list->next;
47229	47566	Free(1, sizeof(struct listnode), list);
47230	47567	}
47231		- label = 3958LLU; // repeat
	47568	+ label = 3997LLU; // repeat
47232	47569	break;
47233	47570	}
47234		- case 3959LLU: // loop finished
	47571	+ case 3998LLU: // loop finished
47235	47572	{
47236		- label = 3938LLU; // continue unrolling stack, delete next variable
	47573	+ label = 3977LLU; // continue unrolling stack, delete next variable
47237	47574	break;
47238	47575	}
47239		- case 3957LLU: // skipped deleter
	47576	+ case 3996LLU: // skipped deleter
47240	47577	{
47241	47578	stack[base + 39] = 0;
47242	47579	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
47243	47580	if(!newstack)
47244	47581	{
47245		- label = 3956LLU; // throw: begin to unroll stack
	47582	+ label = 3995LLU; // throw: begin to unroll stack
47246	47583	break;
47247	47584	}
47248	47585

		@@ -47249,9 +47586,9 @@
47249	47586	newstack[160LLU] = 9876543210LLU; // overflow-marker
47250	47587	// call procblock from procblock
47251	47588	newstack[0] = (uint64_t)stack; // backup stack location
47252		- newstack[1] = 3961LLU;
	47589	+ newstack[1] = 4000LLU;
47253	47590	newstack[2] = base;
47254		- newstack[3] = 3962LLU;
	47591	+ newstack[3] = 4001LLU;
47255	47592	// arguments for call to procblock
47256	47593	newstack[4LLU] = stack[base + 0]/fndefs/;
47257	47594	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -47277,7 +47614,7 @@
47277	47614	label = 3319LLU; // procblock
47278	47615	break;
47279	47616	}
47280		- case 3961LLU: // copy-back deleter (procblock to procblock)
	47617	+ case 4000LLU: // copy-back deleter (procblock to procblock)
47281	47618	{
47282	47619	uint64_t oldstack = (uint64_t )stack[0];
47283	47620	// copy mutable arguments back from call to procblock

		@@ -47294,10 +47631,10 @@
47294	47631	}
47295	47632	Free(160LLU + 1, sizeof(uint64_t), stack);
47296	47633	stack = oldstack;
47297		- label = 3956LLU; // continue to unroll stack
	47634	+ label = 3995LLU; // continue to unroll stack
47298	47635	break;
47299	47636	}
47300		- case 3962LLU: // return from procblock to procblock
	47637	+ case 4001LLU: // return from procblock to procblock
47301	47638	{
47302	47639	uint64_t oldstack = (uint64_t )stack[0];
47303	47640	// copy mutable arguments back from call to procblock

		@@ -47315,14 +47652,14 @@
47315	47652	Free(160LLU + 1, sizeof(uint64_t), stack);
47316	47653	stack = oldstack;
47317	47654	// delete list
47318		- label = 3963LLU; // start to repeat
	47655	+ label = 4002LLU; // start to repeat
47319	47656	break;
47320	47657	}
47321		- case 3963LLU: // repeat from here
	47658	+ case 4002LLU: // repeat from here
47322	47659	{
47323	47660	if(!stack[base + 39])
47324	47661	{
47325		- label = 3964LLU; // break loop
	47662	+ label = 4003LLU; // break loop
47326	47663	break;
47327	47664	}
47328	47665

		@@ -47333,7 +47670,7 @@
47333	47670	newstack[0] = (uint64_t)stack; // backup stack location
47334	47671	newstack[1] = 1234567890;
47335	47672	newstack[2] = base;
47336		- newstack[3] = 3965LLU;
	47673	+ newstack[3] = 4004LLU;
47337	47674	stack = newstack;
47338	47675	// set stack-base & callee-address
47339	47676	base = 4/deloffset/;

		@@ -47340,7 +47677,7 @@
47340	47677	label = 395LLU; // ~typeidx
47341	47678	break;
47342	47679	}
47343		- case 3965LLU: // return from ~typeidx to procblock
	47680	+ case 4004LLU: // return from ~typeidx to procblock
47344	47681	{
47345	47682	stack = (uint64_t *)stack[0];
47346	47683	// releasing toplevel container

		@@ -47351,15 +47688,15 @@
47351	47688	stack[base + 39] = (uint64_t)list->next;
47352	47689	Free(1, sizeof(struct listnode), list);
47353	47690	}
47354		- label = 3963LLU; // repeat
	47691	+ label = 4002LLU; // repeat
47355	47692	break;
47356	47693	}
47357		- case 3964LLU: // loop finished
	47694	+ case 4003LLU: // loop finished
47358	47695	{
47359	47696	uint64_t newstack = (uint64_t )Calloc(75LLU + 1, sizeof(uint64_t));
47360	47697	if(!newstack)
47361	47698	{
47362		- label = 3938LLU; // throw: begin to unroll stack
	47699	+ label = 3977LLU; // throw: begin to unroll stack
47363	47700	break;
47364	47701	}
47365	47702

		@@ -47366,9 +47703,9 @@
47366	47703	newstack[75LLU] = 9876543210LLU; // overflow-marker
47367	47704	// call calldestr from procblock
47368	47705	newstack[0] = (uint64_t)stack; // backup stack location
47369		- newstack[1] = 3966LLU;
	47706	+ newstack[1] = 4005LLU;
47370	47707	newstack[2] = base;
47371		- newstack[3] = 3967LLU;
	47708	+ newstack[3] = 4006LLU;
47372	47709	// arguments for call to calldestr
47373	47710	newstack[4LLU] = stack[base + 8]/fnid/;
47374	47711	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -47382,7 +47719,7 @@
47382	47719	label = 1179LLU; // calldestr
47383	47720	break;
47384	47721	}
47385		- case 3966LLU: // copy-back deleter (calldestr to procblock)
	47722	+ case 4005LLU: // copy-back deleter (calldestr to procblock)
47386	47723	{
47387	47724	uint64_t oldstack = (uint64_t )stack[0];
47388	47725	// copy mutable arguments back from call to calldestr

		@@ -47394,10 +47731,10 @@
47394	47731	}
47395	47732	Free(75LLU + 1, sizeof(uint64_t), stack);
47396	47733	stack = oldstack;
47397		- label = 3938LLU; // continue to unroll stack
	47734	+ label = 3977LLU; // continue to unroll stack
47398	47735	break;
47399	47736	}
47400		- case 3967LLU: // return from calldestr to procblock
	47737	+ case 4006LLU: // return from calldestr to procblock
47401	47738	{
47402	47739	uint64_t oldstack = (uint64_t )stack[0];
47403	47740	// copy mutable arguments back from call to calldestr

		@@ -47411,9 +47748,9 @@
47411	47748	stack = oldstack;
47412	47749	printf("%s", "\n label = ");
47413	47750	// call printnr from procblock
47414		- stack[base + 39LLU] = 3968LLU/throw to this address/;
	47751	+ stack[base + 39LLU] = 4007LLU/throw to this address/;
47415	47752	stack[base + 40LLU] = base;
47416		- stack[base + 41LLU] = 3969LLU;
	47753	+ stack[base + 41LLU] = 4008LLU;
47417	47754	// arguments for call to printnr
47418	47755	stack[base + 42LLU] = stack[base + 22]/labelloop/;
47419	47756	// set stack-base & callee-address

		@@ -47421,13 +47758,13 @@
47421	47758	label = 18446744073709551590LLU; // printnr
47422	47759	break;
47423	47760	}
47424		- case 3968LLU: // copy-back deleter (printnr to procblock)
	47761	+ case 4007LLU: // copy-back deleter (printnr to procblock)
47425	47762	{
47426	47763	// copy mutable arguments back from call to printnr
47427		- label = 3938LLU; // continue to roll stack
	47764	+ label = 3977LLU; // continue to roll stack
47428	47765	break;
47429	47766	}
47430		- case 3969LLU: // return from printnr to procblock
	47767	+ case 4008LLU: // return from printnr to procblock
47431	47768	{
47432	47769	// copy mutable arguments back from call to printnr
47433	47770	printf("%s", "LLU; // repeat");

		@@ -47435,9 +47772,9 @@
47435	47772	printf("%s", "\n }");
47436	47773	printf("%s", "\n case ");
47437	47774	// call printnr from procblock
47438		- stack[base + 39LLU] = 3970LLU/throw to this address/;
	47775	+ stack[base + 39LLU] = 4009LLU/throw to this address/;
47439	47776	stack[base + 40LLU] = base;
47440		- stack[base + 41LLU] = 3971LLU;
	47777	+ stack[base + 41LLU] = 4010LLU;
47441	47778	// arguments for call to printnr
47442	47779	stack[base + 42LLU] = stack[base + 23]/labelskip/;
47443	47780	// set stack-base & callee-address

		@@ -47445,42 +47782,42 @@
47445	47782	label = 18446744073709551590LLU; // printnr
47446	47783	break;
47447	47784	}
47448		- case 3970LLU: // copy-back deleter (printnr to procblock)
	47785	+ case 4009LLU: // copy-back deleter (printnr to procblock)
47449	47786	{
47450	47787	// copy mutable arguments back from call to printnr
47451		- label = 3938LLU; // continue to roll stack
	47788	+ label = 3977LLU; // continue to roll stack
47452	47789	break;
47453	47790	}
47454		- case 3971LLU: // return from printnr to procblock
	47791	+ case 4010LLU: // return from printnr to procblock
47455	47792	{
47456	47793	// copy mutable arguments back from call to printnr
47457	47794	printf("%s", "LLU: // loop finished");
47458	47795	printf("%s", "\n {");
47459		- label = 3951LLU; // consequent complete
	47796	+ label = 3990LLU; // consequent complete
47460	47797	break;
47461	47798	}
47462		- case 3950LLU: // alternative
	47799	+ case 3989LLU: // alternative
47463	47800	{
47464		- label = 3973LLU; // skip deleter
	47801	+ label = 4012LLU; // skip deleter
47465	47802	break;
47466	47803	}
47467		- case 3972LLU: // deleter
	47804	+ case 4011LLU: // deleter
47468	47805	{
47469	47806	// throw from procblock
47470	47807	if(!stack[base + 39])
47471	47808	{
47472		- label = 3938LLU; // skip, variable already deleted/unscoped
	47809	+ label = 3977LLU; // skip, variable already deleted/unscoped
47473	47810	break;
47474	47811	}
47475		- label = 3938LLU; // continue unrolling stack, delete next variable
	47812	+ label = 3977LLU; // continue unrolling stack, delete next variable
47476	47813	break;
47477	47814	}
47478		- case 3973LLU: // skipped deleter
	47815	+ case 4012LLU: // skipped deleter
47479	47816	{
47480	47817	// call newvarraw from procblock
47481		- stack[base + 40LLU] = 3974LLU/throw to this address/;
	47818	+ stack[base + 40LLU] = 4013LLU/throw to this address/;
47482	47819	stack[base + 41LLU] = base;
47483		- stack[base + 42LLU] = 3975LLU;
	47820	+ stack[base + 42LLU] = 4014LLU;
47484	47821	// arguments for call to newvarraw
47485	47822	stack[base + 44LLU] = stack[base + 29]/listtype/;
47486	47823	stack[base + 45LLU] = 0LLU;

		@@ -47496,16 +47833,16 @@
47496	47833	label = 755LLU; // newvarraw
47497	47834	break;
47498	47835	}
47499		- case 3974LLU: // copy-back deleter (newvarraw to procblock)
	47836	+ case 4013LLU: // copy-back deleter (newvarraw to procblock)
47500	47837	{
47501	47838	// copy mutable arguments back from call to newvarraw
47502	47839	stack[base + 3]/scope/ = stack[base + 51LLU];
47503	47840	stack[base + 18]/varcount/ = stack[base + 50LLU];
47504	47841	stack[base + 12]/fnmaxcount/ = stack[base + 49LLU];
47505		- label = 3938LLU; // continue to roll stack
	47842	+ label = 3977LLU; // continue to roll stack
47506	47843	break;
47507	47844	}
47508		- case 3975LLU: // return from newvarraw to procblock
	47845	+ case 4014LLU: // return from newvarraw to procblock
47509	47846	{
47510	47847	// copy mutable arguments back from call to newvarraw
47511	47848	stack[base + 3]/scope/ = stack[base + 51LLU];

		@@ -47515,9 +47852,9 @@
47515	47852	stack[base + 39] = stack[base + 43LLU];
47516	47853	printf("%s", "\n ");
47517	47854	// call emitvaridx from procblock
47518		- stack[base + 40LLU] = 3976LLU/throw to this address/;
	47855	+ stack[base + 40LLU] = 4015LLU/throw to this address/;
47519	47856	stack[base + 41LLU] = base;
47520		- stack[base + 42LLU] = 3977LLU;
	47857	+ stack[base + 42LLU] = 4016LLU;
47521	47858	// arguments for call to emitvaridx
47522	47859	stack[base + 43LLU] = stack[base + 39]/previdx/;
47523	47860	// set stack-base & callee-address

		@@ -47525,20 +47862,20 @@
47525	47862	label = 741LLU; // emitvaridx
47526	47863	break;
47527	47864	}
47528		- case 3976LLU: // copy-back deleter (emitvaridx to procblock)
	47865	+ case 4015LLU: // copy-back deleter (emitvaridx to procblock)
47529	47866	{
47530	47867	// copy mutable arguments back from call to emitvaridx
47531		- label = 3972LLU; // continue to roll stack
	47868	+ label = 4011LLU; // continue to roll stack
47532	47869	break;
47533	47870	}
47534		- case 3977LLU: // return from emitvaridx to procblock
	47871	+ case 4016LLU: // return from emitvaridx to procblock
47535	47872	{
47536	47873	// copy mutable arguments back from call to emitvaridx
47537	47874	printf("%s", "/previous/ = ");
47538	47875	// call emitvaridx from procblock
47539		- stack[base + 40LLU] = 3978LLU/throw to this address/;
	47876	+ stack[base + 40LLU] = 4017LLU/throw to this address/;
47540	47877	stack[base + 41LLU] = base;
47541		- stack[base + 42LLU] = 3979LLU;
	47878	+ stack[base + 42LLU] = 4018LLU;
47542	47879	// arguments for call to emitvaridx
47543	47880	stack[base + 43LLU] = stack[base + 35]/listindex/;
47544	47881	// set stack-base & callee-address

		@@ -47546,21 +47883,21 @@
47546	47883	label = 741LLU; // emitvaridx
47547	47884	break;
47548	47885	}
47549		- case 3978LLU: // copy-back deleter (emitvaridx to procblock)
	47886	+ case 4017LLU: // copy-back deleter (emitvaridx to procblock)
47550	47887	{
47551	47888	// copy mutable arguments back from call to emitvaridx
47552		- label = 3972LLU; // continue to roll stack
	47889	+ label = 4011LLU; // continue to roll stack
47553	47890	break;
47554	47891	}
47555		- case 3979LLU: // return from emitvaridx to procblock
	47892	+ case 4018LLU: // return from emitvaridx to procblock
47556	47893	{
47557	47894	// copy mutable arguments back from call to emitvaridx
47558	47895	printf("%s", ";");
47559	47896	printf("%s", "\n ");
47560	47897	// call emitvaridx from procblock
47561		- stack[base + 40LLU] = 3980LLU/throw to this address/;
	47898	+ stack[base + 40LLU] = 4019LLU/throw to this address/;
47562	47899	stack[base + 41LLU] = base;
47563		- stack[base + 42LLU] = 3981LLU;
	47900	+ stack[base + 42LLU] = 4020LLU;
47564	47901	// arguments for call to emitvaridx
47565	47902	stack[base + 43LLU] = stack[base + 35]/listindex/;
47566	47903	// set stack-base & callee-address

		@@ -47568,20 +47905,20 @@
47568	47905	label = 741LLU; // emitvaridx
47569	47906	break;
47570	47907	}
47571		- case 3980LLU: // copy-back deleter (emitvaridx to procblock)
	47908	+ case 4019LLU: // copy-back deleter (emitvaridx to procblock)
47572	47909	{
47573	47910	// copy mutable arguments back from call to emitvaridx
47574		- label = 3972LLU; // continue to roll stack
	47911	+ label = 4011LLU; // continue to roll stack
47575	47912	break;
47576	47913	}
47577		- case 3981LLU: // return from emitvaridx to procblock
	47914	+ case 4020LLU: // return from emitvaridx to procblock
47578	47915	{
47579	47916	// copy mutable arguments back from call to emitvaridx
47580	47917	printf("%s", " = (uint64_t)(((const struct listnode *)(");
47581	47918	// call emitvaridx from procblock
47582		- stack[base + 40LLU] = 3982LLU/throw to this address/;
	47919	+ stack[base + 40LLU] = 4021LLU/throw to this address/;
47583	47920	stack[base + 41LLU] = base;
47584		- stack[base + 42LLU] = 3983LLU;
	47921	+ stack[base + 42LLU] = 4022LLU;
47585	47922	// arguments for call to emitvaridx
47586	47923	stack[base + 43LLU] = stack[base + 35]/listindex/;
47587	47924	// set stack-base & callee-address

		@@ -47589,36 +47926,36 @@
47589	47926	label = 741LLU; // emitvaridx
47590	47927	break;
47591	47928	}
47592		- case 3982LLU: // copy-back deleter (emitvaridx to procblock)
	47929	+ case 4021LLU: // copy-back deleter (emitvaridx to procblock)
47593	47930	{
47594	47931	// copy mutable arguments back from call to emitvaridx
47595		- label = 3972LLU; // continue to roll stack
	47932	+ label = 4011LLU; // continue to roll stack
47596	47933	break;
47597	47934	}
47598		- case 3983LLU: // return from emitvaridx to procblock
	47935	+ case 4022LLU: // return from emitvaridx to procblock
47599	47936	{
47600	47937	// copy mutable arguments back from call to emitvaridx
47601	47938	printf("%s", "))->next);");
47602		- label = 3985LLU; // skip deleter
	47939	+ label = 4024LLU; // skip deleter
47603	47940	break;
47604	47941	}
47605		- case 3984LLU: // deleter
	47942	+ case 4023LLU: // deleter
47606	47943	{
47607	47944	// throw from procblock
47608	47945	if(!stack[base + 40])
47609	47946	{
47610		- label = 3972LLU; // skip, variable already deleted/unscoped
	47947	+ label = 4011LLU; // skip, variable already deleted/unscoped
47611	47948	break;
47612	47949	}
47613		- label = 3972LLU; // continue unrolling stack, delete next variable
	47950	+ label = 4011LLU; // continue unrolling stack, delete next variable
47614	47951	break;
47615	47952	}
47616		- case 3985LLU: // skipped deleter
	47953	+ case 4024LLU: // skipped deleter
47617	47954	{
47618	47955	// call getdeladdr from procblock
47619		- stack[base + 41LLU] = 3986LLU/throw to this address/;
	47956	+ stack[base + 41LLU] = 4025LLU/throw to this address/;
47620	47957	stack[base + 42LLU] = base;
47621		- stack[base + 43LLU] = 3987LLU;
	47958	+ stack[base + 43LLU] = 4026LLU;
47622	47959	// arguments for call to getdeladdr
47623	47960	stack[base + 45LLU] = stack[base + 3]/scope/;
47624	47961	// set stack-base & callee-address

		@@ -47626,21 +47963,21 @@
47626	47963	label = 592LLU; // getdeladdr
47627	47964	break;
47628	47965	}
47629		- case 3986LLU: // copy-back deleter (getdeladdr to procblock)
	47966	+ case 4025LLU: // copy-back deleter (getdeladdr to procblock)
47630	47967	{
47631	47968	// copy mutable arguments back from call to getdeladdr
47632		- label = 3972LLU; // continue to roll stack
	47969	+ label = 4011LLU; // continue to roll stack
47633	47970	break;
47634	47971	}
47635		- case 3987LLU: // return from getdeladdr to procblock
	47972	+ case 4026LLU: // return from getdeladdr to procblock
47636	47973	{
47637	47974	// copy mutable arguments back from call to getdeladdr
47638	47975	// copy back results provided by call to getdeladdr
47639	47976	stack[base + 40] = stack[base + 44LLU];
47640	47977	// call add from procblock
47641		- stack[base + 41LLU] = 3988LLU/throw to this address/;
	47978	+ stack[base + 41LLU] = 4027LLU/throw to this address/;
47642	47979	stack[base + 42LLU] = base;
47643		- stack[base + 43LLU] = 3989LLU;
	47980	+ stack[base + 43LLU] = 4028LLU;
47644	47981	// arguments for call to add
47645	47982	stack[base + 45LLU] = 1LLU;
47646	47983	stack[base + 46LLU] = stack[base + 17]/label/;

		@@ -47649,37 +47986,37 @@
47649	47986	label = 18446744073709551605LLU; // add
47650	47987	break;
47651	47988	}
47652		- case 3988LLU: // copy-back deleter (add to procblock)
	47989	+ case 4027LLU: // copy-back deleter (add to procblock)
47653	47990	{
47654	47991	// copy mutable arguments back from call to add
47655		- label = 3984LLU; // continue to roll stack
	47992	+ label = 4023LLU; // continue to roll stack
47656	47993	break;
47657	47994	}
47658		- case 3989LLU: // return from add to procblock
	47995	+ case 4028LLU: // return from add to procblock
47659	47996	{
47660	47997	// copy mutable arguments back from call to add
47661	47998	// copy back results provided by call to add
47662	47999	stack[base + 17] = stack[base + 44LLU];
47663		- label = 3991LLU; // skip deleter
	48000	+ label = 4030LLU; // skip deleter
47664	48001	break;
47665	48002	}
47666		- case 3990LLU: // deleter
	48003	+ case 4029LLU: // deleter
47667	48004	{
47668	48005	// throw from procblock
47669	48006	if(!stack[base + 41])
47670	48007	{
47671		- label = 3984LLU; // skip, variable already deleted/unscoped
	48008	+ label = 4023LLU; // skip, variable already deleted/unscoped
47672	48009	break;
47673	48010	}
47674		- label = 3984LLU; // continue unrolling stack, delete next variable
	48011	+ label = 4023LLU; // continue unrolling stack, delete next variable
47675	48012	break;
47676	48013	}
47677		- case 3991LLU: // skipped deleter
	48014	+ case 4030LLU: // skipped deleter
47678	48015	{
47679	48016	stack[base + 41] = stack[base + 17]/label/;
47680	48017	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
47681	48018	{
47682		- label = 3993LLU; // jump to alternative
	48019	+ label = 4032LLU; // jump to alternative
47683	48020	break;
47684	48021	}
47685	48022

		@@ -47690,43 +48027,43 @@
47690	48027	stack[base + 42]/deleteaddr/ = stack[base + 41]/labelfail/;
47691	48028	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 43];
47692	48029	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 42];
47693		- label = 3992LLU; // case complete
	48030	+ label = 4031LLU; // case complete
47694	48031	break;
47695	48032	}
47696		- case 3994LLU: // copy-back deleter (switch)
	48033	+ case 4033LLU: // copy-back deleter (switch)
47697	48034	{
47698	48035	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 43];
47699	48036	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 42];
47700		- label = 3990LLU; // continue to unroll stack
	48037	+ label = 4029LLU; // continue to unroll stack
47701	48038	break;
47702	48039	}
47703		- case 3993LLU: // try next case
	48040	+ case 4032LLU: // try next case
47704	48041	{
47705	48042	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
47706	48043	exit(-1);
47707	48044	}
47708		- case 3992LLU: // completed switch
	48045	+ case 4031LLU: // completed switch
47709	48046	{
47710		- label = 3996LLU; // skip deleter
	48047	+ label = 4035LLU; // skip deleter
47711	48048	break;
47712	48049	}
47713		- case 3995LLU: // deleter
	48050	+ case 4034LLU: // deleter
47714	48051	{
47715	48052	// throw from procblock
47716	48053	if(!stack[base + 42])
47717	48054	{
47718		- label = 3990LLU; // skip, variable already deleted/unscoped
	48055	+ label = 4029LLU; // skip, variable already deleted/unscoped
47719	48056	break;
47720	48057	}
47721	48058	// delete list
47722		- label = 3997LLU; // start to repeat
	48059	+ label = 4036LLU; // start to repeat
47723	48060	break;
47724	48061	}
47725		- case 3997LLU: // repeat from here
	48062	+ case 4036LLU: // repeat from here
47726	48063	{
47727	48064	if(!stack[base + 42])
47728	48065	{
47729		- label = 3998LLU; // break loop
	48066	+ label = 4037LLU; // break loop
47730	48067	break;
47731	48068	}
47732	48069

		@@ -47737,7 +48074,7 @@
47737	48074	newstack[0] = (uint64_t)stack; // backup stack location
47738	48075	newstack[1] = 1234567890;
47739	48076	newstack[2] = base;
47740		- newstack[3] = 3999LLU;
	48077	+ newstack[3] = 4038LLU;
47741	48078	stack = newstack;
47742	48079	// set stack-base & callee-address
47743	48080	base = 4/deloffset/;

		@@ -47744,7 +48081,7 @@
47744	48081	label = 395LLU; // ~typeidx
47745	48082	break;
47746	48083	}
47747		- case 3999LLU: // return from ~typeidx to procblock
	48084	+ case 4038LLU: // return from ~typeidx to procblock
47748	48085	{
47749	48086	stack = (uint64_t *)stack[0];
47750	48087	// releasing toplevel container

		@@ -47755,21 +48092,21 @@
47755	48092	stack[base + 42] = (uint64_t)list->next;
47756	48093	Free(1, sizeof(struct listnode), list);
47757	48094	}
47758		- label = 3997LLU; // repeat
	48095	+ label = 4036LLU; // repeat
47759	48096	break;
47760	48097	}
47761		- case 3998LLU: // loop finished
	48098	+ case 4037LLU: // loop finished
47762	48099	{
47763		- label = 3990LLU; // continue unrolling stack, delete next variable
	48100	+ label = 4029LLU; // continue unrolling stack, delete next variable
47764	48101	break;
47765	48102	}
47766		- case 3996LLU: // skipped deleter
	48103	+ case 4035LLU: // skipped deleter
47767	48104	{
47768	48105	stack[base + 42] = 0;
47769	48106	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
47770	48107	if(!newstack)
47771	48108	{
47772		- label = 3995LLU; // throw: begin to unroll stack
	48109	+ label = 4034LLU; // throw: begin to unroll stack
47773	48110	break;
47774	48111	}
47775	48112

		@@ -47776,9 +48113,9 @@
47776	48113	newstack[160LLU] = 9876543210LLU; // overflow-marker
47777	48114	// call procblock from procblock
47778	48115	newstack[0] = (uint64_t)stack; // backup stack location
47779		- newstack[1] = 4000LLU;
	48116	+ newstack[1] = 4039LLU;
47780	48117	newstack[2] = base;
47781		- newstack[3] = 4001LLU;
	48118	+ newstack[3] = 4040LLU;
47782	48119	// arguments for call to procblock
47783	48120	newstack[4LLU] = stack[base + 0]/fndefs/;
47784	48121	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -47804,7 +48141,7 @@
47804	48141	label = 3319LLU; // procblock
47805	48142	break;
47806	48143	}
47807		- case 4000LLU: // copy-back deleter (procblock to procblock)
	48144	+ case 4039LLU: // copy-back deleter (procblock to procblock)
47808	48145	{
47809	48146	uint64_t oldstack = (uint64_t )stack[0];
47810	48147	// copy mutable arguments back from call to procblock

		@@ -47821,10 +48158,10 @@
47821	48158	}
47822	48159	Free(160LLU + 1, sizeof(uint64_t), stack);
47823	48160	stack = oldstack;
47824		- label = 3995LLU; // continue to unroll stack
	48161	+ label = 4034LLU; // continue to unroll stack
47825	48162	break;
47826	48163	}
47827		- case 4001LLU: // return from procblock to procblock
	48164	+ case 4040LLU: // return from procblock to procblock
47828	48165	{
47829	48166	uint64_t oldstack = (uint64_t )stack[0];
47830	48167	// copy mutable arguments back from call to procblock

		@@ -47842,14 +48179,14 @@
47842	48179	Free(160LLU + 1, sizeof(uint64_t), stack);
47843	48180	stack = oldstack;
47844	48181	// delete list
47845		- label = 4002LLU; // start to repeat
	48182	+ label = 4041LLU; // start to repeat
47846	48183	break;
47847	48184	}
47848		- case 4002LLU: // repeat from here
	48185	+ case 4041LLU: // repeat from here
47849	48186	{
47850	48187	if(!stack[base + 42])
47851	48188	{
47852		- label = 4003LLU; // break loop
	48189	+ label = 4042LLU; // break loop
47853	48190	break;
47854	48191	}
47855	48192

		@@ -47860,7 +48197,7 @@
47860	48197	newstack[0] = (uint64_t)stack; // backup stack location
47861	48198	newstack[1] = 1234567890;
47862	48199	newstack[2] = base;
47863		- newstack[3] = 4004LLU;
	48200	+ newstack[3] = 4043LLU;
47864	48201	stack = newstack;
47865	48202	// set stack-base & callee-address
47866	48203	base = 4/deloffset/;

		@@ -47867,7 +48204,7 @@
47867	48204	label = 395LLU; // ~typeidx
47868	48205	break;
47869	48206	}
47870		- case 4004LLU: // return from ~typeidx to procblock
	48207	+ case 4043LLU: // return from ~typeidx to procblock
47871	48208	{
47872	48209	stack = (uint64_t *)stack[0];
47873	48210	// releasing toplevel container

		@@ -47878,16 +48215,16 @@
47878	48215	stack[base + 42] = (uint64_t)list->next;
47879	48216	Free(1, sizeof(struct listnode), list);
47880	48217	}
47881		- label = 4002LLU; // repeat
	48218	+ label = 4041LLU; // repeat
47882	48219	break;
47883	48220	}
47884		- case 4003LLU: // loop finished
	48221	+ case 4042LLU: // loop finished
47885	48222	{
47886	48223	printf("%s", "\n ((struct listnode *)(");
47887	48224	// call emitvaridx from procblock
47888		- stack[base + 42LLU] = 4005LLU/throw to this address/;
	48225	+ stack[base + 42LLU] = 4044LLU/throw to this address/;
47889	48226	stack[base + 43LLU] = base;
47890		- stack[base + 44LLU] = 4006LLU;
	48227	+ stack[base + 44LLU] = 4045LLU;
47891	48228	// arguments for call to emitvaridx
47892	48229	stack[base + 45LLU] = stack[base + 39]/previdx/;
47893	48230	// set stack-base & callee-address

		@@ -47895,20 +48232,20 @@
47895	48232	label = 741LLU; // emitvaridx
47896	48233	break;
47897	48234	}
47898		- case 4005LLU: // copy-back deleter (emitvaridx to procblock)
	48235	+ case 4044LLU: // copy-back deleter (emitvaridx to procblock)
47899	48236	{
47900	48237	// copy mutable arguments back from call to emitvaridx
47901		- label = 3990LLU; // continue to roll stack
	48238	+ label = 4029LLU; // continue to roll stack
47902	48239	break;
47903	48240	}
47904		- case 4006LLU: // return from emitvaridx to procblock
	48241	+ case 4045LLU: // return from emitvaridx to procblock
47905	48242	{
47906	48243	// copy mutable arguments back from call to emitvaridx
47907	48244	printf("%s", "/previous/))->data = ");
47908	48245	// call emitvaridx from procblock
47909		- stack[base + 42LLU] = 4007LLU/throw to this address/;
	48246	+ stack[base + 42LLU] = 4046LLU/throw to this address/;
47910	48247	stack[base + 43LLU] = base;
47911		- stack[base + 44LLU] = 4008LLU;
	48248	+ stack[base + 44LLU] = 4047LLU;
47912	48249	// arguments for call to emitvaridx
47913	48250	stack[base + 45LLU] = stack[base + 38]/elemindex/;
47914	48251	// set stack-base & callee-address

		@@ -47916,21 +48253,21 @@
47916	48253	label = 741LLU; // emitvaridx
47917	48254	break;
47918	48255	}
47919		- case 4007LLU: // copy-back deleter (emitvaridx to procblock)
	48256	+ case 4046LLU: // copy-back deleter (emitvaridx to procblock)
47920	48257	{
47921	48258	// copy mutable arguments back from call to emitvaridx
47922		- label = 3990LLU; // continue to roll stack
	48259	+ label = 4029LLU; // continue to roll stack
47923	48260	break;
47924	48261	}
47925		- case 4008LLU: // return from emitvaridx to procblock
	48262	+ case 4047LLU: // return from emitvaridx to procblock
47926	48263	{
47927	48264	// copy mutable arguments back from call to emitvaridx
47928	48265	printf("%s", ";");
47929	48266	printf("%s", "\n label = ");
47930	48267	// call printnr from procblock
47931		- stack[base + 42LLU] = 4009LLU/throw to this address/;
	48268	+ stack[base + 42LLU] = 4048LLU/throw to this address/;
47932	48269	stack[base + 43LLU] = base;
47933		- stack[base + 44LLU] = 4010LLU;
	48270	+ stack[base + 44LLU] = 4049LLU;
47934	48271	// arguments for call to printnr
47935	48272	stack[base + 45LLU] = stack[base + 22]/labelloop/;
47936	48273	// set stack-base & callee-address

		@@ -47938,13 +48275,13 @@
47938	48275	label = 18446744073709551590LLU; // printnr
47939	48276	break;
47940	48277	}
47941		- case 4009LLU: // copy-back deleter (printnr to procblock)
	48278	+ case 4048LLU: // copy-back deleter (printnr to procblock)
47942	48279	{
47943	48280	// copy mutable arguments back from call to printnr
47944		- label = 3990LLU; // continue to roll stack
	48281	+ label = 4029LLU; // continue to roll stack
47945	48282	break;
47946	48283	}
47947		- case 4010LLU: // return from printnr to procblock
	48284	+ case 4049LLU: // return from printnr to procblock
47948	48285	{
47949	48286	// copy mutable arguments back from call to printnr
47950	48287	printf("%s", "LLU; // repeat");

		@@ -47952,9 +48289,9 @@
47952	48289	printf("%s", "\n }");
47953	48290	printf("%s", "\n case ");
47954	48291	// call printnr from procblock
47955		- stack[base + 42LLU] = 4011LLU/throw to this address/;
	48292	+ stack[base + 42LLU] = 4050LLU/throw to this address/;
47956	48293	stack[base + 43LLU] = base;
47957		- stack[base + 44LLU] = 4012LLU;
	48294	+ stack[base + 44LLU] = 4051LLU;
47958	48295	// arguments for call to printnr
47959	48296	stack[base + 45LLU] = stack[base + 41]/labelfail/;
47960	48297	// set stack-base & callee-address

		@@ -47962,13 +48299,13 @@
47962	48299	label = 18446744073709551590LLU; // printnr
47963	48300	break;
47964	48301	}
47965		- case 4011LLU: // copy-back deleter (printnr to procblock)
	48302	+ case 4050LLU: // copy-back deleter (printnr to procblock)
47966	48303	{
47967	48304	// copy mutable arguments back from call to printnr
47968		- label = 3990LLU; // continue to roll stack
	48305	+ label = 4029LLU; // continue to roll stack
47969	48306	break;
47970	48307	}
47971		- case 4012LLU: // return from printnr to procblock
	48308	+ case 4051LLU: // return from printnr to procblock
47972	48309	{
47973	48310	// copy mutable arguments back from call to printnr
47974	48311	printf("%s", "LLU: // copy-back deleter for while next");

		@@ -47975,9 +48312,9 @@
47975	48312	printf("%s", "\n {");
47976	48313	printf("%s", "\n ((struct listnode *)(");
47977	48314	// call emitvaridx from procblock
47978		- stack[base + 42LLU] = 4013LLU/throw to this address/;
	48315	+ stack[base + 42LLU] = 4052LLU/throw to this address/;
47979	48316	stack[base + 43LLU] = base;
47980		- stack[base + 44LLU] = 4014LLU;
	48317	+ stack[base + 44LLU] = 4053LLU;
47981	48318	// arguments for call to emitvaridx
47982	48319	stack[base + 45LLU] = stack[base + 39]/previdx/;
47983	48320	// set stack-base & callee-address

		@@ -47985,20 +48322,20 @@
47985	48322	label = 741LLU; // emitvaridx
47986	48323	break;
47987	48324	}
47988		- case 4013LLU: // copy-back deleter (emitvaridx to procblock)
	48325	+ case 4052LLU: // copy-back deleter (emitvaridx to procblock)
47989	48326	{
47990	48327	// copy mutable arguments back from call to emitvaridx
47991		- label = 3990LLU; // continue to roll stack
	48328	+ label = 4029LLU; // continue to roll stack
47992	48329	break;
47993	48330	}
47994		- case 4014LLU: // return from emitvaridx to procblock
	48331	+ case 4053LLU: // return from emitvaridx to procblock
47995	48332	{
47996	48333	// copy mutable arguments back from call to emitvaridx
47997	48334	printf("%s", "/previous/))->data = ");
47998	48335	// call emitvaridx from procblock
47999		- stack[base + 42LLU] = 4015LLU/throw to this address/;
	48336	+ stack[base + 42LLU] = 4054LLU/throw to this address/;
48000	48337	stack[base + 43LLU] = base;
48001		- stack[base + 44LLU] = 4016LLU;
	48338	+ stack[base + 44LLU] = 4055LLU;
48002	48339	// arguments for call to emitvaridx
48003	48340	stack[base + 45LLU] = stack[base + 38]/elemindex/;
48004	48341	// set stack-base & callee-address

		@@ -48006,21 +48343,21 @@
48006	48343	label = 741LLU; // emitvaridx
48007	48344	break;
48008	48345	}
48009		- case 4015LLU: // copy-back deleter (emitvaridx to procblock)
	48346	+ case 4054LLU: // copy-back deleter (emitvaridx to procblock)
48010	48347	{
48011	48348	// copy mutable arguments back from call to emitvaridx
48012		- label = 3990LLU; // continue to roll stack
	48349	+ label = 4029LLU; // continue to roll stack
48013	48350	break;
48014	48351	}
48015		- case 4016LLU: // return from emitvaridx to procblock
	48352	+ case 4055LLU: // return from emitvaridx to procblock
48016	48353	{
48017	48354	// copy mutable arguments back from call to emitvaridx
48018	48355	printf("%s", ";");
48019	48356	printf("%s", "\n label = ");
48020	48357	// call printnr from procblock
48021		- stack[base + 42LLU] = 4017LLU/throw to this address/;
	48358	+ stack[base + 42LLU] = 4056LLU/throw to this address/;
48022	48359	stack[base + 43LLU] = base;
48023		- stack[base + 44LLU] = 4018LLU;
	48360	+ stack[base + 44LLU] = 4057LLU;
48024	48361	// arguments for call to printnr
48025	48362	stack[base + 45LLU] = stack[base + 40]/labelthrow/;
48026	48363	// set stack-base & callee-address

		@@ -48028,13 +48365,13 @@
48028	48365	label = 18446744073709551590LLU; // printnr
48029	48366	break;
48030	48367	}
48031		- case 4017LLU: // copy-back deleter (printnr to procblock)
	48368	+ case 4056LLU: // copy-back deleter (printnr to procblock)
48032	48369	{
48033	48370	// copy mutable arguments back from call to printnr
48034		- label = 3990LLU; // continue to roll stack
	48371	+ label = 4029LLU; // continue to roll stack
48035	48372	break;
48036	48373	}
48037		- case 4018LLU: // return from printnr to procblock
	48374	+ case 4057LLU: // return from printnr to procblock
48038	48375	{
48039	48376	// copy mutable arguments back from call to printnr
48040	48377	printf("%s", "LLU; // continue to unroll stack");

		@@ -48042,9 +48379,9 @@
48042	48379	printf("%s", "\n }");
48043	48380	printf("%s", "\n case ");
48044	48381	// call printnr from procblock
48045		- stack[base + 42LLU] = 4019LLU/throw to this address/;
	48382	+ stack[base + 42LLU] = 4058LLU/throw to this address/;
48046	48383	stack[base + 43LLU] = base;
48047		- stack[base + 44LLU] = 4020LLU;
	48384	+ stack[base + 44LLU] = 4059LLU;
48048	48385	// arguments for call to printnr
48049	48386	stack[base + 45LLU] = stack[base + 23]/labelskip/;
48050	48387	// set stack-base & callee-address

		@@ -48052,40 +48389,40 @@
48052	48389	label = 18446744073709551590LLU; // printnr
48053	48390	break;
48054	48391	}
48055		- case 4019LLU: // copy-back deleter (printnr to procblock)
	48392	+ case 4058LLU: // copy-back deleter (printnr to procblock)
48056	48393	{
48057	48394	// copy mutable arguments back from call to printnr
48058		- label = 3990LLU; // continue to roll stack
	48395	+ label = 4029LLU; // continue to roll stack
48059	48396	break;
48060	48397	}
48061		- case 4020LLU: // return from printnr to procblock
	48398	+ case 4059LLU: // return from printnr to procblock
48062	48399	{
48063	48400	// copy mutable arguments back from call to printnr
48064	48401	printf("%s", "LLU: // loop finished");
48065	48402	printf("%s", "\n {");
48066		- label = 3951LLU; // alternative complete
	48403	+ label = 3990LLU; // alternative complete
48067	48404	break;
48068	48405	}
48069		- case 3951LLU: // completed if-then-else
	48406	+ case 3990LLU: // completed if-then-else
48070	48407	{
48071	48408	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 37];
48072		- label = 3935LLU; // case complete
	48409	+ label = 3974LLU; // case complete
48073	48410	break;
48074	48411	}
48075		- case 3937LLU: // copy-back deleter (switch)
	48412	+ case 3976LLU: // copy-back deleter (switch)
48076	48413	{
48077	48414	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 37];
48078		- label = 3923LLU; // continue to unroll stack
	48415	+ label = 3962LLU; // continue to unroll stack
48079	48416	break;
48080	48417	}
48081		- case 3936LLU: // try next case
	48418	+ case 3975LLU: // try next case
48082	48419	{
48083	48420	// default
48084	48421	fprintf(stderr, "%s", "in function ");
48085	48422	// call reportid from procblock
48086		- stack[base + 37LLU] = 4021LLU/throw to this address/;
	48423	+ stack[base + 37LLU] = 4060LLU/throw to this address/;
48087	48424	stack[base + 38LLU] = base;
48088		- stack[base + 39LLU] = 4022LLU;
	48425	+ stack[base + 39LLU] = 4061LLU;
48089	48426	// arguments for call to reportid
48090	48427	stack[base + 40LLU] = stack[base + 8]/fnid/;
48091	48428	// set stack-base & callee-address

		@@ -48093,13 +48430,13 @@
48093	48430	label = 18446744073709551586LLU; // reportid
48094	48431	break;
48095	48432	}
48096		- case 4021LLU: // copy-back deleter (reportid to procblock)
	48433	+ case 4060LLU: // copy-back deleter (reportid to procblock)
48097	48434	{
48098	48435	// copy mutable arguments back from call to reportid
48099		- label = 3923LLU; // continue to roll stack
	48436	+ label = 3962LLU; // continue to roll stack
48100	48437	break;
48101	48438	}
48102		- case 4022LLU: // return from reportid to procblock
	48439	+ case 4061LLU: // return from reportid to procblock
48103	48440	{
48104	48441	// copy mutable arguments back from call to reportid
48105	48442	fprintf(stderr, "%s", ": ");

		@@ -48107,7 +48444,7 @@
48107	48444	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
48108	48445	if(!newstack)
48109	48446	{
48110		- label = 3923LLU; // throw: begin to unroll stack
	48447	+ label = 3962LLU; // throw: begin to unroll stack
48111	48448	break;
48112	48449	}
48113	48450

		@@ -48114,9 +48451,9 @@
48114	48451	newstack[10LLU] = 9876543210LLU; // overflow-marker
48115	48452	// call reporttype from procblock
48116	48453	newstack[0] = (uint64_t)stack; // backup stack location
48117		- newstack[1] = 4023LLU;
	48454	+ newstack[1] = 4062LLU;
48118	48455	newstack[2] = base;
48119		- newstack[3] = 4024LLU;
	48456	+ newstack[3] = 4063LLU;
48120	48457	// arguments for call to reporttype
48121	48458	newstack[4LLU] = stack[base + 29]/listtype/;
48122	48459	stack = newstack;

		@@ -48125,7 +48462,7 @@
48125	48462	label = 326LLU; // reporttype
48126	48463	break;
48127	48464	}
48128		- case 4023LLU: // copy-back deleter (reporttype to procblock)
	48465	+ case 4062LLU: // copy-back deleter (reporttype to procblock)
48129	48466	{
48130	48467	uint64_t oldstack = (uint64_t )stack[0];
48131	48468	// copy mutable arguments back from call to reporttype

		@@ -48136,10 +48473,10 @@
48136	48473	}
48137	48474	Free(10LLU + 1, sizeof(uint64_t), stack);
48138	48475	stack = oldstack;
48139		- label = 3923LLU; // continue to unroll stack
	48476	+ label = 3962LLU; // continue to unroll stack
48140	48477	break;
48141	48478	}
48142		- case 4024LLU: // return from reporttype to procblock
	48479	+ case 4063LLU: // return from reporttype to procblock
48143	48480	{
48144	48481	uint64_t oldstack = (uint64_t )stack[0];
48145	48482	// copy mutable arguments back from call to reporttype

		@@ -48152,14 +48489,14 @@
48152	48489	stack = oldstack;
48153	48490	fprintf(stderr, "%s", "\n");
48154	48491	{
48155		- label = 3923LLU; // throw: begin to unroll stack
	48492	+ label = 3962LLU; // throw: begin to unroll stack
48156	48493	break;
48157	48494	}
48158	48495
48159		- label = 3935LLU; // default complete
	48496	+ label = 3974LLU; // default complete
48160	48497	break;
48161	48498	}
48162		- case 3935LLU: // completed switch
	48499	+ case 3974LLU: // completed switch
48163	48500	{
48164	48501	((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33];
48165	48502	((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32];

		@@ -48166,10 +48503,10 @@
48166	48503	((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31];
48167	48504	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30];
48168	48505	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29];
48169		- label = 3857LLU; // case complete
	48506	+ label = 3896LLU; // case complete
48170	48507	break;
48171	48508	}
48172		- case 3859LLU: // copy-back deleter (switch)
	48509	+ case 3898LLU: // copy-back deleter (switch)
48173	48510	{
48174	48511	((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33];
48175	48512	((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32];

		@@ -48176,15 +48513,15 @@
48176	48513	((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31];
48177	48514	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30];
48178	48515	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29];
48179		- label = 3852LLU; // continue to unroll stack
	48516	+ label = 3891LLU; // continue to unroll stack
48180	48517	break;
48181	48518	}
48182		- case 3858LLU: // try next case
	48519	+ case 3897LLU: // try next case
48183	48520	{
48184	48521	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
48185	48522	exit(-1);
48186	48523	}
48187		- case 3857LLU: // completed switch
	48524	+ case 3896LLU: // completed switch
48188	48525	{
48189	48526
48190	48527	uint64_t newstack = (uint64_t )(stack[base + 28] - sizeof(uint64_t) * 4);

		@@ -48192,7 +48529,7 @@
48192	48529	newstack[0] = (uint64_t)stack; // backup stack location
48193	48530	newstack[1] = 1234567890;
48194	48531	newstack[2] = base;
48195		- newstack[3] = 4025LLU;
	48532	+ newstack[3] = 4064LLU;
48196	48533	stack = newstack;
48197	48534	// set stack-base & callee-address
48198	48535	base = 4/deloffset/;

		@@ -48199,20 +48536,20 @@
48199	48536	label = 482LLU; // ~letdef
48200	48537	break;
48201	48538	}
48202		- case 4025LLU: // return from ~letdef to procblock
	48539	+ case 4064LLU: // return from ~letdef to procblock
48203	48540	{
48204	48541	stack = (uint64_t *)stack[0];
48205	48542	// releasing toplevel container
48206	48543	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
48207	48544
48208		- label = 3703LLU; // alternative complete
	48545	+ label = 3742LLU; // alternative complete
48209	48546	break;
48210	48547	}
48211		- case 3703LLU: // completed if-then-else
	48548	+ case 3742LLU: // completed if-then-else
48212	48549	{
48213	48550	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
48214	48551	{
48215		- label = 4027LLU; // jump to alternative
	48552	+ label = 4066LLU; // jump to alternative
48216	48553	break;
48217	48554	}
48218	48555

		@@ -48220,14 +48557,14 @@
48220	48557	/letdefs/stack[base + 27] = ((uint64_t *)(stack[base + 3]/scope/))[1][1]/letdefs*/;
48221	48558
48222	48559	// case
48223		- label = 4029LLU; // start to repeat
	48560	+ label = 4068LLU; // start to repeat
48224	48561	break;
48225	48562	}
48226		- case 4029LLU: // repeat from here
	48563	+ case 4068LLU: // repeat from here
48227	48564	{
48228	48565	if(!stack[base + 27])
48229	48566	{
48230		- label = 4030LLU; // break loop
	48567	+ label = 4069LLU; // break loop
48231	48568	break;
48232	48569	}
48233	48570

		@@ -48244,7 +48581,7 @@
48244	48581	newstack[0] = (uint64_t)stack; // backup stack location
48245	48582	newstack[1] = 1234567890;
48246	48583	newstack[2] = base;
48247		- newstack[3] = 4031LLU;
	48584	+ newstack[3] = 4070LLU;
48248	48585	stack = newstack;
48249	48586	// set stack-base & callee-address
48250	48587	base = 4/deloffset/;

		@@ -48251,49 +48588,49 @@
48251	48588	label = 482LLU; // ~letdef
48252	48589	break;
48253	48590	}
48254		- case 4031LLU: // return from ~letdef to procblock
	48591	+ case 4070LLU: // return from ~letdef to procblock
48255	48592	{
48256	48593	stack = (uint64_t *)stack[0];
48257	48594	// releasing toplevel container
48258	48595	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
48259	48596
48260		- label = 4029LLU; // repeat
	48597	+ label = 4068LLU; // repeat
48261	48598	break;
48262	48599	}
48263		- case 4030LLU: // loop finished
	48600	+ case 4069LLU: // loop finished
48264	48601	{
48265	48602	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 27];
48266	48603	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 26];
48267		- label = 4026LLU; // case complete
	48604	+ label = 4065LLU; // case complete
48268	48605	break;
48269	48606	}
48270		- case 4028LLU: // copy-back deleter (switch)
	48607	+ case 4067LLU: // copy-back deleter (switch)
48271	48608	{
48272	48609	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 27];
48273	48610	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 26];
48274		- label = 3670LLU; // continue to unroll stack
	48611	+ label = 3709LLU; // continue to unroll stack
48275	48612	break;
48276	48613	}
48277		- case 4027LLU: // try next case
	48614	+ case 4066LLU: // try next case
48278	48615	{
48279	48616	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
48280	48617	exit(-1);
48281	48618	}
48282		- case 4026LLU: // completed switch
	48619	+ case 4065LLU: // completed switch
48283	48620	{
48284	48621	{ // if pop
48285	48622	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
48286	48623	if(!list)
48287	48624	{
48288		- label = 4032LLU; // jump to alternative
	48625	+ label = 4071LLU; // jump to alternative
48289	48626	break;
48290	48627	}
48291	48628
48292	48629	// consequent
48293	48630	struct listnode *next = list->next;
48294		- stack[base + 26]/tmp/ = list->data;
	48631	+ /tmp/stack[base + 26] = list->data;
48295	48632	Free(1, sizeof(struct listnode), list);
48296		- stack[base + 2]/scopes/ = (uint64_t)next;
	48633	+ /scopes/stack[base + 2] = (uint64_t)next;
48297	48634	}
48298	48635	swap(&stack[base + 3], &stack[base + 26]);
48299	48636

		@@ -48302,7 +48639,7 @@
48302	48639	newstack[0] = (uint64_t)stack; // backup stack location
48303	48640	newstack[1] = 1234567890;
48304	48641	newstack[2] = base;
48305		- newstack[3] = 4035LLU;
	48642	+ newstack[3] = 4074LLU;
48306	48643	stack = newstack;
48307	48644	// set stack-base & callee-address
48308	48645	base = 4/deloffset/;

		@@ -48309,16 +48646,16 @@
48309	48646	label = 558LLU; // ~scope
48310	48647	break;
48311	48648	}
48312		- case 4035LLU: // return from ~scope to procblock
	48649	+ case 4074LLU: // return from ~scope to procblock
48313	48650	{
48314	48651	stack = (uint64_t *)stack[0];
48315	48652	// releasing toplevel container
48316	48653	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 26] - sizeof(uint64_t) 4));
48317	48654
48318		- label = 4033LLU; // consequent complete
	48655	+ label = 4072LLU; // consequent complete
48319	48656	break;
48320	48657	}
48321		- case 4034LLU: // copy-back deleter (if pop)
	48658	+ case 4073LLU: // copy-back deleter (if pop)
48322	48659	{
48323	48660
48324	48661	uint64_t newstack = (uint64_t )(stack[base + 26] - sizeof(uint64_t) * 4);

		@@ -48326,7 +48663,7 @@
48326	48663	newstack[0] = (uint64_t)stack; // backup stack location
48327	48664	newstack[1] = 1234567890;
48328	48665	newstack[2] = base;
48329		- newstack[3] = 4036LLU;
	48666	+ newstack[3] = 4075LLU;
48330	48667	stack = newstack;
48331	48668	// set stack-base & callee-address
48332	48669	base = 4/deloffset/;

		@@ -48333,37 +48670,37 @@
48333	48670	label = 558LLU; // ~scope
48334	48671	break;
48335	48672	}
48336		- case 4036LLU: // return from ~scope to procblock
	48673	+ case 4075LLU: // return from ~scope to procblock
48337	48674	{
48338	48675	stack = (uint64_t *)stack[0];
48339	48676	// releasing toplevel container
48340	48677	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 26] - sizeof(uint64_t) 4));
48341	48678
48342		- label = 3670LLU; // consequent complete
	48679	+ label = 3709LLU; // consequent complete
48343	48680	break;
48344	48681	}
48345		- case 4032LLU: // alternative
	48682	+ case 4071LLU: // alternative
48346	48683	{
48347	48684	fprintf(stderr, "%s", "internal error poping scope in block/while\n");
48348	48685	{
48349		- label = 3670LLU; // throw: begin to unroll stack
	48686	+ label = 3709LLU; // throw: begin to unroll stack
48350	48687	break;
48351	48688	}
48352	48689
48353		- label = 4033LLU; // alternative complete
	48690	+ label = 4072LLU; // alternative complete
48354	48691	break;
48355	48692	}
48356		- case 4033LLU: // completed if-then-else
	48693	+ case 4072LLU: // completed if-then-else
48357	48694	{
48358		- label = 3652LLU; // consequent complete
	48695	+ label = 3691LLU; // consequent complete
48359	48696	break;
48360	48697	}
48361		- case 3651LLU: // alternative
	48698	+ case 3690LLU: // alternative
48362	48699	{
48363	48700	// call equ from procblock
48364		- stack[base + 22LLU] = 4037LLU/throw to this address/;
	48701	+ stack[base + 22LLU] = 4076LLU/throw to this address/;
48365	48702	stack[base + 23LLU] = base;
48366		- stack[base + 24LLU] = 4038LLU;
	48703	+ stack[base + 24LLU] = 4077LLU;
48367	48704	// arguments for call to equ
48368	48705	stack[base + 26LLU] = stack[base + 16]/content/;
48369	48706	stack[base + 27LLU] = 819847183506341888LLU;

		@@ -48372,13 +48709,13 @@
48372	48709	label = 18446744073709551600LLU; // equ
48373	48710	break;
48374	48711	}
48375		- case 4037LLU: // copy-back deleter (equ to procblock)
	48712	+ case 4076LLU: // copy-back deleter (equ to procblock)
48376	48713	{
48377	48714	// copy mutable arguments back from call to equ
48378	48715	label = 3386LLU; // continue to roll stack
48379	48716	break;
48380	48717	}
48381		- case 4038LLU: // return from equ to procblock
	48718	+ case 4077LLU: // return from equ to procblock
48382	48719	{
48383	48720	// copy mutable arguments back from call to equ
48384	48721	// copy back results provided by call to equ

		@@ -48385,7 +48722,7 @@
48385	48722	stack[base + 20] = stack[base + 25LLU];
48386	48723	if(!stack[base + 20]/isequal/)
48387	48724	{
48388		- label = 4039LLU; // jump to alternative
	48725	+ label = 4078LLU; // jump to alternative
48389	48726	break;
48390	48727	}
48391	48728

		@@ -48392,21 +48729,21 @@
48392	48729	// consequent
48393	48730	if(!stack[base + 7]/fnIO/)
48394	48731	{
48395		- label = 4041LLU; // jump to alternative
	48732	+ label = 4080LLU; // jump to alternative
48396	48733	break;
48397	48734	}
48398	48735
48399	48736	// consequent
48400		- label = 4042LLU; // consequent complete
	48737	+ label = 4081LLU; // consequent complete
48401	48738	break;
48402	48739	}
48403		- case 4041LLU: // alternative
	48740	+ case 4080LLU: // alternative
48404	48741	{
48405	48742	fprintf(stderr, "%s", "in function ");
48406	48743	// call reportid from procblock
48407		- stack[base + 22LLU] = 4043LLU/throw to this address/;
	48744	+ stack[base + 22LLU] = 4082LLU/throw to this address/;
48408	48745	stack[base + 23LLU] = base;
48409		- stack[base + 24LLU] = 4044LLU;
	48746	+ stack[base + 24LLU] = 4083LLU;
48410	48747	// arguments for call to reportid
48411	48748	stack[base + 25LLU] = stack[base + 8]/fnid/;
48412	48749	// set stack-base & callee-address

		@@ -48414,13 +48751,13 @@
48414	48751	label = 18446744073709551586LLU; // reportid
48415	48752	break;
48416	48753	}
48417		- case 4043LLU: // copy-back deleter (reportid to procblock)
	48754	+ case 4082LLU: // copy-back deleter (reportid to procblock)
48418	48755	{
48419	48756	// copy mutable arguments back from call to reportid
48420	48757	label = 3386LLU; // continue to roll stack
48421	48758	break;
48422	48759	}
48423		- case 4044LLU: // return from reportid to procblock
	48760	+ case 4083LLU: // return from reportid to procblock
48424	48761	{
48425	48762	// copy mutable arguments back from call to reportid
48426	48763	fprintf(stderr, "%s", ": report-construct used in non-IO environment\n");

		@@ -48429,15 +48766,15 @@
48429	48766	break;
48430	48767	}
48431	48768
48432		- label = 4042LLU; // alternative complete
	48769	+ label = 4081LLU; // alternative complete
48433	48770	break;
48434	48771	}
48435		- case 4042LLU: // completed if-then-else
	48772	+ case 4081LLU: // completed if-then-else
48436	48773	{
48437	48774	// call matchsym from procblock
48438		- stack[base + 22LLU] = 4045LLU/throw to this address/;
	48775	+ stack[base + 22LLU] = 4084LLU/throw to this address/;
48439	48776	stack[base + 23LLU] = base;
48440		- stack[base + 24LLU] = 4046LLU;
	48777	+ stack[base + 24LLU] = 4085LLU;
48441	48778	// arguments for call to matchsym
48442	48779	stack[base + 25LLU] = stack[base + 8]/fnid/;
48443	48780	stack[base + 26LLU] = 40LLU;

		@@ -48447,7 +48784,7 @@
48447	48784	label = 222LLU; // matchsym
48448	48785	break;
48449	48786	}
48450		- case 4045LLU: // copy-back deleter (matchsym to procblock)
	48787	+ case 4084LLU: // copy-back deleter (matchsym to procblock)
48451	48788	{
48452	48789	// copy mutable arguments back from call to matchsym
48453	48790	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48454,15 +48791,15 @@
48454	48791	label = 3386LLU; // continue to roll stack
48455	48792	break;
48456	48793	}
48457		- case 4046LLU: // return from matchsym to procblock
	48794	+ case 4085LLU: // return from matchsym to procblock
48458	48795	{
48459	48796	// copy mutable arguments back from call to matchsym
48460	48797	stack[base + 19]/lookahead/ = stack[base + 27LLU];
48461	48798	printf("%s", "\n fprintf(stderr, \"%s\", ");
48462	48799	// call echostring from procblock
48463		- stack[base + 22LLU] = 4047LLU/throw to this address/;
	48800	+ stack[base + 22LLU] = 4086LLU/throw to this address/;
48464	48801	stack[base + 23LLU] = base;
48465		- stack[base + 24LLU] = 4048LLU;
	48802	+ stack[base + 24LLU] = 4087LLU;
48466	48803	// arguments for call to echostring
48467	48804	stack[base + 26LLU] = stack[base + 19]/lookahead/;
48468	48805	// set stack-base & callee-address

		@@ -48470,13 +48807,13 @@
48470	48807	label = 18446744073709551581LLU; // echostring
48471	48808	break;
48472	48809	}
48473		- case 4047LLU: // copy-back deleter (echostring to procblock)
	48810	+ case 4086LLU: // copy-back deleter (echostring to procblock)
48474	48811	{
48475	48812	// copy mutable arguments back from call to echostring
48476	48813	label = 3386LLU; // continue to roll stack
48477	48814	break;
48478	48815	}
48479		- case 4048LLU: // return from echostring to procblock
	48816	+ case 4087LLU: // return from echostring to procblock
48480	48817	{
48481	48818	// copy mutable arguments back from call to echostring
48482	48819	// copy back results provided by call to echostring

		@@ -48483,9 +48820,9 @@
48483	48820	stack[base + 19] = stack[base + 25LLU];
48484	48821	printf("%s", ");");
48485	48822	// call matchsym from procblock
48486		- stack[base + 22LLU] = 4049LLU/throw to this address/;
	48823	+ stack[base + 22LLU] = 4088LLU/throw to this address/;
48487	48824	stack[base + 23LLU] = base;
48488		- stack[base + 24LLU] = 4050LLU;
	48825	+ stack[base + 24LLU] = 4089LLU;
48489	48826	// arguments for call to matchsym
48490	48827	stack[base + 25LLU] = stack[base + 8]/fnid/;
48491	48828	stack[base + 26LLU] = 41LLU;

		@@ -48495,7 +48832,7 @@
48495	48832	label = 222LLU; // matchsym
48496	48833	break;
48497	48834	}
48498		- case 4049LLU: // copy-back deleter (matchsym to procblock)
	48835	+ case 4088LLU: // copy-back deleter (matchsym to procblock)
48499	48836	{
48500	48837	// copy mutable arguments back from call to matchsym
48501	48838	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48502,14 +48839,14 @@
48502	48839	label = 3386LLU; // continue to roll stack
48503	48840	break;
48504	48841	}
48505		- case 4050LLU: // return from matchsym to procblock
	48842	+ case 4089LLU: // return from matchsym to procblock
48506	48843	{
48507	48844	// copy mutable arguments back from call to matchsym
48508	48845	stack[base + 19]/lookahead/ = stack[base + 27LLU];
48509	48846	// call delimiter from procblock
48510		- stack[base + 22LLU] = 4051LLU/throw to this address/;
	48847	+ stack[base + 22LLU] = 4090LLU/throw to this address/;
48511	48848	stack[base + 23LLU] = base;
48512		- stack[base + 24LLU] = 4052LLU;
	48849	+ stack[base + 24LLU] = 4091LLU;
48513	48850	// arguments for call to delimiter
48514	48851	stack[base + 25LLU] = stack[base + 8]/fnid/;
48515	48852	stack[base + 26LLU] = stack[base + 19]/lookahead/;

		@@ -48518,7 +48855,7 @@
48518	48855	label = 29LLU; // delimiter
48519	48856	break;
48520	48857	}
48521		- case 4051LLU: // copy-back deleter (delimiter to procblock)
	48858	+ case 4090LLU: // copy-back deleter (delimiter to procblock)
48522	48859	{
48523	48860	// copy mutable arguments back from call to delimiter
48524	48861	stack[base + 19]/lookahead/ = stack[base + 26LLU];

		@@ -48525,19 +48862,19 @@
48525	48862	label = 3386LLU; // continue to roll stack
48526	48863	break;
48527	48864	}
48528		- case 4052LLU: // return from delimiter to procblock
	48865	+ case 4091LLU: // return from delimiter to procblock
48529	48866	{
48530	48867	// copy mutable arguments back from call to delimiter
48531	48868	stack[base + 19]/lookahead/ = stack[base + 26LLU];
48532		- label = 4040LLU; // consequent complete
	48869	+ label = 4079LLU; // consequent complete
48533	48870	break;
48534	48871	}
48535		- case 4039LLU: // alternative
	48872	+ case 4078LLU: // alternative
48536	48873	{
48537	48874	// call equ from procblock
48538		- stack[base + 22LLU] = 4053LLU/throw to this address/;
	48875	+ stack[base + 22LLU] = 4092LLU/throw to this address/;
48539	48876	stack[base + 23LLU] = base;
48540		- stack[base + 24LLU] = 4054LLU;
	48877	+ stack[base + 24LLU] = 4093LLU;
48541	48878	// arguments for call to equ
48542	48879	stack[base + 26LLU] = stack[base + 16]/content/;
48543	48880	stack[base + 27LLU] = 787446707498516480LLU;

		@@ -48546,13 +48883,13 @@
48546	48883	label = 18446744073709551600LLU; // equ
48547	48884	break;
48548	48885	}
48549		- case 4053LLU: // copy-back deleter (equ to procblock)
	48886	+ case 4092LLU: // copy-back deleter (equ to procblock)
48550	48887	{
48551	48888	// copy mutable arguments back from call to equ
48552	48889	label = 3386LLU; // continue to roll stack
48553	48890	break;
48554	48891	}
48555		- case 4054LLU: // return from equ to procblock
	48892	+ case 4093LLU: // return from equ to procblock
48556	48893	{
48557	48894	// copy mutable arguments back from call to equ
48558	48895	// copy back results provided by call to equ

		@@ -48559,7 +48896,7 @@
48559	48896	stack[base + 20] = stack[base + 25LLU];
48560	48897	if(!stack[base + 20]/isequal/)
48561	48898	{
48562		- label = 4055LLU; // jump to alternative
	48899	+ label = 4094LLU; // jump to alternative
48563	48900	break;
48564	48901	}
48565	48902

		@@ -48566,21 +48903,21 @@
48566	48903	// consequent
48567	48904	if(!stack[base + 7]/fnIO/)
48568	48905	{
48569		- label = 4057LLU; // jump to alternative
	48906	+ label = 4096LLU; // jump to alternative
48570	48907	break;
48571	48908	}
48572	48909
48573	48910	// consequent
48574		- label = 4058LLU; // consequent complete
	48911	+ label = 4097LLU; // consequent complete
48575	48912	break;
48576	48913	}
48577		- case 4057LLU: // alternative
	48914	+ case 4096LLU: // alternative
48578	48915	{
48579	48916	fprintf(stderr, "%s", "in function ");
48580	48917	// call reportid from procblock
48581		- stack[base + 22LLU] = 4059LLU/throw to this address/;
	48918	+ stack[base + 22LLU] = 4098LLU/throw to this address/;
48582	48919	stack[base + 23LLU] = base;
48583		- stack[base + 24LLU] = 4060LLU;
	48920	+ stack[base + 24LLU] = 4099LLU;
48584	48921	// arguments for call to reportid
48585	48922	stack[base + 25LLU] = stack[base + 8]/fnid/;
48586	48923	// set stack-base & callee-address

		@@ -48588,13 +48925,13 @@
48588	48925	label = 18446744073709551586LLU; // reportid
48589	48926	break;
48590	48927	}
48591		- case 4059LLU: // copy-back deleter (reportid to procblock)
	48928	+ case 4098LLU: // copy-back deleter (reportid to procblock)
48592	48929	{
48593	48930	// copy mutable arguments back from call to reportid
48594	48931	label = 3386LLU; // continue to roll stack
48595	48932	break;
48596	48933	}
48597		- case 4060LLU: // return from reportid to procblock
	48934	+ case 4099LLU: // return from reportid to procblock
48598	48935	{
48599	48936	// copy mutable arguments back from call to reportid
48600	48937	fprintf(stderr, "%s", ": print-construct used in non-IO environment\n");

		@@ -48603,15 +48940,15 @@
48603	48940	break;
48604	48941	}
48605	48942
48606		- label = 4058LLU; // alternative complete
	48943	+ label = 4097LLU; // alternative complete
48607	48944	break;
48608	48945	}
48609		- case 4058LLU: // completed if-then-else
	48946	+ case 4097LLU: // completed if-then-else
48610	48947	{
48611	48948	// call matchsym from procblock
48612		- stack[base + 22LLU] = 4061LLU/throw to this address/;
	48949	+ stack[base + 22LLU] = 4100LLU/throw to this address/;
48613	48950	stack[base + 23LLU] = base;
48614		- stack[base + 24LLU] = 4062LLU;
	48951	+ stack[base + 24LLU] = 4101LLU;
48615	48952	// arguments for call to matchsym
48616	48953	stack[base + 25LLU] = stack[base + 8]/fnid/;
48617	48954	stack[base + 26LLU] = 40LLU;

		@@ -48621,7 +48958,7 @@
48621	48958	label = 222LLU; // matchsym
48622	48959	break;
48623	48960	}
48624		- case 4061LLU: // copy-back deleter (matchsym to procblock)
	48961	+ case 4100LLU: // copy-back deleter (matchsym to procblock)
48625	48962	{
48626	48963	// copy mutable arguments back from call to matchsym
48627	48964	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48628,15 +48965,15 @@
48628	48965	label = 3386LLU; // continue to roll stack
48629	48966	break;
48630	48967	}
48631		- case 4062LLU: // return from matchsym to procblock
	48968	+ case 4101LLU: // return from matchsym to procblock
48632	48969	{
48633	48970	// copy mutable arguments back from call to matchsym
48634	48971	stack[base + 19]/lookahead/ = stack[base + 27LLU];
48635	48972	printf("%s", "\n printf(\"%s\", ");
48636	48973	// call echostring from procblock
48637		- stack[base + 22LLU] = 4063LLU/throw to this address/;
	48974	+ stack[base + 22LLU] = 4102LLU/throw to this address/;
48638	48975	stack[base + 23LLU] = base;
48639		- stack[base + 24LLU] = 4064LLU;
	48976	+ stack[base + 24LLU] = 4103LLU;
48640	48977	// arguments for call to echostring
48641	48978	stack[base + 26LLU] = stack[base + 19]/lookahead/;
48642	48979	// set stack-base & callee-address

		@@ -48644,13 +48981,13 @@
48644	48981	label = 18446744073709551581LLU; // echostring
48645	48982	break;
48646	48983	}
48647		- case 4063LLU: // copy-back deleter (echostring to procblock)
	48984	+ case 4102LLU: // copy-back deleter (echostring to procblock)
48648	48985	{
48649	48986	// copy mutable arguments back from call to echostring
48650	48987	label = 3386LLU; // continue to roll stack
48651	48988	break;
48652	48989	}
48653		- case 4064LLU: // return from echostring to procblock
	48990	+ case 4103LLU: // return from echostring to procblock
48654	48991	{
48655	48992	// copy mutable arguments back from call to echostring
48656	48993	// copy back results provided by call to echostring

		@@ -48657,9 +48994,9 @@
48657	48994	stack[base + 19] = stack[base + 25LLU];
48658	48995	printf("%s", ");");
48659	48996	// call matchsym from procblock
48660		- stack[base + 22LLU] = 4065LLU/throw to this address/;
	48997	+ stack[base + 22LLU] = 4104LLU/throw to this address/;
48661	48998	stack[base + 23LLU] = base;
48662		- stack[base + 24LLU] = 4066LLU;
	48999	+ stack[base + 24LLU] = 4105LLU;
48663	49000	// arguments for call to matchsym
48664	49001	stack[base + 25LLU] = stack[base + 8]/fnid/;
48665	49002	stack[base + 26LLU] = 41LLU;

		@@ -48669,7 +49006,7 @@
48669	49006	label = 222LLU; // matchsym
48670	49007	break;
48671	49008	}
48672		- case 4065LLU: // copy-back deleter (matchsym to procblock)
	49009	+ case 4104LLU: // copy-back deleter (matchsym to procblock)
48673	49010	{
48674	49011	// copy mutable arguments back from call to matchsym
48675	49012	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48676,14 +49013,14 @@
48676	49013	label = 3386LLU; // continue to roll stack
48677	49014	break;
48678	49015	}
48679		- case 4066LLU: // return from matchsym to procblock
	49016	+ case 4105LLU: // return from matchsym to procblock
48680	49017	{
48681	49018	// copy mutable arguments back from call to matchsym
48682	49019	stack[base + 19]/lookahead/ = stack[base + 27LLU];
48683	49020	// call delimiter from procblock
48684		- stack[base + 22LLU] = 4067LLU/throw to this address/;
	49021	+ stack[base + 22LLU] = 4106LLU/throw to this address/;
48685	49022	stack[base + 23LLU] = base;
48686		- stack[base + 24LLU] = 4068LLU;
	49023	+ stack[base + 24LLU] = 4107LLU;
48687	49024	// arguments for call to delimiter
48688	49025	stack[base + 25LLU] = stack[base + 8]/fnid/;
48689	49026	stack[base + 26LLU] = stack[base + 19]/lookahead/;

		@@ -48692,7 +49029,7 @@
48692	49029	label = 29LLU; // delimiter
48693	49030	break;
48694	49031	}
48695		- case 4067LLU: // copy-back deleter (delimiter to procblock)
	49032	+ case 4106LLU: // copy-back deleter (delimiter to procblock)
48696	49033	{
48697	49034	// copy mutable arguments back from call to delimiter
48698	49035	stack[base + 19]/lookahead/ = stack[base + 26LLU];

		@@ -48699,19 +49036,19 @@
48699	49036	label = 3386LLU; // continue to roll stack
48700	49037	break;
48701	49038	}
48702		- case 4068LLU: // return from delimiter to procblock
	49039	+ case 4107LLU: // return from delimiter to procblock
48703	49040	{
48704	49041	// copy mutable arguments back from call to delimiter
48705	49042	stack[base + 19]/lookahead/ = stack[base + 26LLU];
48706		- label = 4056LLU; // consequent complete
	49043	+ label = 4095LLU; // consequent complete
48707	49044	break;
48708	49045	}
48709		- case 4055LLU: // alternative
	49046	+ case 4094LLU: // alternative
48710	49047	{
48711	49048	// call equ from procblock
48712		- stack[base + 22LLU] = 4069LLU/throw to this address/;
	49049	+ stack[base + 22LLU] = 4108LLU/throw to this address/;
48713	49050	stack[base + 23LLU] = base;
48714		- stack[base + 24LLU] = 4070LLU;
	49051	+ stack[base + 24LLU] = 4109LLU;
48715	49052	// arguments for call to equ
48716	49053	stack[base + 26LLU] = stack[base + 16]/content/;
48717	49054	stack[base + 27LLU] = 856729206128640000LLU;

		@@ -48720,13 +49057,13 @@
48720	49057	label = 18446744073709551600LLU; // equ
48721	49058	break;
48722	49059	}
48723		- case 4069LLU: // copy-back deleter (equ to procblock)
	49060	+ case 4108LLU: // copy-back deleter (equ to procblock)
48724	49061	{
48725	49062	// copy mutable arguments back from call to equ
48726	49063	label = 3386LLU; // continue to roll stack
48727	49064	break;
48728	49065	}
48729		- case 4070LLU: // return from equ to procblock
	49066	+ case 4109LLU: // return from equ to procblock
48730	49067	{
48731	49068	// copy mutable arguments back from call to equ
48732	49069	// copy back results provided by call to equ

		@@ -48733,7 +49070,7 @@
48733	49070	stack[base + 20] = stack[base + 25LLU];
48734	49071	if(!stack[base + 20]/isequal/)
48735	49072	{
48736		- label = 4071LLU; // jump to alternative
	49073	+ label = 4110LLU; // jump to alternative
48737	49074	break;
48738	49075	}
48739	49076

		@@ -48740,21 +49077,21 @@
48740	49077	// consequent
48741	49078	if(!stack[base + 6]/fncanthrow/)
48742	49079	{
48743		- label = 4073LLU; // jump to alternative
	49080	+ label = 4112LLU; // jump to alternative
48744	49081	break;
48745	49082	}
48746	49083
48747	49084	// consequent
48748		- label = 4074LLU; // consequent complete
	49085	+ label = 4113LLU; // consequent complete
48749	49086	break;
48750	49087	}
48751		- case 4073LLU: // alternative
	49088	+ case 4112LLU: // alternative
48752	49089	{
48753	49090	fprintf(stderr, "%s", "in function ");
48754	49091	// call reportid from procblock
48755		- stack[base + 22LLU] = 4075LLU/throw to this address/;
	49092	+ stack[base + 22LLU] = 4114LLU/throw to this address/;
48756	49093	stack[base + 23LLU] = base;
48757		- stack[base + 24LLU] = 4076LLU;
	49094	+ stack[base + 24LLU] = 4115LLU;
48758	49095	// arguments for call to reportid
48759	49096	stack[base + 25LLU] = stack[base + 8]/fnid/;
48760	49097	// set stack-base & callee-address

		@@ -48762,13 +49099,13 @@
48762	49099	label = 18446744073709551586LLU; // reportid
48763	49100	break;
48764	49101	}
48765		- case 4075LLU: // copy-back deleter (reportid to procblock)
	49102	+ case 4114LLU: // copy-back deleter (reportid to procblock)
48766	49103	{
48767	49104	// copy mutable arguments back from call to reportid
48768	49105	label = 3386LLU; // continue to roll stack
48769	49106	break;
48770	49107	}
48771		- case 4076LLU: // return from reportid to procblock
	49108	+ case 4115LLU: // return from reportid to procblock
48772	49109	{
48773	49110	// copy mutable arguments back from call to reportid
48774	49111	fprintf(stderr, "%s", ": use of throw in no-throw environment\n");

		@@ -48777,15 +49114,15 @@
48777	49114	break;
48778	49115	}
48779	49116
48780		- label = 4074LLU; // alternative complete
	49117	+ label = 4113LLU; // alternative complete
48781	49118	break;
48782	49119	}
48783		- case 4074LLU: // completed if-then-else
	49120	+ case 4113LLU: // completed if-then-else
48784	49121	{
48785	49122	// call emitthrow from procblock
48786		- stack[base + 22LLU] = 4077LLU/throw to this address/;
	49123	+ stack[base + 22LLU] = 4116LLU/throw to this address/;
48787	49124	stack[base + 23LLU] = base;
48788		- stack[base + 24LLU] = 4078LLU;
	49125	+ stack[base + 24LLU] = 4117LLU;
48789	49126	// arguments for call to emitthrow
48790	49127	stack[base + 25LLU] = stack[base + 3]/scope/;
48791	49128	// set stack-base & callee-address

		@@ -48793,19 +49130,19 @@
48793	49130	label = 1698LLU; // emitthrow
48794	49131	break;
48795	49132	}
48796		- case 4077LLU: // copy-back deleter (emitthrow to procblock)
	49133	+ case 4116LLU: // copy-back deleter (emitthrow to procblock)
48797	49134	{
48798	49135	// copy mutable arguments back from call to emitthrow
48799	49136	label = 3386LLU; // continue to roll stack
48800	49137	break;
48801	49138	}
48802		- case 4078LLU: // return from emitthrow to procblock
	49139	+ case 4117LLU: // return from emitthrow to procblock
48803	49140	{
48804	49141	// copy mutable arguments back from call to emitthrow
48805	49142	// call delimiter from procblock
48806		- stack[base + 22LLU] = 4079LLU/throw to this address/;
	49143	+ stack[base + 22LLU] = 4118LLU/throw to this address/;
48807	49144	stack[base + 23LLU] = base;
48808		- stack[base + 24LLU] = 4080LLU;
	49145	+ stack[base + 24LLU] = 4119LLU;
48809	49146	// arguments for call to delimiter
48810	49147	stack[base + 25LLU] = stack[base + 8]/fnid/;
48811	49148	stack[base + 26LLU] = stack[base + 19]/lookahead/;

		@@ -48814,7 +49151,7 @@
48814	49151	label = 29LLU; // delimiter
48815	49152	break;
48816	49153	}
48817		- case 4079LLU: // copy-back deleter (delimiter to procblock)
	49154	+ case 4118LLU: // copy-back deleter (delimiter to procblock)
48818	49155	{
48819	49156	// copy mutable arguments back from call to delimiter
48820	49157	stack[base + 19]/lookahead/ = stack[base + 26LLU];

		@@ -48821,14 +49158,14 @@
48821	49158	label = 3386LLU; // continue to roll stack
48822	49159	break;
48823	49160	}
48824		- case 4080LLU: // return from delimiter to procblock
	49161	+ case 4119LLU: // return from delimiter to procblock
48825	49162	{
48826	49163	// copy mutable arguments back from call to delimiter
48827	49164	stack[base + 19]/lookahead/ = stack[base + 26LLU];
48828	49165	// call MATCHPEEK from procblock
48829		- stack[base + 22LLU] = 4081LLU/throw to this address/;
	49166	+ stack[base + 22LLU] = 4120LLU/throw to this address/;
48830	49167	stack[base + 23LLU] = base;
48831		- stack[base + 24LLU] = 4082LLU;
	49168	+ stack[base + 24LLU] = 4121LLU;
48832	49169	// arguments for call to MATCHPEEK
48833	49170	stack[base + 25LLU] = stack[base + 8]/fnid/;
48834	49171	stack[base + 26LLU] = 125LLU;

		@@ -48838,7 +49175,7 @@
48838	49175	label = 206LLU; // MATCHPEEK
48839	49176	break;
48840	49177	}
48841		- case 4081LLU: // copy-back deleter (MATCHPEEK to procblock)
	49178	+ case 4120LLU: // copy-back deleter (MATCHPEEK to procblock)
48842	49179	{
48843	49180	// copy mutable arguments back from call to MATCHPEEK
48844	49181	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48845,14 +49182,14 @@
48845	49182	label = 3386LLU; // continue to roll stack
48846	49183	break;
48847	49184	}
48848		- case 4082LLU: // return from MATCHPEEK to procblock
	49185	+ case 4121LLU: // return from MATCHPEEK to procblock
48849	49186	{
48850	49187	// copy mutable arguments back from call to MATCHPEEK
48851	49188	stack[base + 19]/lookahead/ = stack[base + 27LLU];
48852	49189	// call EOSbyte from procblock
48853		- stack[base + 22LLU] = 4083LLU/throw to this address/;
	49190	+ stack[base + 22LLU] = 4122LLU/throw to this address/;
48854	49191	stack[base + 23LLU] = base;
48855		- stack[base + 24LLU] = 4084LLU;
	49192	+ stack[base + 24LLU] = 4123LLU;
48856	49193	// arguments for call to EOSbyte
48857	49194	// set stack-base & callee-address
48858	49195	base += 25LLU;

		@@ -48859,26 +49196,26 @@
48859	49196	label = 77LLU; // EOSbyte
48860	49197	break;
48861	49198	}
48862		- case 4083LLU: // copy-back deleter (EOSbyte to procblock)
	49199	+ case 4122LLU: // copy-back deleter (EOSbyte to procblock)
48863	49200	{
48864	49201	// copy mutable arguments back from call to EOSbyte
48865	49202	label = 3386LLU; // continue to roll stack
48866	49203	break;
48867	49204	}
48868		- case 4084LLU: // return from EOSbyte to procblock
	49205	+ case 4123LLU: // return from EOSbyte to procblock
48869	49206	{
48870	49207	// copy mutable arguments back from call to EOSbyte
48871	49208	// copy back results provided by call to EOSbyte
48872	49209	stack[base + 19] = stack[base + 25LLU];
48873		- label = 4072LLU; // consequent complete
	49210	+ label = 4111LLU; // consequent complete
48874	49211	break;
48875	49212	}
48876		- case 4071LLU: // alternative
	49213	+ case 4110LLU: // alternative
48877	49214	{
48878	49215	// call equ from procblock
48879		- stack[base + 22LLU] = 4085LLU/throw to this address/;
	49216	+ stack[base + 22LLU] = 4124LLU/throw to this address/;
48880	49217	stack[base + 23LLU] = base;
48881		- stack[base + 24LLU] = 4086LLU;
	49218	+ stack[base + 24LLU] = 4125LLU;
48882	49219	// arguments for call to equ
48883	49220	stack[base + 26LLU] = stack[base + 16]/content/;
48884	49221	stack[base + 27LLU] = 711775449310560256LLU;

		@@ -48887,13 +49224,13 @@
48887	49224	label = 18446744073709551600LLU; // equ
48888	49225	break;
48889	49226	}
48890		- case 4085LLU: // copy-back deleter (equ to procblock)
	49227	+ case 4124LLU: // copy-back deleter (equ to procblock)
48891	49228	{
48892	49229	// copy mutable arguments back from call to equ
48893	49230	label = 3386LLU; // continue to roll stack
48894	49231	break;
48895	49232	}
48896		- case 4086LLU: // return from equ to procblock
	49233	+ case 4125LLU: // return from equ to procblock
48897	49234	{
48898	49235	// copy mutable arguments back from call to equ
48899	49236	// copy back results provided by call to equ

		@@ -48900,15 +49237,15 @@
48900	49237	stack[base + 20] = stack[base + 25LLU];
48901	49238	if(!stack[base + 20]/isequal/)
48902	49239	{
48903		- label = 4087LLU; // jump to alternative
	49240	+ label = 4126LLU; // jump to alternative
48904	49241	break;
48905	49242	}
48906	49243
48907	49244	// consequent
48908	49245	// call ParseToken from procblock
48909		- stack[base + 22LLU] = 4089LLU/throw to this address/;
	49246	+ stack[base + 22LLU] = 4128LLU/throw to this address/;
48910	49247	stack[base + 23LLU] = base;
48911		- stack[base + 24LLU] = 4090LLU;
	49248	+ stack[base + 24LLU] = 4129LLU;
48912	49249	// arguments for call to ParseToken
48913	49250	stack[base + 27LLU] = stack[base + 19]/lookahead/;
48914	49251	// set stack-base & callee-address

		@@ -48916,7 +49253,7 @@
48916	49253	label = 3LLU; // ParseToken
48917	49254	break;
48918	49255	}
48919		- case 4089LLU: // copy-back deleter (ParseToken to procblock)
	49256	+ case 4128LLU: // copy-back deleter (ParseToken to procblock)
48920	49257	{
48921	49258	// copy mutable arguments back from call to ParseToken
48922	49259	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48923,7 +49260,7 @@
48923	49260	label = 3386LLU; // continue to roll stack
48924	49261	break;
48925	49262	}
48926		- case 4090LLU: // return from ParseToken to procblock
	49263	+ case 4129LLU: // return from ParseToken to procblock
48927	49264	{
48928	49265	// copy mutable arguments back from call to ParseToken
48929	49266	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -48931,9 +49268,9 @@
48931	49268	stack[base + 15] = stack[base + 25LLU];
48932	49269	stack[base + 16] = stack[base + 26LLU];
48933	49270	// call equ from procblock
48934		- stack[base + 22LLU] = 4091LLU/throw to this address/;
	49271	+ stack[base + 22LLU] = 4130LLU/throw to this address/;
48935	49272	stack[base + 23LLU] = base;
48936		- stack[base + 24LLU] = 4092LLU;
	49273	+ stack[base + 24LLU] = 4131LLU;
48937	49274	// arguments for call to equ
48938	49275	stack[base + 26LLU] = stack[base + 16]/content/;
48939	49276	stack[base + 27LLU] = 40LLU;

		@@ -48942,13 +49279,13 @@
48942	49279	label = 18446744073709551600LLU; // equ
48943	49280	break;
48944	49281	}
48945		- case 4091LLU: // copy-back deleter (equ to procblock)
	49282	+ case 4130LLU: // copy-back deleter (equ to procblock)
48946	49283	{
48947	49284	// copy mutable arguments back from call to equ
48948	49285	label = 3386LLU; // continue to roll stack
48949	49286	break;
48950	49287	}
48951		- case 4092LLU: // return from equ to procblock
	49288	+ case 4131LLU: // return from equ to procblock
48952	49289	{
48953	49290	// copy mutable arguments back from call to equ
48954	49291	// copy back results provided by call to equ

		@@ -48955,15 +49292,15 @@
48955	49292	stack[base + 20] = stack[base + 25LLU];
48956	49293	if(!stack[base + 20]/isequal/)
48957	49294	{
48958		- label = 4093LLU; // jump to alternative
	49295	+ label = 4132LLU; // jump to alternative
48959	49296	break;
48960	49297	}
48961	49298
48962	49299	// consequent
48963		- label = 4096LLU; // skip deleter
	49300	+ label = 4135LLU; // skip deleter
48964	49301	break;
48965	49302	}
48966		- case 4095LLU: // deleter
	49303	+ case 4134LLU: // deleter
48967	49304	{
48968	49305	// throw from procblock
48969	49306	if(!stack[base + 22])

		@@ -48972,14 +49309,14 @@
48972	49309	break;
48973	49310	}
48974	49311	// delete list
48975		- label = 4097LLU; // start to repeat
	49312	+ label = 4136LLU; // start to repeat
48976	49313	break;
48977	49314	}
48978		- case 4097LLU: // repeat from here
	49315	+ case 4136LLU: // repeat from here
48979	49316	{
48980	49317	if(!stack[base + 22])
48981	49318	{
48982		- label = 4098LLU; // break loop
	49319	+ label = 4137LLU; // break loop
48983	49320	break;
48984	49321	}
48985	49322

		@@ -48990,7 +49327,7 @@
48990	49327	newstack[0] = (uint64_t)stack; // backup stack location
48991	49328	newstack[1] = 1234567890;
48992	49329	newstack[2] = base;
48993		- newstack[3] = 4099LLU;
	49330	+ newstack[3] = 4138LLU;
48994	49331	stack = newstack;
48995	49332	// set stack-base & callee-address
48996	49333	base = 4/deloffset/;

		@@ -48997,7 +49334,7 @@
48997	49334	label = 395LLU; // ~typeidx
48998	49335	break;
48999	49336	}
49000		- case 4099LLU: // return from ~typeidx to procblock
	49337	+ case 4138LLU: // return from ~typeidx to procblock
49001	49338	{
49002	49339	stack = (uint64_t *)stack[0];
49003	49340	// releasing toplevel container

		@@ -49008,26 +49345,26 @@
49008	49345	stack[base + 22] = (uint64_t)list->next;
49009	49346	Free(1, sizeof(struct listnode), list);
49010	49347	}
49011		- label = 4097LLU; // repeat
	49348	+ label = 4136LLU; // repeat
49012	49349	break;
49013	49350	}
49014		- case 4098LLU: // loop finished
	49351	+ case 4137LLU: // loop finished
49015	49352	{
49016	49353	label = 3386LLU; // continue unrolling stack, delete next variable
49017	49354	break;
49018	49355	}
49019		- case 4096LLU: // skipped deleter
	49356	+ case 4135LLU: // skipped deleter
49020	49357	{
49021	49358	stack[base + 22] = 0;
49022		- label = 4101LLU; // skip deleter
	49359	+ label = 4140LLU; // skip deleter
49023	49360	break;
49024	49361	}
49025		- case 4100LLU: // deleter
	49362	+ case 4139LLU: // deleter
49026	49363	{
49027	49364	// throw from procblock
49028	49365	if(!stack[base + 23])
49029	49366	{
49030		- label = 4095LLU; // skip, variable already deleted/unscoped
	49367	+ label = 4134LLU; // skip, variable already deleted/unscoped
49031	49368	break;
49032	49369	}
49033	49370

		@@ -49036,7 +49373,7 @@
49036	49373	newstack[0] = (uint64_t)stack; // backup stack location
49037	49374	newstack[1] = 1234567890;
49038	49375	newstack[2] = base;
49039		- newstack[3] = 4102LLU;
	49376	+ newstack[3] = 4141LLU;
49040	49377	stack = newstack;
49041	49378	// set stack-base & callee-address
49042	49379	base = 4/deloffset/;

		@@ -49043,21 +49380,21 @@
49043	49380	label = 558LLU; // ~scope
49044	49381	break;
49045	49382	}
49046		- case 4102LLU: // return from ~scope to procblock
	49383	+ case 4141LLU: // return from ~scope to procblock
49047	49384	{
49048	49385	stack = (uint64_t *)stack[0];
49049	49386	// releasing toplevel container
49050	49387	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
49051	49388
49052		- label = 4095LLU; // continue unrolling stack, delete next variable
	49389	+ label = 4134LLU; // continue unrolling stack, delete next variable
49053	49390	break;
49054	49391	}
49055		- case 4101LLU: // skipped deleter
	49392	+ case 4140LLU: // skipped deleter
49056	49393	{
49057	49394	// call linkscope from procblock
49058		- stack[base + 24LLU] = 4103LLU/throw to this address/;
	49395	+ stack[base + 24LLU] = 4142LLU/throw to this address/;
49059	49396	stack[base + 25LLU] = base;
49060		- stack[base + 26LLU] = 4104LLU;
	49397	+ stack[base + 26LLU] = 4143LLU;
49061	49398	// arguments for call to linkscope
49062	49399	stack[base + 28LLU] = stack[base + 3]/scope/;
49063	49400	// set stack-base & callee-address

		@@ -49065,21 +49402,21 @@
49065	49402	label = 585LLU; // linkscope
49066	49403	break;
49067	49404	}
49068		- case 4103LLU: // copy-back deleter (linkscope to procblock)
	49405	+ case 4142LLU: // copy-back deleter (linkscope to procblock)
49069	49406	{
49070	49407	// copy mutable arguments back from call to linkscope
49071		- label = 4095LLU; // continue to roll stack
	49408	+ label = 4134LLU; // continue to roll stack
49072	49409	break;
49073	49410	}
49074		- case 4104LLU: // return from linkscope to procblock
	49411	+ case 4143LLU: // return from linkscope to procblock
49075	49412	{
49076	49413	// copy mutable arguments back from call to linkscope
49077	49414	// copy back results provided by call to linkscope
49078	49415	stack[base + 23] = stack[base + 27LLU];
49079	49416	// call skipwscmnt from procblock
49080		- stack[base + 24LLU] = 4105LLU/throw to this address/;
	49417	+ stack[base + 24LLU] = 4144LLU/throw to this address/;
49081	49418	stack[base + 25LLU] = base;
49082		- stack[base + 26LLU] = 4106LLU;
	49419	+ stack[base + 26LLU] = 4145LLU;
49083	49420	// arguments for call to skipwscmnt
49084	49421	stack[base + 28LLU] = stack[base + 19]/lookahead/;
49085	49422	// set stack-base & callee-address

		@@ -49087,21 +49424,21 @@
49087	49424	label = 18446744073709551580LLU; // skipwscmnt
49088	49425	break;
49089	49426	}
49090		- case 4105LLU: // copy-back deleter (skipwscmnt to procblock)
	49427	+ case 4144LLU: // copy-back deleter (skipwscmnt to procblock)
49091	49428	{
49092	49429	// copy mutable arguments back from call to skipwscmnt
49093		- label = 4100LLU; // continue to roll stack
	49430	+ label = 4139LLU; // continue to roll stack
49094	49431	break;
49095	49432	}
49096		- case 4106LLU: // return from skipwscmnt to procblock
	49433	+ case 4145LLU: // return from skipwscmnt to procblock
49097	49434	{
49098	49435	// copy mutable arguments back from call to skipwscmnt
49099	49436	// copy back results provided by call to skipwscmnt
49100	49437	stack[base + 19] = stack[base + 27LLU];
49101	49438	// call equ from procblock
49102		- stack[base + 24LLU] = 4107LLU/throw to this address/;
	49439	+ stack[base + 24LLU] = 4146LLU/throw to this address/;
49103	49440	stack[base + 25LLU] = base;
49104		- stack[base + 26LLU] = 4108LLU;
	49441	+ stack[base + 26LLU] = 4147LLU;
49105	49442	// arguments for call to equ
49106	49443	stack[base + 28LLU] = stack[base + 19]/lookahead/;
49107	49444	stack[base + 29LLU] = 41LLU;

		@@ -49110,13 +49447,13 @@
49110	49447	label = 18446744073709551600LLU; // equ
49111	49448	break;
49112	49449	}
49113		- case 4107LLU: // copy-back deleter (equ to procblock)
	49450	+ case 4146LLU: // copy-back deleter (equ to procblock)
49114	49451	{
49115	49452	// copy mutable arguments back from call to equ
49116		- label = 4100LLU; // continue to roll stack
	49453	+ label = 4139LLU; // continue to roll stack
49117	49454	break;
49118	49455	}
49119		- case 4108LLU: // return from equ to procblock
	49456	+ case 4147LLU: // return from equ to procblock
49120	49457	{
49121	49458	// copy mutable arguments back from call to equ
49122	49459	// copy back results provided by call to equ

		@@ -49123,36 +49460,36 @@
49123	49460	stack[base + 20] = stack[base + 27LLU];
49124	49461	if(!stack[base + 20]/isequal/)
49125	49462	{
49126		- label = 4109LLU; // jump to alternative
	49463	+ label = 4148LLU; // jump to alternative
49127	49464	break;
49128	49465	}
49129	49466
49130	49467	// consequent
49131		- label = 4110LLU; // consequent complete
	49468	+ label = 4149LLU; // consequent complete
49132	49469	break;
49133	49470	}
49134		- case 4109LLU: // alternative
	49471	+ case 4148LLU: // alternative
49135	49472	{
49136		- label = 4112LLU; // skip deleter
	49473	+ label = 4151LLU; // skip deleter
49137	49474	break;
49138	49475	}
49139		- case 4111LLU: // deleter
	49476	+ case 4150LLU: // deleter
49140	49477	{
49141	49478	// throw from procblock
49142	49479	if(!stack[base + 24])
49143	49480	{
49144		- label = 4100LLU; // skip, variable already deleted/unscoped
	49481	+ label = 4139LLU; // skip, variable already deleted/unscoped
49145	49482	break;
49146	49483	}
49147	49484	// delete list
49148		- label = 4113LLU; // start to repeat
	49485	+ label = 4152LLU; // start to repeat
49149	49486	break;
49150	49487	}
49151		- case 4113LLU: // repeat from here
	49488	+ case 4152LLU: // repeat from here
49152	49489	{
49153	49490	if(!stack[base + 24])
49154	49491	{
49155		- label = 4114LLU; // break loop
	49492	+ label = 4153LLU; // break loop
49156	49493	break;
49157	49494	}
49158	49495

		@@ -49162,33 +49499,33 @@
49162	49499	stack[base + 24] = (uint64_t)list->next;
49163	49500	Free(1, sizeof(struct listnode), list);
49164	49501	}
49165		- label = 4113LLU; // repeat
	49502	+ label = 4152LLU; // repeat
49166	49503	break;
49167	49504	}
49168		- case 4114LLU: // loop finished
	49505	+ case 4153LLU: // loop finished
49169	49506	{
49170		- label = 4100LLU; // continue unrolling stack, delete next variable
	49507	+ label = 4139LLU; // continue unrolling stack, delete next variable
49171	49508	break;
49172	49509	}
49173		- case 4112LLU: // skipped deleter
	49510	+ case 4151LLU: // skipped deleter
49174	49511	{
49175	49512	stack[base + 24] = 0;
49176		- label = 4115LLU; // start to repeat
	49513	+ label = 4154LLU; // start to repeat
49177	49514	break;
49178	49515	}
49179		- case 4115LLU: // repeat from here
	49516	+ case 4154LLU: // repeat from here
49180	49517	{
49181	49518	if(stack[base + 19]/lookahead/ > 0xFF)
49182	49519	{
49183		- label = 4116LLU; // break loop
	49520	+ label = 4155LLU; // break loop
49184	49521	break;
49185	49522	}
49186	49523
49187	49524	// loop body
49188	49525	// call ParseToken from procblock
49189		- stack[base + 25LLU] = 4117LLU/throw to this address/;
	49526	+ stack[base + 25LLU] = 4156LLU/throw to this address/;
49190	49527	stack[base + 26LLU] = base;
49191		- stack[base + 27LLU] = 4118LLU;
	49528	+ stack[base + 27LLU] = 4157LLU;
49192	49529	// arguments for call to ParseToken
49193	49530	stack[base + 30LLU] = stack[base + 19]/lookahead/;
49194	49531	// set stack-base & callee-address

		@@ -49196,14 +49533,14 @@
49196	49533	label = 3LLU; // ParseToken
49197	49534	break;
49198	49535	}
49199		- case 4117LLU: // copy-back deleter (ParseToken to procblock)
	49536	+ case 4156LLU: // copy-back deleter (ParseToken to procblock)
49200	49537	{
49201	49538	// copy mutable arguments back from call to ParseToken
49202	49539	stack[base + 19]/lookahead/ = stack[base + 30LLU];
49203		- label = 4111LLU; // continue to roll stack
	49540	+ label = 4150LLU; // continue to roll stack
49204	49541	break;
49205	49542	}
49206		- case 4118LLU: // return from ParseToken to procblock
	49543	+ case 4157LLU: // return from ParseToken to procblock
49207	49544	{
49208	49545	// copy mutable arguments back from call to ParseToken
49209	49546	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -49210,26 +49547,26 @@
49210	49547	// copy back results provided by call to ParseToken
49211	49548	stack[base + 15] = stack[base + 28LLU];
49212	49549	stack[base + 16] = stack[base + 29LLU];
49213		- label = 4120LLU; // skip deleter
	49550	+ label = 4159LLU; // skip deleter
49214	49551	break;
49215	49552	}
49216		- case 4119LLU: // deleter
	49553	+ case 4158LLU: // deleter
49217	49554	{
49218	49555	// throw from procblock
49219	49556	if(!stack[base + 25])
49220	49557	{
49221		- label = 4111LLU; // skip, variable already deleted/unscoped
	49558	+ label = 4150LLU; // skip, variable already deleted/unscoped
49222	49559	break;
49223	49560	}
49224		- label = 4111LLU; // continue unrolling stack, delete next variable
	49561	+ label = 4150LLU; // continue unrolling stack, delete next variable
49225	49562	break;
49226	49563	}
49227		- case 4120LLU: // skipped deleter
	49564	+ case 4159LLU: // skipped deleter
49228	49565	{
49229	49566	// call equ from procblock
49230		- stack[base + 26LLU] = 4121LLU/throw to this address/;
	49567	+ stack[base + 26LLU] = 4160LLU/throw to this address/;
49231	49568	stack[base + 27LLU] = base;
49232		- stack[base + 28LLU] = 4122LLU;
	49569	+ stack[base + 28LLU] = 4161LLU;
49233	49570	// arguments for call to equ
49234	49571	stack[base + 30LLU] = stack[base + 15]/variant/;
49235	49572	stack[base + 31LLU] = 4LLU;

		@@ -49238,13 +49575,13 @@
49238	49575	label = 18446744073709551600LLU; // equ
49239	49576	break;
49240	49577	}
49241		- case 4121LLU: // copy-back deleter (equ to procblock)
	49578	+ case 4160LLU: // copy-back deleter (equ to procblock)
49242	49579	{
49243	49580	// copy mutable arguments back from call to equ
49244		- label = 4111LLU; // continue to roll stack
	49581	+ label = 4150LLU; // continue to roll stack
49245	49582	break;
49246	49583	}
49247		- case 4122LLU: // return from equ to procblock
	49584	+ case 4161LLU: // return from equ to procblock
49248	49585	{
49249	49586	// copy mutable arguments back from call to equ
49250	49587	// copy back results provided by call to equ

		@@ -49251,15 +49588,15 @@
49251	49588	stack[base + 20] = stack[base + 29LLU];
49252	49589	if(!stack[base + 20]/isequal/)
49253	49590	{
49254		- label = 4123LLU; // jump to alternative
	49591	+ label = 4162LLU; // jump to alternative
49255	49592	break;
49256	49593	}
49257	49594
49258	49595	// consequent
49259	49596	// call equ from procblock
49260		- stack[base + 26LLU] = 4125LLU/throw to this address/;
	49597	+ stack[base + 26LLU] = 4164LLU/throw to this address/;
49261	49598	stack[base + 27LLU] = base;
49262		- stack[base + 28LLU] = 4126LLU;
	49599	+ stack[base + 28LLU] = 4165LLU;
49263	49600	// arguments for call to equ
49264	49601	stack[base + 30LLU] = stack[base + 16]/content/;
49265	49602	stack[base + 31LLU] = 734293447447412736LLU;

		@@ -49268,13 +49605,13 @@
49268	49605	label = 18446744073709551600LLU; // equ
49269	49606	break;
49270	49607	}
49271		- case 4125LLU: // copy-back deleter (equ to procblock)
	49608	+ case 4164LLU: // copy-back deleter (equ to procblock)
49272	49609	{
49273	49610	// copy mutable arguments back from call to equ
49274		- label = 4111LLU; // continue to roll stack
	49611	+ label = 4150LLU; // continue to roll stack
49275	49612	break;
49276	49613	}
49277		- case 4126LLU: // return from equ to procblock
	49614	+ case 4165LLU: // return from equ to procblock
49278	49615	{
49279	49616	// copy mutable arguments back from call to equ
49280	49617	// copy back results provided by call to equ

		@@ -49281,15 +49618,15 @@
49281	49618	stack[base + 20] = stack[base + 29LLU];
49282	49619	if(!stack[base + 20]/isequal/)
49283	49620	{
49284		- label = 4127LLU; // jump to alternative
	49621	+ label = 4166LLU; // jump to alternative
49285	49622	break;
49286	49623	}
49287	49624
49288	49625	// consequent
49289	49626	// call ParseToken from procblock
49290		- stack[base + 26LLU] = 4129LLU/throw to this address/;
	49627	+ stack[base + 26LLU] = 4168LLU/throw to this address/;
49291	49628	stack[base + 27LLU] = base;
49292		- stack[base + 28LLU] = 4130LLU;
	49629	+ stack[base + 28LLU] = 4169LLU;
49293	49630	// arguments for call to ParseToken
49294	49631	stack[base + 31LLU] = stack[base + 19]/lookahead/;
49295	49632	// set stack-base & callee-address

		@@ -49297,14 +49634,14 @@
49297	49634	label = 3LLU; // ParseToken
49298	49635	break;
49299	49636	}
49300		- case 4129LLU: // copy-back deleter (ParseToken to procblock)
	49637	+ case 4168LLU: // copy-back deleter (ParseToken to procblock)
49301	49638	{
49302	49639	// copy mutable arguments back from call to ParseToken
49303	49640	stack[base + 19]/lookahead/ = stack[base + 31LLU];
49304		- label = 4111LLU; // continue to roll stack
	49641	+ label = 4150LLU; // continue to roll stack
49305	49642	break;
49306	49643	}
49307		- case 4130LLU: // return from ParseToken to procblock
	49644	+ case 4169LLU: // return from ParseToken to procblock
49308	49645	{
49309	49646	// copy mutable arguments back from call to ParseToken
49310	49647	stack[base + 19]/lookahead/ = stack[base + 31LLU];

		@@ -49311,86 +49648,86 @@
49311	49648	// copy back results provided by call to ParseToken
49312	49649	stack[base + 15] = stack[base + 29LLU];
49313	49650	stack[base + 16] = stack[base + 30LLU];
49314		- label = 4132LLU; // skip deleter
	49651	+ label = 4171LLU; // skip deleter
49315	49652	break;
49316	49653	}
49317		- case 4131LLU: // deleter
	49654	+ case 4170LLU: // deleter
49318	49655	{
49319	49656	// throw from procblock
49320	49657	if(!stack[base + 25])
49321	49658	{
49322		- label = 4111LLU; // skip, variable already deleted/unscoped
	49659	+ label = 4150LLU; // skip, variable already deleted/unscoped
49323	49660	break;
49324	49661	}
49325		- label = 4111LLU; // continue unrolling stack, delete next variable
	49662	+ label = 4150LLU; // continue unrolling stack, delete next variable
49326	49663	break;
49327	49664	}
49328		- case 4132LLU: // skipped deleter
	49665	+ case 4171LLU: // skipped deleter
49329	49666	{
49330	49667	stack[base + 25] = 1;
49331		- label = 4128LLU; // consequent complete
	49668	+ label = 4167LLU; // consequent complete
49332	49669	break;
49333	49670	}
49334		- case 4127LLU: // alternative
	49671	+ case 4166LLU: // alternative
49335	49672	{
49336		- label = 4134LLU; // skip deleter
	49673	+ label = 4173LLU; // skip deleter
49337	49674	break;
49338	49675	}
49339		- case 4133LLU: // deleter
	49676	+ case 4172LLU: // deleter
49340	49677	{
49341	49678	// throw from procblock
49342	49679	if(!stack[base + 25])
49343	49680	{
49344		- label = 4111LLU; // skip, variable already deleted/unscoped
	49681	+ label = 4150LLU; // skip, variable already deleted/unscoped
49345	49682	break;
49346	49683	}
49347		- label = 4111LLU; // continue unrolling stack, delete next variable
	49684	+ label = 4150LLU; // continue unrolling stack, delete next variable
49348	49685	break;
49349	49686	}
49350		- case 4134LLU: // skipped deleter
	49687	+ case 4173LLU: // skipped deleter
49351	49688	{
49352	49689	stack[base + 25] = 0;
49353		- label = 4128LLU; // alternative complete
	49690	+ label = 4167LLU; // alternative complete
49354	49691	break;
49355	49692	}
49356		- case 4128LLU: // completed if-then-else
	49693	+ case 4167LLU: // completed if-then-else
49357	49694	{
49358		- label = 4124LLU; // consequent complete
	49695	+ label = 4163LLU; // consequent complete
49359	49696	break;
49360	49697	}
49361		- case 4123LLU: // alternative
	49698	+ case 4162LLU: // alternative
49362	49699	{
49363		- label = 4136LLU; // skip deleter
	49700	+ label = 4175LLU; // skip deleter
49364	49701	break;
49365	49702	}
49366		- case 4135LLU: // deleter
	49703	+ case 4174LLU: // deleter
49367	49704	{
49368	49705	// throw from procblock
49369	49706	if(!stack[base + 25])
49370	49707	{
49371		- label = 4111LLU; // skip, variable already deleted/unscoped
	49708	+ label = 4150LLU; // skip, variable already deleted/unscoped
49372	49709	break;
49373	49710	}
49374		- label = 4111LLU; // continue unrolling stack, delete next variable
	49711	+ label = 4150LLU; // continue unrolling stack, delete next variable
49375	49712	break;
49376	49713	}
49377		- case 4136LLU: // skipped deleter
	49714	+ case 4175LLU: // skipped deleter
49378	49715	{
49379	49716	stack[base + 25] = 0;
49380		- label = 4124LLU; // alternative complete
	49717	+ label = 4163LLU; // alternative complete
49381	49718	break;
49382	49719	}
49383		- case 4124LLU: // completed if-then-else
	49720	+ case 4163LLU: // completed if-then-else
49384	49721	{
49385		- label = 4138LLU; // skip deleter
	49722	+ label = 4177LLU; // skip deleter
49386	49723	break;
49387	49724	}
49388		- case 4137LLU: // deleter
	49725	+ case 4176LLU: // deleter
49389	49726	{
49390	49727	// throw from procblock
49391	49728	if(!stack[base + 26])
49392	49729	{
49393		- label = 4119LLU; // skip, variable already deleted/unscoped
	49730	+ label = 4158LLU; // skip, variable already deleted/unscoped
49394	49731	break;
49395	49732	}
49396	49733

		@@ -49399,7 +49736,7 @@
49399	49736	newstack[0] = (uint64_t)stack; // backup stack location
49400	49737	newstack[1] = 1234567890;
49401	49738	newstack[2] = base;
49402		- newstack[3] = 4139LLU;
	49739	+ newstack[3] = 4178LLU;
49403	49740	stack = newstack;
49404	49741	// set stack-base & callee-address
49405	49742	base = 4/deloffset/;

		@@ -49406,21 +49743,21 @@
49406	49743	label = 306LLU; // ~type
49407	49744	break;
49408	49745	}
49409		- case 4139LLU: // return from ~type to procblock
	49746	+ case 4178LLU: // return from ~type to procblock
49410	49747	{
49411	49748	stack = (uint64_t *)stack[0];
49412	49749	// releasing toplevel container
49413	49750	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 26] - sizeof(uint64_t) 4));
49414	49751
49415		- label = 4119LLU; // continue unrolling stack, delete next variable
	49752	+ label = 4158LLU; // continue unrolling stack, delete next variable
49416	49753	break;
49417	49754	}
49418		- case 4138LLU: // skipped deleter
	49755	+ case 4177LLU: // skipped deleter
49419	49756	{
49420	49757	// call PARSETYPE from procblock
49421		- stack[base + 27LLU] = 4140LLU/throw to this address/;
	49758	+ stack[base + 27LLU] = 4179LLU/throw to this address/;
49422	49759	stack[base + 28LLU] = base;
49423		- stack[base + 29LLU] = 4141LLU;
	49760	+ stack[base + 29LLU] = 4180LLU;
49424	49761	// arguments for call to PARSETYPE
49425	49762	stack[base + 31LLU] = stack[base + 8]/fnid/;
49426	49763	stack[base + 32LLU] = stack[base + 15]/variant/;

		@@ -49431,16 +49768,16 @@
49431	49768	label = 932LLU; // PARSETYPE
49432	49769	break;
49433	49770	}
49434		- case 4140LLU: // copy-back deleter (PARSETYPE to procblock)
	49771	+ case 4179LLU: // copy-back deleter (PARSETYPE to procblock)
49435	49772	{
49436	49773	// copy mutable arguments back from call to PARSETYPE
49437	49774	stack[base + 19]/lookahead/ = stack[base + 34LLU];
49438	49775	stack[base + 16]/content/ = stack[base + 33LLU];
49439	49776	stack[base + 15]/variant/ = stack[base + 32LLU];
49440		- label = 4119LLU; // continue to roll stack
	49777	+ label = 4158LLU; // continue to roll stack
49441	49778	break;
49442	49779	}
49443		- case 4141LLU: // return from PARSETYPE to procblock
	49780	+ case 4180LLU: // return from PARSETYPE to procblock
49444	49781	{
49445	49782	// copy mutable arguments back from call to PARSETYPE
49446	49783	stack[base + 19]/lookahead/ = stack[base + 34LLU];

		@@ -49449,9 +49786,9 @@
49449	49786	// copy back results provided by call to PARSETYPE
49450	49787	stack[base + 26] = stack[base + 30LLU];
49451	49788	// call ParseToken from procblock
49452		- stack[base + 27LLU] = 4142LLU/throw to this address/;
	49789	+ stack[base + 27LLU] = 4181LLU/throw to this address/;
49453	49790	stack[base + 28LLU] = base;
49454		- stack[base + 29LLU] = 4143LLU;
	49791	+ stack[base + 29LLU] = 4182LLU;
49455	49792	// arguments for call to ParseToken
49456	49793	stack[base + 32LLU] = stack[base + 19]/lookahead/;
49457	49794	// set stack-base & callee-address

		@@ -49459,14 +49796,14 @@
49459	49796	label = 3LLU; // ParseToken
49460	49797	break;
49461	49798	}
49462		- case 4142LLU: // copy-back deleter (ParseToken to procblock)
	49799	+ case 4181LLU: // copy-back deleter (ParseToken to procblock)
49463	49800	{
49464	49801	// copy mutable arguments back from call to ParseToken
49465	49802	stack[base + 19]/lookahead/ = stack[base + 32LLU];
49466		- label = 4137LLU; // continue to roll stack
	49803	+ label = 4176LLU; // continue to roll stack
49467	49804	break;
49468	49805	}
49469		- case 4143LLU: // return from ParseToken to procblock
	49806	+ case 4182LLU: // return from ParseToken to procblock
49470	49807	{
49471	49808	// copy mutable arguments back from call to ParseToken
49472	49809	stack[base + 19]/lookahead/ = stack[base + 32LLU];

		@@ -49474,9 +49811,9 @@
49474	49811	stack[base + 15] = stack[base + 30LLU];
49475	49812	stack[base + 16] = stack[base + 31LLU];
49476	49813	// call equ from procblock
49477		- stack[base + 27LLU] = 4144LLU/throw to this address/;
	49814	+ stack[base + 27LLU] = 4183LLU/throw to this address/;
49478	49815	stack[base + 28LLU] = base;
49479		- stack[base + 29LLU] = 4145LLU;
	49816	+ stack[base + 29LLU] = 4184LLU;
49480	49817	// arguments for call to equ
49481	49818	stack[base + 31LLU] = stack[base + 15]/variant/;
49482	49819	stack[base + 32LLU] = 4LLU;

		@@ -49485,13 +49822,13 @@
49485	49822	label = 18446744073709551600LLU; // equ
49486	49823	break;
49487	49824	}
49488		- case 4144LLU: // copy-back deleter (equ to procblock)
	49825	+ case 4183LLU: // copy-back deleter (equ to procblock)
49489	49826	{
49490	49827	// copy mutable arguments back from call to equ
49491		- label = 4137LLU; // continue to roll stack
	49828	+ label = 4176LLU; // continue to roll stack
49492	49829	break;
49493	49830	}
49494		- case 4145LLU: // return from equ to procblock
	49831	+ case 4184LLU: // return from equ to procblock
49495	49832	{
49496	49833	// copy mutable arguments back from call to equ
49497	49834	// copy back results provided by call to equ

		@@ -49498,21 +49835,21 @@
49498	49835	stack[base + 20] = stack[base + 30LLU];
49499	49836	if(!stack[base + 20]/isequal/)
49500	49837	{
49501		- label = 4146LLU; // jump to alternative
	49838	+ label = 4185LLU; // jump to alternative
49502	49839	break;
49503	49840	}
49504	49841
49505	49842	// consequent
49506		- label = 4147LLU; // consequent complete
	49843	+ label = 4186LLU; // consequent complete
49507	49844	break;
49508	49845	}
49509		- case 4146LLU: // alternative
	49846	+ case 4185LLU: // alternative
49510	49847	{
49511	49848	fprintf(stderr, "%s", "let expects identifier but found ");
49512	49849	// call reporttok from procblock
49513		- stack[base + 27LLU] = 4148LLU/throw to this address/;
	49850	+ stack[base + 27LLU] = 4187LLU/throw to this address/;
49514	49851	stack[base + 28LLU] = base;
49515		- stack[base + 29LLU] = 4149LLU;
	49852	+ stack[base + 29LLU] = 4188LLU;
49516	49853	// arguments for call to reporttok
49517	49854	stack[base + 30LLU] = stack[base + 15]/variant/;
49518	49855	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -49521,29 +49858,29 @@
49521	49858	label = 18446744073709551582LLU; // reporttok
49522	49859	break;
49523	49860	}
49524		- case 4148LLU: // copy-back deleter (reporttok to procblock)
	49861	+ case 4187LLU: // copy-back deleter (reporttok to procblock)
49525	49862	{
49526	49863	// copy mutable arguments back from call to reporttok
49527		- label = 4137LLU; // continue to roll stack
	49864	+ label = 4176LLU; // continue to roll stack
49528	49865	break;
49529	49866	}
49530		- case 4149LLU: // return from reporttok to procblock
	49867	+ case 4188LLU: // return from reporttok to procblock
49531	49868	{
49532	49869	// copy mutable arguments back from call to reporttok
49533	49870	{
49534		- label = 4137LLU; // throw: begin to unroll stack
	49871	+ label = 4176LLU; // throw: begin to unroll stack
49535	49872	break;
49536	49873	}
49537	49874
49538		- label = 4147LLU; // alternative complete
	49875	+ label = 4186LLU; // alternative complete
49539	49876	break;
49540	49877	}
49541		- case 4147LLU: // completed if-then-else
	49878	+ case 4186LLU: // completed if-then-else
49542	49879	{
49543	49880	// call existsid from procblock
49544		- stack[base + 27LLU] = 4150LLU/throw to this address/;
	49881	+ stack[base + 27LLU] = 4189LLU/throw to this address/;
49545	49882	stack[base + 28LLU] = base;
49546		- stack[base + 29LLU] = 4151LLU;
	49883	+ stack[base + 29LLU] = 4190LLU;
49547	49884	// arguments for call to existsid
49548	49885	stack[base + 31LLU] = stack[base + 24]/letids/;
49549	49886	stack[base + 32LLU] = stack[base + 16]/content/;

		@@ -49552,13 +49889,13 @@
49552	49889	label = 153LLU; // existsid
49553	49890	break;
49554	49891	}
49555		- case 4150LLU: // copy-back deleter (existsid to procblock)
	49892	+ case 4189LLU: // copy-back deleter (existsid to procblock)
49556	49893	{
49557	49894	// copy mutable arguments back from call to existsid
49558		- label = 4137LLU; // continue to roll stack
	49895	+ label = 4176LLU; // continue to roll stack
49559	49896	break;
49560	49897	}
49561		- case 4151LLU: // return from existsid to procblock
	49898	+ case 4190LLU: // return from existsid to procblock
49562	49899	{
49563	49900	// copy mutable arguments back from call to existsid
49564	49901	// copy back results provided by call to existsid

		@@ -49565,7 +49902,7 @@
49565	49902	stack[base + 20] = stack[base + 30LLU];
49566	49903	if(!stack[base + 20]/isequal/)
49567	49904	{
49568		- label = 4152LLU; // jump to alternative
	49905	+ label = 4191LLU; // jump to alternative
49569	49906	break;
49570	49907	}
49571	49908

		@@ -49572,9 +49909,9 @@
49572	49909	// consequent
49573	49910	fprintf(stderr, "%s", "in function ");
49574	49911	// call reportid from procblock
49575		- stack[base + 27LLU] = 4154LLU/throw to this address/;
	49912	+ stack[base + 27LLU] = 4193LLU/throw to this address/;
49576	49913	stack[base + 28LLU] = base;
49577		- stack[base + 29LLU] = 4155LLU;
	49914	+ stack[base + 29LLU] = 4194LLU;
49578	49915	// arguments for call to reportid
49579	49916	stack[base + 30LLU] = stack[base + 8]/fnid/;
49580	49917	// set stack-base & callee-address

		@@ -49582,21 +49919,21 @@
49582	49919	label = 18446744073709551586LLU; // reportid
49583	49920	break;
49584	49921	}
49585		- case 4154LLU: // copy-back deleter (reportid to procblock)
	49922	+ case 4193LLU: // copy-back deleter (reportid to procblock)
49586	49923	{
49587	49924	// copy mutable arguments back from call to reportid
49588		- label = 4137LLU; // continue to roll stack
	49925	+ label = 4176LLU; // continue to roll stack
49589	49926	break;
49590	49927	}
49591		- case 4155LLU: // return from reportid to procblock
	49928	+ case 4194LLU: // return from reportid to procblock
49592	49929	{
49593	49930	// copy mutable arguments back from call to reportid
49594	49931	fprintf(stderr, "%s", ": ");
49595	49932	fprintf(stderr, "%s", "duplicate variable ");
49596	49933	// call reportid from procblock
49597		- stack[base + 27LLU] = 4156LLU/throw to this address/;
	49934	+ stack[base + 27LLU] = 4195LLU/throw to this address/;
49598	49935	stack[base + 28LLU] = base;
49599		- stack[base + 29LLU] = 4157LLU;
	49936	+ stack[base + 29LLU] = 4196LLU;
49600	49937	// arguments for call to reportid
49601	49938	stack[base + 30LLU] = stack[base + 16]/content/;
49602	49939	// set stack-base & callee-address

		@@ -49604,25 +49941,25 @@
49604	49941	label = 18446744073709551586LLU; // reportid
49605	49942	break;
49606	49943	}
49607		- case 4156LLU: // copy-back deleter (reportid to procblock)
	49944	+ case 4195LLU: // copy-back deleter (reportid to procblock)
49608	49945	{
49609	49946	// copy mutable arguments back from call to reportid
49610		- label = 4137LLU; // continue to roll stack
	49947	+ label = 4176LLU; // continue to roll stack
49611	49948	break;
49612	49949	}
49613		- case 4157LLU: // return from reportid to procblock
	49950	+ case 4196LLU: // return from reportid to procblock
49614	49951	{
49615	49952	// copy mutable arguments back from call to reportid
49616	49953	fprintf(stderr, "%s", " in let\n");
49617	49954	{
49618		- label = 4137LLU; // throw: begin to unroll stack
	49955	+ label = 4176LLU; // throw: begin to unroll stack
49619	49956	break;
49620	49957	}
49621	49958
49622		- label = 4153LLU; // consequent complete
	49959	+ label = 4192LLU; // consequent complete
49623	49960	break;
49624	49961	}
49625		- case 4152LLU: // alternative
	49962	+ case 4191LLU: // alternative
49626	49963	{
49627	49964	{
49628	49965	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));

		@@ -49637,31 +49974,31 @@
49637	49974	stack[base + 24]/letids/ = (uint64_t)list;
49638	49975	list->data = stack[base + 16]/content/;
49639	49976	}
49640		- label = 4153LLU; // alternative complete
	49977	+ label = 4192LLU; // alternative complete
49641	49978	break;
49642	49979	}
49643		- case 4153LLU: // completed if-then-else
	49980	+ case 4192LLU: // completed if-then-else
49644	49981	{
49645		- label = 4159LLU; // skip deleter
	49982	+ label = 4198LLU; // skip deleter
49646	49983	break;
49647	49984	}
49648		- case 4158LLU: // deleter
	49985	+ case 4197LLU: // deleter
49649	49986	{
49650	49987	// throw from procblock
49651	49988	if(!stack[base + 27])
49652	49989	{
49653		- label = 4137LLU; // skip, variable already deleted/unscoped
	49990	+ label = 4176LLU; // skip, variable already deleted/unscoped
49654	49991	break;
49655	49992	}
49656		- label = 4137LLU; // continue unrolling stack, delete next variable
	49993	+ label = 4176LLU; // continue unrolling stack, delete next variable
49657	49994	break;
49658	49995	}
49659		- case 4159LLU: // skipped deleter
	49996	+ case 4198LLU: // skipped deleter
49660	49997	{
49661	49998	// call newvarraw from procblock
49662		- stack[base + 28LLU] = 4160LLU/throw to this address/;
	49999	+ stack[base + 28LLU] = 4199LLU/throw to this address/;
49663	50000	stack[base + 29LLU] = base;
49664		- stack[base + 30LLU] = 4161LLU;
	50001	+ stack[base + 30LLU] = 4200LLU;
49665	50002	// arguments for call to newvarraw
49666	50003	stack[base + 32LLU] = stack[base + 26]/type/;
49667	50004	stack[base + 33LLU] = stack[base + 16]/content/;

		@@ -49677,16 +50014,16 @@
49677	50014	label = 755LLU; // newvarraw
49678	50015	break;
49679	50016	}
49680		- case 4160LLU: // copy-back deleter (newvarraw to procblock)
	50017	+ case 4199LLU: // copy-back deleter (newvarraw to procblock)
49681	50018	{
49682	50019	// copy mutable arguments back from call to newvarraw
49683	50020	stack[base + 23]/NEWSCOPE/ = stack[base + 39LLU];
49684	50021	stack[base + 18]/varcount/ = stack[base + 38LLU];
49685	50022	stack[base + 12]/fnmaxcount/ = stack[base + 37LLU];
49686		- label = 4137LLU; // continue to roll stack
	50023	+ label = 4176LLU; // continue to roll stack
49687	50024	break;
49688	50025	}
49689		- case 4161LLU: // return from newvarraw to procblock
	50026	+ case 4200LLU: // return from newvarraw to procblock
49690	50027	{
49691	50028	// copy mutable arguments back from call to newvarraw
49692	50029	stack[base + 23]/NEWSCOPE/ = stack[base + 39LLU];

		@@ -49694,26 +50031,26 @@
49694	50031	stack[base + 12]/fnmaxcount/ = stack[base + 37LLU];
49695	50032	// copy back results provided by call to newvarraw
49696	50033	stack[base + 27] = stack[base + 31LLU];
49697		- label = 4163LLU; // skip deleter
	50034	+ label = 4202LLU; // skip deleter
49698	50035	break;
49699	50036	}
49700		- case 4162LLU: // deleter
	50037	+ case 4201LLU: // deleter
49701	50038	{
49702	50039	// throw from procblock
49703	50040	if(!stack[base + 28])
49704	50041	{
49705		- label = 4158LLU; // skip, variable already deleted/unscoped
	50042	+ label = 4197LLU; // skip, variable already deleted/unscoped
49706	50043	break;
49707	50044	}
49708		- label = 4158LLU; // continue unrolling stack, delete next variable
	50045	+ label = 4197LLU; // continue unrolling stack, delete next variable
49709	50046	break;
49710	50047	}
49711		- case 4163LLU: // skipped deleter
	50048	+ case 4202LLU: // skipped deleter
49712	50049	{
49713	50050	// call getdeladdr from procblock
49714		- stack[base + 29LLU] = 4164LLU/throw to this address/;
	50051	+ stack[base + 29LLU] = 4203LLU/throw to this address/;
49715	50052	stack[base + 30LLU] = base;
49716		- stack[base + 31LLU] = 4165LLU;
	50053	+ stack[base + 31LLU] = 4204LLU;
49717	50054	// arguments for call to getdeladdr
49718	50055	stack[base + 33LLU] = stack[base + 23]/NEWSCOPE/;
49719	50056	// set stack-base & callee-address

		@@ -49721,37 +50058,37 @@
49721	50058	label = 592LLU; // getdeladdr
49722	50059	break;
49723	50060	}
49724		- case 4164LLU: // copy-back deleter (getdeladdr to procblock)
	50061	+ case 4203LLU: // copy-back deleter (getdeladdr to procblock)
49725	50062	{
49726	50063	// copy mutable arguments back from call to getdeladdr
49727		- label = 4158LLU; // continue to roll stack
	50064	+ label = 4197LLU; // continue to roll stack
49728	50065	break;
49729	50066	}
49730		- case 4165LLU: // return from getdeladdr to procblock
	50067	+ case 4204LLU: // return from getdeladdr to procblock
49731	50068	{
49732	50069	// copy mutable arguments back from call to getdeladdr
49733	50070	// copy back results provided by call to getdeladdr
49734	50071	stack[base + 28] = stack[base + 32LLU];
49735		- label = 4167LLU; // skip deleter
	50072	+ label = 4206LLU; // skip deleter
49736	50073	break;
49737	50074	}
49738		- case 4166LLU: // deleter
	50075	+ case 4205LLU: // deleter
49739	50076	{
49740	50077	// throw from procblock
49741	50078	if(!stack[base + 29])
49742	50079	{
49743		- label = 4162LLU; // skip, variable already deleted/unscoped
	50080	+ label = 4201LLU; // skip, variable already deleted/unscoped
49744	50081	break;
49745	50082	}
49746		- label = 4162LLU; // continue unrolling stack, delete next variable
	50083	+ label = 4201LLU; // continue unrolling stack, delete next variable
49747	50084	break;
49748	50085	}
49749		- case 4167LLU: // skipped deleter
	50086	+ case 4206LLU: // skipped deleter
49750	50087	{
49751	50088	// call emitdelete from procblock
49752		- stack[base + 30LLU] = 4168LLU/throw to this address/;
	50089	+ stack[base + 30LLU] = 4207LLU/throw to this address/;
49753	50090	stack[base + 31LLU] = base;
49754		- stack[base + 32LLU] = 4169LLU;
	50091	+ stack[base + 32LLU] = 4208LLU;
49755	50092	// arguments for call to emitdelete
49756	50093	stack[base + 34LLU] = stack[base + 8]/fnid/;
49757	50094	stack[base + 35LLU] = stack[base + 26]/type/;

		@@ -49765,14 +50102,14 @@
49765	50102	label = 2402LLU; // emitdelete
49766	50103	break;
49767	50104	}
49768		- case 4168LLU: // copy-back deleter (emitdelete to procblock)
	50105	+ case 4207LLU: // copy-back deleter (emitdelete to procblock)
49769	50106	{
49770	50107	// copy mutable arguments back from call to emitdelete
49771	50108	stack[base + 17]/label/ = stack[base + 40LLU];
49772		- label = 4162LLU; // continue to roll stack
	50109	+ label = 4201LLU; // continue to roll stack
49773	50110	break;
49774	50111	}
49775		- case 4169LLU: // return from emitdelete to procblock
	50112	+ case 4208LLU: // return from emitdelete to procblock
49776	50113	{
49777	50114	// copy mutable arguments back from call to emitdelete
49778	50115	stack[base + 17]/label/ = stack[base + 40LLU];

		@@ -49779,9 +50116,9 @@
49779	50116	// copy back results provided by call to emitdelete
49780	50117	stack[base + 29] = stack[base + 33LLU];
49781	50118	// call linkthrow from procblock
49782		- stack[base + 30LLU] = 4170LLU/throw to this address/;
	50119	+ stack[base + 30LLU] = 4209LLU/throw to this address/;
49783	50120	stack[base + 31LLU] = base;
49784		- stack[base + 32LLU] = 4171LLU;
	50121	+ stack[base + 32LLU] = 4210LLU;
49785	50122	// arguments for call to linkthrow
49786	50123	stack[base + 33LLU] = stack[base + 23]/NEWSCOPE/;
49787	50124	stack[base + 34LLU] = stack[base + 29]/labelfail/;

		@@ -49790,26 +50127,26 @@
49790	50127	label = 1693LLU; // linkthrow
49791	50128	break;
49792	50129	}
49793		- case 4170LLU: // copy-back deleter (linkthrow to procblock)
	50130	+ case 4209LLU: // copy-back deleter (linkthrow to procblock)
49794	50131	{
49795	50132	// copy mutable arguments back from call to linkthrow
49796	50133	stack[base + 23]/NEWSCOPE/ = stack[base + 33LLU];
49797		- label = 4166LLU; // continue to roll stack
	50134	+ label = 4205LLU; // continue to roll stack
49798	50135	break;
49799	50136	}
49800		- case 4171LLU: // return from linkthrow to procblock
	50137	+ case 4210LLU: // return from linkthrow to procblock
49801	50138	{
49802	50139	// copy mutable arguments back from call to linkthrow
49803	50140	stack[base + 23]/NEWSCOPE/ = stack[base + 33LLU];
49804		- label = 4173LLU; // skip deleter
	50141	+ label = 4212LLU; // skip deleter
49805	50142	break;
49806	50143	}
49807		- case 4172LLU: // deleter
	50144	+ case 4211LLU: // deleter
49808	50145	{
49809	50146	// throw from procblock
49810	50147	if(!stack[base + 28])
49811	50148	{
49812		- label = 4158LLU; // skip, variable already deleted/unscoped
	50149	+ label = 4197LLU; // skip, variable already deleted/unscoped
49813	50150	break;
49814	50151	}
49815	50152

		@@ -49818,7 +50155,7 @@
49818	50155	newstack[0] = (uint64_t)stack; // backup stack location
49819	50156	newstack[1] = 1234567890;
49820	50157	newstack[2] = base;
49821		- newstack[3] = 4174LLU;
	50158	+ newstack[3] = 4213LLU;
49822	50159	stack = newstack;
49823	50160	// set stack-base & callee-address
49824	50161	base = 4/deloffset/;

		@@ -49825,21 +50162,21 @@
49825	50162	label = 395LLU; // ~typeidx
49826	50163	break;
49827	50164	}
49828		- case 4174LLU: // return from ~typeidx to procblock
	50165	+ case 4213LLU: // return from ~typeidx to procblock
49829	50166	{
49830	50167	stack = (uint64_t *)stack[0];
49831	50168	// releasing toplevel container
49832	50169	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
49833	50170
49834		- label = 4158LLU; // continue unrolling stack, delete next variable
	50171	+ label = 4197LLU; // continue unrolling stack, delete next variable
49835	50172	break;
49836	50173	}
49837		- case 4173LLU: // skipped deleter
	50174	+ case 4212LLU: // skipped deleter
49838	50175	{
49839	50176	// construct typeidx.typeidx
49840	50177	if(!(stack[base + 28] = construct(2)))
49841	50178	{
49842		- label = 4158LLU; // throw: begin to unroll stack
	50179	+ label = 4197LLU; // throw: begin to unroll stack
49843	50180	break;
49844	50181	}
49845	50182

		@@ -49861,9 +50198,9 @@
49861	50198	MOVE(&list->data, &stack[base + 28]/typeidx/);
49862	50199	}
49863	50200	// call skipwscmnt from procblock
49864		- stack[base + 29LLU] = 4175LLU/throw to this address/;
	50201	+ stack[base + 29LLU] = 4214LLU/throw to this address/;
49865	50202	stack[base + 30LLU] = base;
49866		- stack[base + 31LLU] = 4176LLU;
	50203	+ stack[base + 31LLU] = 4215LLU;
49867	50204	// arguments for call to skipwscmnt
49868	50205	stack[base + 33LLU] = stack[base + 19]/lookahead/;
49869	50206	// set stack-base & callee-address

		@@ -49871,37 +50208,37 @@
49871	50208	label = 18446744073709551580LLU; // skipwscmnt
49872	50209	break;
49873	50210	}
49874		- case 4175LLU: // copy-back deleter (skipwscmnt to procblock)
	50211	+ case 4214LLU: // copy-back deleter (skipwscmnt to procblock)
49875	50212	{
49876	50213	// copy mutable arguments back from call to skipwscmnt
49877		- label = 4172LLU; // continue to roll stack
	50214	+ label = 4211LLU; // continue to roll stack
49878	50215	break;
49879	50216	}
49880		- case 4176LLU: // return from skipwscmnt to procblock
	50217	+ case 4215LLU: // return from skipwscmnt to procblock
49881	50218	{
49882	50219	// copy mutable arguments back from call to skipwscmnt
49883	50220	// copy back results provided by call to skipwscmnt
49884	50221	stack[base + 19] = stack[base + 32LLU];
49885		- label = 4178LLU; // skip deleter
	50222	+ label = 4217LLU; // skip deleter
49886	50223	break;
49887	50224	}
49888		- case 4177LLU: // deleter
	50225	+ case 4216LLU: // deleter
49889	50226	{
49890	50227	// throw from procblock
49891	50228	if(!stack[base + 29])
49892	50229	{
49893		- label = 4172LLU; // skip, variable already deleted/unscoped
	50230	+ label = 4211LLU; // skip, variable already deleted/unscoped
49894	50231	break;
49895	50232	}
49896		- label = 4172LLU; // continue unrolling stack, delete next variable
	50233	+ label = 4211LLU; // continue unrolling stack, delete next variable
49897	50234	break;
49898	50235	}
49899		- case 4178LLU: // skipped deleter
	50236	+ case 4217LLU: // skipped deleter
49900	50237	{
49901	50238	// call neq from procblock
49902		- stack[base + 30LLU] = 4179LLU/throw to this address/;
	50239	+ stack[base + 30LLU] = 4218LLU/throw to this address/;
49903	50240	stack[base + 31LLU] = base;
49904		- stack[base + 32LLU] = 4180LLU;
	50241	+ stack[base + 32LLU] = 4219LLU;
49905	50242	// arguments for call to neq
49906	50243	stack[base + 34LLU] = stack[base + 19]/lookahead/;
49907	50244	stack[base + 35LLU] = 41LLU;

		@@ -49910,13 +50247,13 @@
49910	50247	label = 18446744073709551599LLU; // neq
49911	50248	break;
49912	50249	}
49913		- case 4179LLU: // copy-back deleter (neq to procblock)
	50250	+ case 4218LLU: // copy-back deleter (neq to procblock)
49914	50251	{
49915	50252	// copy mutable arguments back from call to neq
49916		- label = 4172LLU; // continue to roll stack
	50253	+ label = 4211LLU; // continue to roll stack
49917	50254	break;
49918	50255	}
49919		- case 4180LLU: // return from neq to procblock
	50256	+ case 4219LLU: // return from neq to procblock
49920	50257	{
49921	50258	// copy mutable arguments back from call to neq
49922	50259	// copy back results provided by call to neq

		@@ -49923,15 +50260,15 @@
49923	50260	stack[base + 29] = stack[base + 33LLU];
49924	50261	if(!stack[base + 29]/continue/)
49925	50262	{
49926		- label = 4181LLU; // jump to alternative
	50263	+ label = 4220LLU; // jump to alternative
49927	50264	break;
49928	50265	}
49929	50266
49930	50267	// consequent
49931	50268	// call MATCHPEEK from procblock
49932		- stack[base + 30LLU] = 4183LLU/throw to this address/;
	50269	+ stack[base + 30LLU] = 4222LLU/throw to this address/;
49933	50270	stack[base + 31LLU] = base;
49934		- stack[base + 32LLU] = 4184LLU;
	50271	+ stack[base + 32LLU] = 4223LLU;
49935	50272	// arguments for call to MATCHPEEK
49936	50273	stack[base + 33LLU] = stack[base + 8]/fnid/;
49937	50274	stack[base + 34LLU] = 44LLU;

		@@ -49941,26 +50278,26 @@
49941	50278	label = 206LLU; // MATCHPEEK
49942	50279	break;
49943	50280	}
49944		- case 4183LLU: // copy-back deleter (MATCHPEEK to procblock)
	50281	+ case 4222LLU: // copy-back deleter (MATCHPEEK to procblock)
49945	50282	{
49946	50283	// copy mutable arguments back from call to MATCHPEEK
49947	50284	stack[base + 19]/lookahead/ = stack[base + 35LLU];
49948		- label = 4177LLU; // continue to roll stack
	50285	+ label = 4216LLU; // continue to roll stack
49949	50286	break;
49950	50287	}
49951		- case 4184LLU: // return from MATCHPEEK to procblock
	50288	+ case 4223LLU: // return from MATCHPEEK to procblock
49952	50289	{
49953	50290	// copy mutable arguments back from call to MATCHPEEK
49954	50291	stack[base + 19]/lookahead/ = stack[base + 35LLU];
49955		- label = 4182LLU; // consequent complete
	50292	+ label = 4221LLU; // consequent complete
49956	50293	break;
49957	50294	}
49958		- case 4181LLU: // alternative
	50295	+ case 4220LLU: // alternative
49959	50296	{
49960	50297	// call EOSbyte from procblock
49961		- stack[base + 30LLU] = 4185LLU/throw to this address/;
	50298	+ stack[base + 30LLU] = 4224LLU/throw to this address/;
49962	50299	stack[base + 31LLU] = base;
49963		- stack[base + 32LLU] = 4186LLU;
	50300	+ stack[base + 32LLU] = 4225LLU;
49964	50301	// arguments for call to EOSbyte
49965	50302	// set stack-base & callee-address
49966	50303	base += 33LLU;

		@@ -49967,36 +50304,36 @@
49967	50304	label = 77LLU; // EOSbyte
49968	50305	break;
49969	50306	}
49970		- case 4185LLU: // copy-back deleter (EOSbyte to procblock)
	50307	+ case 4224LLU: // copy-back deleter (EOSbyte to procblock)
49971	50308	{
49972	50309	// copy mutable arguments back from call to EOSbyte
49973		- label = 4177LLU; // continue to roll stack
	50310	+ label = 4216LLU; // continue to roll stack
49974	50311	break;
49975	50312	}
49976		- case 4186LLU: // return from EOSbyte to procblock
	50313	+ case 4225LLU: // return from EOSbyte to procblock
49977	50314	{
49978	50315	// copy mutable arguments back from call to EOSbyte
49979	50316	// copy back results provided by call to EOSbyte
49980	50317	stack[base + 19] = stack[base + 33LLU];
49981		- label = 4182LLU; // alternative complete
	50318	+ label = 4221LLU; // alternative complete
49982	50319	break;
49983	50320	}
49984		- case 4182LLU: // completed if-then-else
	50321	+ case 4221LLU: // completed if-then-else
49985	50322	{
49986	50323	if(stack[base + 19]/lookahead/ <= 0xFF) stack[base + 19]/lookahead/ = getchar();
49987		- label = 4115LLU; // repeat
	50324	+ label = 4154LLU; // repeat
49988	50325	break;
49989	50326	}
49990		- case 4116LLU: // loop finished
	50327	+ case 4155LLU: // loop finished
49991	50328	{
49992		- label = 4187LLU; // start to repeat
	50329	+ label = 4226LLU; // start to repeat
49993	50330	break;
49994	50331	}
49995		- case 4187LLU: // repeat from here
	50332	+ case 4226LLU: // repeat from here
49996	50333	{
49997	50334	if(!stack[base + 24])
49998	50335	{
49999		- label = 4188LLU; // break loop
	50336	+ label = 4227LLU; // break loop
50000	50337	break;
50001	50338	}
50002	50339

		@@ -50007,20 +50344,20 @@
50007	50344	stack[base + 24] = (uint64_t)list->next;
50008	50345	Free(1, sizeof(struct listnode), list);
50009	50346	}
50010		- label = 4187LLU; // repeat
	50347	+ label = 4226LLU; // repeat
50011	50348	break;
50012	50349	}
50013		- case 4188LLU: // loop finished
	50350	+ case 4227LLU: // loop finished
50014	50351	{
50015	50352	// delete list
50016		- label = 4189LLU; // start to repeat
	50353	+ label = 4228LLU; // start to repeat
50017	50354	break;
50018	50355	}
50019		- case 4189LLU: // repeat from here
	50356	+ case 4228LLU: // repeat from here
50020	50357	{
50021	50358	if(!stack[base + 24])
50022	50359	{
50023		- label = 4190LLU; // break loop
	50360	+ label = 4229LLU; // break loop
50024	50361	break;
50025	50362	}
50026	50363

		@@ -50030,20 +50367,20 @@
50030	50367	stack[base + 24] = (uint64_t)list->next;
50031	50368	Free(1, sizeof(struct listnode), list);
50032	50369	}
50033		- label = 4189LLU; // repeat
	50370	+ label = 4228LLU; // repeat
50034	50371	break;
50035	50372	}
50036		- case 4190LLU: // loop finished
	50373	+ case 4229LLU: // loop finished
50037	50374	{
50038		- label = 4110LLU; // alternative complete
	50375	+ label = 4149LLU; // alternative complete
50039	50376	break;
50040	50377	}
50041		- case 4110LLU: // completed if-then-else
	50378	+ case 4149LLU: // completed if-then-else
50042	50379	{
50043	50380	// call getbyte from procblock
50044		- stack[base + 24LLU] = 4191LLU/throw to this address/;
	50381	+ stack[base + 24LLU] = 4230LLU/throw to this address/;
50045	50382	stack[base + 25LLU] = base;
50046		- stack[base + 26LLU] = 4192LLU;
	50383	+ stack[base + 26LLU] = 4231LLU;
50047	50384	// arguments for call to getbyte
50048	50385	// set stack-base & callee-address
50049	50386	base += 27LLU;

		@@ -50050,13 +50387,13 @@
50050	50387	label = 18446744073709551593LLU; // getbyte
50051	50388	break;
50052	50389	}
50053		- case 4191LLU: // copy-back deleter (getbyte to procblock)
	50390	+ case 4230LLU: // copy-back deleter (getbyte to procblock)
50054	50391	{
50055	50392	// copy mutable arguments back from call to getbyte
50056		- label = 4100LLU; // continue to roll stack
	50393	+ label = 4139LLU; // continue to roll stack
50057	50394	break;
50058	50395	}
50059		- case 4192LLU: // return from getbyte to procblock
	50396	+ case 4231LLU: // return from getbyte to procblock
50060	50397	{
50061	50398	// copy mutable arguments back from call to getbyte
50062	50399	// copy back results provided by call to getbyte

		@@ -50063,9 +50400,9 @@
50063	50400	stack[base + 19] = stack[base + 27LLU];
50064	50401	list_reverse(((struct listnode *)(&stack[base + 22]/blkresults*/)));
50065	50402	// call matchsym from procblock
50066		- stack[base + 24LLU] = 4193LLU/throw to this address/;
	50403	+ stack[base + 24LLU] = 4232LLU/throw to this address/;
50067	50404	stack[base + 25LLU] = base;
50068		- stack[base + 26LLU] = 4194LLU;
	50405	+ stack[base + 26LLU] = 4233LLU;
50069	50406	// arguments for call to matchsym
50070	50407	stack[base + 27LLU] = stack[base + 8]/fnid/;
50071	50408	stack[base + 28LLU] = 61LLU;

		@@ -50075,21 +50412,21 @@
50075	50412	label = 222LLU; // matchsym
50076	50413	break;
50077	50414	}
50078		- case 4193LLU: // copy-back deleter (matchsym to procblock)
	50415	+ case 4232LLU: // copy-back deleter (matchsym to procblock)
50079	50416	{
50080	50417	// copy mutable arguments back from call to matchsym
50081	50418	stack[base + 19]/lookahead/ = stack[base + 29LLU];
50082		- label = 4100LLU; // continue to roll stack
	50419	+ label = 4139LLU; // continue to roll stack
50083	50420	break;
50084	50421	}
50085		- case 4194LLU: // return from matchsym to procblock
	50422	+ case 4233LLU: // return from matchsym to procblock
50086	50423	{
50087	50424	// copy mutable arguments back from call to matchsym
50088	50425	stack[base + 19]/lookahead/ = stack[base + 29LLU];
50089	50426	// call PARSETOKEN from procblock
50090		- stack[base + 24LLU] = 4195LLU/throw to this address/;
	50427	+ stack[base + 24LLU] = 4234LLU/throw to this address/;
50091	50428	stack[base + 25LLU] = base;
50092		- stack[base + 26LLU] = 4196LLU;
	50429	+ stack[base + 26LLU] = 4235LLU;
50093	50430	// arguments for call to PARSETOKEN
50094	50431	stack[base + 29LLU] = stack[base + 19]/lookahead/;
50095	50432	// set stack-base & callee-address

		@@ -50097,13 +50434,13 @@
50097	50434	label = 18446744073709551584LLU; // PARSETOKEN
50098	50435	break;
50099	50436	}
50100		- case 4195LLU: // copy-back deleter (PARSETOKEN to procblock)
	50437	+ case 4234LLU: // copy-back deleter (PARSETOKEN to procblock)
50101	50438	{
50102	50439	// copy mutable arguments back from call to PARSETOKEN
50103		- label = 4100LLU; // continue to roll stack
	50440	+ label = 4139LLU; // continue to roll stack
50104	50441	break;
50105	50442	}
50106		- case 4196LLU: // return from PARSETOKEN to procblock
	50443	+ case 4235LLU: // return from PARSETOKEN to procblock
50107	50444	{
50108	50445	// copy mutable arguments back from call to PARSETOKEN
50109	50446	// copy back results provided by call to PARSETOKEN

		@@ -50110,9 +50447,9 @@
50110	50447	stack[base + 15] = stack[base + 27LLU];
50111	50448	stack[base + 16] = stack[base + 28LLU];
50112	50449	// call equ from procblock
50113		- stack[base + 24LLU] = 4197LLU/throw to this address/;
	50450	+ stack[base + 24LLU] = 4236LLU/throw to this address/;
50114	50451	stack[base + 25LLU] = base;
50115		- stack[base + 26LLU] = 4198LLU;
	50452	+ stack[base + 26LLU] = 4237LLU;
50116	50453	// arguments for call to equ
50117	50454	stack[base + 28LLU] = stack[base + 15]/variant/;
50118	50455	stack[base + 29LLU] = 4LLU;

		@@ -50121,13 +50458,13 @@
50121	50458	label = 18446744073709551600LLU; // equ
50122	50459	break;
50123	50460	}
50124		- case 4197LLU: // copy-back deleter (equ to procblock)
	50461	+ case 4236LLU: // copy-back deleter (equ to procblock)
50125	50462	{
50126	50463	// copy mutable arguments back from call to equ
50127		- label = 4100LLU; // continue to roll stack
	50464	+ label = 4139LLU; // continue to roll stack
50128	50465	break;
50129	50466	}
50130		- case 4198LLU: // return from equ to procblock
	50467	+ case 4237LLU: // return from equ to procblock
50131	50468	{
50132	50469	// copy mutable arguments back from call to equ
50133	50470	// copy back results provided by call to equ

		@@ -50134,20 +50471,20 @@
50134	50471	stack[base + 20] = stack[base + 27LLU];
50135	50472	if(!stack[base + 20]/isequal/)
50136	50473	{
50137		- label = 4199LLU; // jump to alternative
	50474	+ label = 4238LLU; // jump to alternative
50138	50475	break;
50139	50476	}
50140	50477
50141	50478	// consequent
50142		- label = 4202LLU; // skip deleter
	50479	+ label = 4241LLU; // skip deleter
50143	50480	break;
50144	50481	}
50145		- case 4201LLU: // deleter
	50482	+ case 4240LLU: // deleter
50146	50483	{
50147	50484	// throw from procblock
50148	50485	if(!stack[base + 24])
50149	50486	{
50150		- label = 4100LLU; // skip, variable already deleted/unscoped
	50487	+ label = 4139LLU; // skip, variable already deleted/unscoped
50151	50488	break;
50152	50489	}
50153	50490

		@@ -50156,7 +50493,7 @@
50156	50493	newstack[0] = (uint64_t)stack; // backup stack location
50157	50494	newstack[1] = 1234567890;
50158	50495	newstack[2] = base;
50159		- newstack[3] = 4203LLU;
	50496	+ newstack[3] = 4242LLU;
50160	50497	stack = newstack;
50161	50498	// set stack-base & callee-address
50162	50499	base = 4/deloffset/;

		@@ -50163,21 +50500,21 @@
50163	50500	label = 1449LLU; // ~fndef
50164	50501	break;
50165	50502	}
50166		- case 4203LLU: // return from ~fndef to procblock
	50503	+ case 4242LLU: // return from ~fndef to procblock
50167	50504	{
50168	50505	stack = (uint64_t *)stack[0];
50169	50506	// releasing toplevel container
50170	50507	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 24] - sizeof(uint64_t) 4));
50171	50508
50172		- label = 4100LLU; // continue unrolling stack, delete next variable
	50509	+ label = 4139LLU; // continue unrolling stack, delete next variable
50173	50510	break;
50174	50511	}
50175		- case 4202LLU: // skipped deleter
	50512	+ case 4241LLU: // skipped deleter
50176	50513	{
50177	50514	// call FindFn from procblock
50178		- stack[base + 25LLU] = 4204LLU/throw to this address/;
	50515	+ stack[base + 25LLU] = 4243LLU/throw to this address/;
50179	50516	stack[base + 26LLU] = base;
50180		- stack[base + 27LLU] = 4205LLU;
	50517	+ stack[base + 27LLU] = 4244LLU;
50181	50518	// arguments for call to FindFn
50182	50519	stack[base + 29LLU] = stack[base + 8]/fnid/;
50183	50520	stack[base + 30LLU] = stack[base + 0]/fndefs/;

		@@ -50187,21 +50524,21 @@
50187	50524	label = 1530LLU; // FindFn
50188	50525	break;
50189	50526	}
50190		- case 4204LLU: // copy-back deleter (FindFn to procblock)
	50527	+ case 4243LLU: // copy-back deleter (FindFn to procblock)
50191	50528	{
50192	50529	// copy mutable arguments back from call to FindFn
50193		- label = 4100LLU; // continue to roll stack
	50530	+ label = 4139LLU; // continue to roll stack
50194	50531	break;
50195	50532	}
50196		- case 4205LLU: // return from FindFn to procblock
	50533	+ case 4244LLU: // return from FindFn to procblock
50197	50534	{
50198	50535	// copy mutable arguments back from call to FindFn
50199	50536	// copy back results provided by call to FindFn
50200	50537	stack[base + 24] = stack[base + 28LLU];
50201	50538	// call matchsym from procblock
50202		- stack[base + 25LLU] = 4206LLU/throw to this address/;
	50539	+ stack[base + 25LLU] = 4245LLU/throw to this address/;
50203	50540	stack[base + 26LLU] = base;
50204		- stack[base + 27LLU] = 4207LLU;
	50541	+ stack[base + 27LLU] = 4246LLU;
50205	50542	// arguments for call to matchsym
50206	50543	stack[base + 28LLU] = stack[base + 8]/fnid/;
50207	50544	stack[base + 29LLU] = 40LLU;

		@@ -50211,21 +50548,21 @@
50211	50548	label = 222LLU; // matchsym
50212	50549	break;
50213	50550	}
50214		- case 4206LLU: // copy-back deleter (matchsym to procblock)
	50551	+ case 4245LLU: // copy-back deleter (matchsym to procblock)
50215	50552	{
50216	50553	// copy mutable arguments back from call to matchsym
50217	50554	stack[base + 19]/lookahead/ = stack[base + 30LLU];
50218		- label = 4201LLU; // continue to roll stack
	50555	+ label = 4240LLU; // continue to roll stack
50219	50556	break;
50220	50557	}
50221		- case 4207LLU: // return from matchsym to procblock
	50558	+ case 4246LLU: // return from matchsym to procblock
50222	50559	{
50223	50560	// copy mutable arguments back from call to matchsym
50224	50561	stack[base + 19]/lookahead/ = stack[base + 30LLU];
50225	50562	// call ProcCall from procblock
50226		- stack[base + 25LLU] = 4208LLU/throw to this address/;
	50563	+ stack[base + 25LLU] = 4247LLU/throw to this address/;
50227	50564	stack[base + 26LLU] = base;
50228		- stack[base + 27LLU] = 4209LLU;
	50565	+ stack[base + 27LLU] = 4248LLU;
50229	50566	// arguments for call to ProcCall
50230	50567	stack[base + 28LLU] = stack[base + 22]/blkresults/;
50231	50568	stack[base + 29LLU] = stack[base + 0]/fndefs/;

		@@ -50250,7 +50587,7 @@
50250	50587	label = 1705LLU; // ProcCall
50251	50588	break;
50252	50589	}
50253		- case 4208LLU: // copy-back deleter (ProcCall to procblock)
	50590	+ case 4247LLU: // copy-back deleter (ProcCall to procblock)
50254	50591	{
50255	50592	// copy mutable arguments back from call to ProcCall
50256	50593	stack[base + 17]/label/ = stack[base + 45LLU];

		@@ -50259,10 +50596,10 @@
50259	50596	stack[base + 19]/lookahead/ = stack[base + 42LLU];
50260	50597	stack[base + 12]/fnmaxcount/ = stack[base + 40LLU];
50261	50598	stack[base + 22]/blkresults/ = stack[base + 28LLU];
50262		- label = 4201LLU; // continue to roll stack
	50599	+ label = 4240LLU; // continue to roll stack
50263	50600	break;
50264	50601	}
50265		- case 4209LLU: // return from ProcCall to procblock
	50602	+ case 4248LLU: // return from ProcCall to procblock
50266	50603	{
50267	50604	// copy mutable arguments back from call to ProcCall
50268	50605	stack[base + 17]/label/ = stack[base + 45LLU];

		@@ -50272,9 +50609,9 @@
50272	50609	stack[base + 12]/fnmaxcount/ = stack[base + 40LLU];
50273	50610	stack[base + 22]/blkresults/ = stack[base + 28LLU];
50274	50611	// call matchsym from procblock
50275		- stack[base + 25LLU] = 4210LLU/throw to this address/;
	50612	+ stack[base + 25LLU] = 4249LLU/throw to this address/;
50276	50613	stack[base + 26LLU] = base;
50277		- stack[base + 27LLU] = 4211LLU;
	50614	+ stack[base + 27LLU] = 4250LLU;
50278	50615	// arguments for call to matchsym
50279	50616	stack[base + 28LLU] = stack[base + 8]/fnid/;
50280	50617	stack[base + 29LLU] = 41LLU;

		@@ -50284,14 +50621,14 @@
50284	50621	label = 222LLU; // matchsym
50285	50622	break;
50286	50623	}
50287		- case 4210LLU: // copy-back deleter (matchsym to procblock)
	50624	+ case 4249LLU: // copy-back deleter (matchsym to procblock)
50288	50625	{
50289	50626	// copy mutable arguments back from call to matchsym
50290	50627	stack[base + 19]/lookahead/ = stack[base + 30LLU];
50291		- label = 4201LLU; // continue to roll stack
	50628	+ label = 4240LLU; // continue to roll stack
50292	50629	break;
50293	50630	}
50294		- case 4211LLU: // return from matchsym to procblock
	50631	+ case 4250LLU: // return from matchsym to procblock
50295	50632	{
50296	50633	// copy mutable arguments back from call to matchsym
50297	50634	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -50301,7 +50638,7 @@
50301	50638	newstack[0] = (uint64_t)stack; // backup stack location
50302	50639	newstack[1] = 1234567890;
50303	50640	newstack[2] = base;
50304		- newstack[3] = 4212LLU;
	50641	+ newstack[3] = 4251LLU;
50305	50642	stack = newstack;
50306	50643	// set stack-base & callee-address
50307	50644	base = 4/deloffset/;

		@@ -50308,21 +50645,21 @@
50308	50645	label = 1449LLU; // ~fndef
50309	50646	break;
50310	50647	}
50311		- case 4212LLU: // return from ~fndef to procblock
	50648	+ case 4251LLU: // return from ~fndef to procblock
50312	50649	{
50313	50650	stack = (uint64_t *)stack[0];
50314	50651	// releasing toplevel container
50315	50652	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 24] - sizeof(uint64_t) 4));
50316	50653
50317		- label = 4200LLU; // consequent complete
	50654	+ label = 4239LLU; // consequent complete
50318	50655	break;
50319	50656	}
50320		- case 4199LLU: // alternative
	50657	+ case 4238LLU: // alternative
50321	50658	{
50322	50659	// call issimple from procblock
50323		- stack[base + 24LLU] = 4213LLU/throw to this address/;
	50660	+ stack[base + 24LLU] = 4252LLU/throw to this address/;
50324	50661	stack[base + 25LLU] = base;
50325		- stack[base + 26LLU] = 4214LLU;
	50662	+ stack[base + 26LLU] = 4253LLU;
50326	50663	// arguments for call to issimple
50327	50664	stack[base + 28LLU] = stack[base + 15]/variant/;
50328	50665	stack[base + 29LLU] = stack[base + 16]/content/;

		@@ -50332,13 +50669,13 @@
50332	50669	label = 166LLU; // issimple
50333	50670	break;
50334	50671	}
50335		- case 4213LLU: // copy-back deleter (issimple to procblock)
	50672	+ case 4252LLU: // copy-back deleter (issimple to procblock)
50336	50673	{
50337	50674	// copy mutable arguments back from call to issimple
50338		- label = 4100LLU; // continue to roll stack
	50675	+ label = 4139LLU; // continue to roll stack
50339	50676	break;
50340	50677	}
50341		- case 4214LLU: // return from issimple to procblock
	50678	+ case 4253LLU: // return from issimple to procblock
50342	50679	{
50343	50680	// copy mutable arguments back from call to issimple
50344	50681	// copy back results provided by call to issimple

		@@ -50345,7 +50682,7 @@
50345	50682	stack[base + 20] = stack[base + 27LLU];
50346	50683	if(!stack[base + 20]/isequal/)
50347	50684	{
50348		- label = 4215LLU; // jump to alternative
	50685	+ label = 4254LLU; // jump to alternative
50349	50686	break;
50350	50687	}
50351	50688

		@@ -50353,7 +50690,7 @@
50353	50690	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
50354	50691	if(!newstack)
50355	50692	{
50356		- label = 4100LLU; // throw: begin to unroll stack
	50693	+ label = 4139LLU; // throw: begin to unroll stack
50357	50694	break;
50358	50695	}
50359	50696

		@@ -50360,9 +50697,9 @@
50360	50697	newstack[160LLU] = 9876543210LLU; // overflow-marker
50361	50698	// call procblock from procblock
50362	50699	newstack[0] = (uint64_t)stack; // backup stack location
50363		- newstack[1] = 4217LLU;
	50700	+ newstack[1] = 4256LLU;
50364	50701	newstack[2] = base;
50365		- newstack[3] = 4218LLU;
	50702	+ newstack[3] = 4257LLU;
50366	50703	// arguments for call to procblock
50367	50704	newstack[4LLU] = stack[base + 0]/fndefs/;
50368	50705	newstack[5LLU] = stack[base + 1]/typedefs/;

		@@ -50388,7 +50725,7 @@
50388	50725	label = 3319LLU; // procblock
50389	50726	break;
50390	50727	}
50391		- case 4217LLU: // copy-back deleter (procblock to procblock)
	50728	+ case 4256LLU: // copy-back deleter (procblock to procblock)
50392	50729	{
50393	50730	uint64_t oldstack = (uint64_t )stack[0];
50394	50731	// copy mutable arguments back from call to procblock

		@@ -50405,10 +50742,10 @@
50405	50742	}
50406	50743	Free(160LLU + 1, sizeof(uint64_t), stack);
50407	50744	stack = oldstack;
50408		- label = 4100LLU; // continue to unroll stack
	50745	+ label = 4139LLU; // continue to unroll stack
50409	50746	break;
50410	50747	}
50411		- case 4218LLU: // return from procblock to procblock
	50748	+ case 4257LLU: // return from procblock to procblock
50412	50749	{
50413	50750	uint64_t oldstack = (uint64_t )stack[0];
50414	50751	// copy mutable arguments back from call to procblock

		@@ -50425,15 +50762,15 @@
50425	50762	}
50426	50763	Free(160LLU + 1, sizeof(uint64_t), stack);
50427	50764	stack = oldstack;
50428		- label = 4216LLU; // consequent complete
	50765	+ label = 4255LLU; // consequent complete
50429	50766	break;
50430	50767	}
50431		- case 4215LLU: // alternative
	50768	+ case 4254LLU: // alternative
50432	50769	{
50433	50770	// call issimple from procblock
50434		- stack[base + 24LLU] = 4219LLU/throw to this address/;
	50771	+ stack[base + 24LLU] = 4258LLU/throw to this address/;
50435	50772	stack[base + 25LLU] = base;
50436		- stack[base + 26LLU] = 4220LLU;
	50773	+ stack[base + 26LLU] = 4259LLU;
50437	50774	// arguments for call to issimple
50438	50775	stack[base + 28LLU] = stack[base + 15]/variant/;
50439	50776	stack[base + 29LLU] = stack[base + 16]/content/;

		@@ -50443,13 +50780,13 @@
50443	50780	label = 166LLU; // issimple
50444	50781	break;
50445	50782	}
50446		- case 4219LLU: // copy-back deleter (issimple to procblock)
	50783	+ case 4258LLU: // copy-back deleter (issimple to procblock)
50447	50784	{
50448	50785	// copy mutable arguments back from call to issimple
50449		- label = 4100LLU; // continue to roll stack
	50786	+ label = 4139LLU; // continue to roll stack
50450	50787	break;
50451	50788	}
50452		- case 4220LLU: // return from issimple to procblock
	50789	+ case 4259LLU: // return from issimple to procblock
50453	50790	{
50454	50791	// copy mutable arguments back from call to issimple
50455	50792	// copy back results provided by call to issimple

		@@ -50456,15 +50793,15 @@
50456	50793	stack[base + 20] = stack[base + 27LLU];
50457	50794	if(!stack[base + 20]/isequal/)
50458	50795	{
50459		- label = 4221LLU; // jump to alternative
	50796	+ label = 4260LLU; // jump to alternative
50460	50797	break;
50461	50798	}
50462	50799
50463	50800	// consequent
50464	50801	// call getbyte from procblock
50465		- stack[base + 24LLU] = 4223LLU/throw to this address/;
	50802	+ stack[base + 24LLU] = 4262LLU/throw to this address/;
50466	50803	stack[base + 25LLU] = base;
50467		- stack[base + 26LLU] = 4224LLU;
	50804	+ stack[base + 26LLU] = 4263LLU;
50468	50805	// arguments for call to getbyte
50469	50806	// set stack-base & callee-address
50470	50807	base += 27LLU;

		@@ -50471,21 +50808,21 @@
50471	50808	label = 18446744073709551593LLU; // getbyte
50472	50809	break;
50473	50810	}
50474		- case 4223LLU: // copy-back deleter (getbyte to procblock)
	50811	+ case 4262LLU: // copy-back deleter (getbyte to procblock)
50475	50812	{
50476	50813	// copy mutable arguments back from call to getbyte
50477		- label = 4100LLU; // continue to roll stack
	50814	+ label = 4139LLU; // continue to roll stack
50478	50815	break;
50479	50816	}
50480		- case 4224LLU: // return from getbyte to procblock
	50817	+ case 4263LLU: // return from getbyte to procblock
50481	50818	{
50482	50819	// copy mutable arguments back from call to getbyte
50483	50820	// copy back results provided by call to getbyte
50484	50821	stack[base + 19] = stack[base + 27LLU];
50485	50822	// call PROCRETURN from procblock
50486		- stack[base + 24LLU] = 4225LLU/throw to this address/;
	50823	+ stack[base + 24LLU] = 4264LLU/throw to this address/;
50487	50824	stack[base + 25LLU] = base;
50488		- stack[base + 26LLU] = 4226LLU;
	50825	+ stack[base + 26LLU] = 4265LLU;
50489	50826	// arguments for call to PROCRETURN
50490	50827	stack[base + 27LLU] = stack[base + 0]/fndefs/;
50491	50828	stack[base + 28LLU] = stack[base + 1]/typedefs/;

		@@ -50510,7 +50847,7 @@
50510	50847	label = 2829LLU; // PROCRETURN
50511	50848	break;
50512	50849	}
50513		- case 4225LLU: // copy-back deleter (PROCRETURN to procblock)
	50850	+ case 4264LLU: // copy-back deleter (PROCRETURN to procblock)
50514	50851	{
50515	50852	// copy mutable arguments back from call to PROCRETURN
50516	50853	stack[base + 17]/label/ = stack[base + 44LLU];

		@@ -50519,10 +50856,10 @@
50519	50856	stack[base + 19]/lookahead/ = stack[base + 41LLU];
50520	50857	stack[base + 12]/fnmaxcount/ = stack[base + 40LLU];
50521	50858	stack[base + 3]/scope/ = stack[base + 30LLU];
50522		- label = 4100LLU; // continue to roll stack
	50859	+ label = 4139LLU; // continue to roll stack
50523	50860	break;
50524	50861	}
50525		- case 4226LLU: // return from PROCRETURN to procblock
	50862	+ case 4265LLU: // return from PROCRETURN to procblock
50526	50863	{
50527	50864	// copy mutable arguments back from call to PROCRETURN
50528	50865	stack[base + 17]/label/ = stack[base + 44LLU];

		@@ -50531,16 +50868,16 @@
50531	50868	stack[base + 19]/lookahead/ = stack[base + 41LLU];
50532	50869	stack[base + 12]/fnmaxcount/ = stack[base + 40LLU];
50533	50870	stack[base + 3]/scope/ = stack[base + 30LLU];
50534		- label = 4222LLU; // consequent complete
	50871	+ label = 4261LLU; // consequent complete
50535	50872	break;
50536	50873	}
50537		- case 4221LLU: // alternative
	50874	+ case 4260LLU: // alternative
50538	50875	{
50539	50876	fprintf(stderr, "%s", "parsing function call expected identifier but found ");
50540	50877	// call reporttok from procblock
50541		- stack[base + 24LLU] = 4227LLU/throw to this address/;
	50878	+ stack[base + 24LLU] = 4266LLU/throw to this address/;
50542	50879	stack[base + 25LLU] = base;
50543		- stack[base + 26LLU] = 4228LLU;
	50880	+ stack[base + 26LLU] = 4267LLU;
50544	50881	// arguments for call to reporttok
50545	50882	stack[base + 27LLU] = stack[base + 15]/variant/;
50546	50883	stack[base + 28LLU] = stack[base + 16]/content/;

		@@ -50549,38 +50886,38 @@
50549	50886	label = 18446744073709551582LLU; // reporttok
50550	50887	break;
50551	50888	}
50552		- case 4227LLU: // copy-back deleter (reporttok to procblock)
	50889	+ case 4266LLU: // copy-back deleter (reporttok to procblock)
50553	50890	{
50554	50891	// copy mutable arguments back from call to reporttok
50555		- label = 4100LLU; // continue to roll stack
	50892	+ label = 4139LLU; // continue to roll stack
50556	50893	break;
50557	50894	}
50558		- case 4228LLU: // return from reporttok to procblock
	50895	+ case 4267LLU: // return from reporttok to procblock
50559	50896	{
50560	50897	// copy mutable arguments back from call to reporttok
50561	50898	{
50562		- label = 4100LLU; // throw: begin to unroll stack
	50899	+ label = 4139LLU; // throw: begin to unroll stack
50563	50900	break;
50564	50901	}
50565	50902
50566		- label = 4222LLU; // alternative complete
	50903	+ label = 4261LLU; // alternative complete
50567	50904	break;
50568	50905	}
50569		- case 4222LLU: // completed if-then-else
	50906	+ case 4261LLU: // completed if-then-else
50570	50907	{
50571		- label = 4216LLU; // alternative complete
	50908	+ label = 4255LLU; // alternative complete
50572	50909	break;
50573	50910	}
50574		- case 4216LLU: // completed if-then-else
	50911	+ case 4255LLU: // completed if-then-else
50575	50912	{
50576		- label = 4200LLU; // alternative complete
	50913	+ label = 4239LLU; // alternative complete
50577	50914	break;
50578	50915	}
50579		- case 4200LLU: // completed if-then-else
	50916	+ case 4239LLU: // completed if-then-else
50580	50917	{
50581	50918	if(/scope/0 != ((uint64_t )(stack[base + 23]/NEWSCOPE*/))[0])
50582	50919	{
50583		- label = 4230LLU; // jump to alternative
	50920	+ label = 4269LLU; // jump to alternative
50584	50921	break;
50585	50922	}
50586	50923

		@@ -50588,14 +50925,14 @@
50588	50925	/LETDEFS/stack[base + 25] = ((uint64_t *)(stack[base + 23]/NEWSCOPE/))[1][1]/letdefs*/;
50589	50926
50590	50927	// case
50591		- label = 4232LLU; // start to repeat
	50928	+ label = 4271LLU; // start to repeat
50592	50929	break;
50593	50930	}
50594		- case 4232LLU: // repeat from here
	50931	+ case 4271LLU: // repeat from here
50595	50932	{
50596	50933	if(!stack[base + 25])
50597	50934	{
50598		- label = 4233LLU; // break loop
	50935	+ label = 4272LLU; // break loop
50599	50936	break;
50600	50937	}
50601	50938

		@@ -50608,7 +50945,7 @@
50608	50945	}
50609	50946	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
50610	50947	{
50611		- label = 4235LLU; // jump to alternative
	50948	+ label = 4274LLU; // jump to alternative
50612	50949	break;
50613	50950	}
50614	50951

		@@ -50617,15 +50954,15 @@
50617	50954
50618	50955	// case
50619	50956	stack[base + 27]/deleteaddr/ = stack[base + 24]/DELETEADDR/;
50620		- label = 4238LLU; // skip deleter
	50957	+ label = 4277LLU; // skip deleter
50621	50958	break;
50622	50959	}
50623		- case 4237LLU: // deleter
	50960	+ case 4276LLU: // deleter
50624	50961	{
50625	50962	// throw from procblock
50626	50963	if(!stack[base + 29])
50627	50964	{
50628		- label = 4236LLU; // skip, variable already deleted/unscoped
	50965	+ label = 4275LLU; // skip, variable already deleted/unscoped
50629	50966	break;
50630	50967	}
50631	50968

		@@ -50634,7 +50971,7 @@
50634	50971	newstack[0] = (uint64_t)stack; // backup stack location
50635	50972	newstack[1] = 1234567890;
50636	50973	newstack[2] = base;
50637		- newstack[3] = 4239LLU;
	50974	+ newstack[3] = 4278LLU;
50638	50975	stack = newstack;
50639	50976	// set stack-base & callee-address
50640	50977	base = 4/deloffset/;

		@@ -50641,21 +50978,21 @@
50641	50978	label = 482LLU; // ~letdef
50642	50979	break;
50643	50980	}
50644		- case 4239LLU: // return from ~letdef to procblock
	50981	+ case 4278LLU: // return from ~letdef to procblock
50645	50982	{
50646	50983	stack = (uint64_t *)stack[0];
50647	50984	// releasing toplevel container
50648	50985	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 29] - sizeof(uint64_t) 4));
50649	50986
50650		- label = 4236LLU; // continue unrolling stack, delete next variable
	50987	+ label = 4275LLU; // continue unrolling stack, delete next variable
50651	50988	break;
50652	50989	}
50653		- case 4238LLU: // skipped deleter
	50990	+ case 4277LLU: // skipped deleter
50654	50991	{
50655	50992	// call mkletdummy from procblock
50656		- stack[base + 30LLU] = 4240LLU/throw to this address/;
	50993	+ stack[base + 30LLU] = 4279LLU/throw to this address/;
50657	50994	stack[base + 31LLU] = base;
50658		- stack[base + 32LLU] = 4241LLU;
	50995	+ stack[base + 32LLU] = 4280LLU;
50659	50996	// arguments for call to mkletdummy
50660	50997	// set stack-base & callee-address
50661	50998	base += 33LLU;

		@@ -50662,13 +50999,13 @@
50662	50999	label = 485LLU; // mkletdummy
50663	51000	break;
50664	51001	}
50665		- case 4240LLU: // copy-back deleter (mkletdummy to procblock)
	51002	+ case 4279LLU: // copy-back deleter (mkletdummy to procblock)
50666	51003	{
50667	51004	// copy mutable arguments back from call to mkletdummy
50668		- label = 4236LLU; // continue to roll stack
	51005	+ label = 4275LLU; // continue to roll stack
50669	51006	break;
50670	51007	}
50671		- case 4241LLU: // return from mkletdummy to procblock
	51008	+ case 4280LLU: // return from mkletdummy to procblock
50672	51009	{
50673	51010	// copy mutable arguments back from call to mkletdummy
50674	51011	// copy back results provided by call to mkletdummy

		@@ -50689,22 +51026,22 @@
50689	51026	}
50690	51027	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 28];
50691	51028	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 27];
50692		- label = 4234LLU; // case complete
	51029	+ label = 4273LLU; // case complete
50693	51030	break;
50694	51031	}
50695		- case 4236LLU: // copy-back deleter (switch)
	51032	+ case 4275LLU: // copy-back deleter (switch)
50696	51033	{
50697	51034	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 28];
50698	51035	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 27];
50699		- label = 4231LLU; // continue to unroll stack
	51036	+ label = 4270LLU; // continue to unroll stack
50700	51037	break;
50701	51038	}
50702		- case 4235LLU: // try next case
	51039	+ case 4274LLU: // try next case
50703	51040	{
50704	51041	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
50705	51042	exit(-1);
50706	51043	}
50707		- case 4234LLU: // completed switch
	51044	+ case 4273LLU: // completed switch
50708	51045	{
50709	51046
50710	51047	uint64_t newstack = (uint64_t )(stack[base + 26] - sizeof(uint64_t) * 4);

		@@ -50712,7 +51049,7 @@
50712	51049	newstack[0] = (uint64_t)stack; // backup stack location
50713	51050	newstack[1] = 1234567890;
50714	51051	newstack[2] = base;
50715		- newstack[3] = 4242LLU;
	51052	+ newstack[3] = 4281LLU;
50716	51053	stack = newstack;
50717	51054	// set stack-base & callee-address
50718	51055	base = 4/deloffset/;

		@@ -50719,35 +51056,35 @@
50719	51056	label = 482LLU; // ~letdef
50720	51057	break;
50721	51058	}
50722		- case 4242LLU: // return from ~letdef to procblock
	51059	+ case 4281LLU: // return from ~letdef to procblock
50723	51060	{
50724	51061	stack = (uint64_t *)stack[0];
50725	51062	// releasing toplevel container
50726	51063	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 26] - sizeof(uint64_t) 4));
50727	51064
50728		- label = 4232LLU; // repeat
	51065	+ label = 4271LLU; // repeat
50729	51066	break;
50730	51067	}
50731		- case 4233LLU: // loop finished
	51068	+ case 4272LLU: // loop finished
50732	51069	{
50733	51070	((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
50734	51071	((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
50735		- label = 4229LLU; // case complete
	51072	+ label = 4268LLU; // case complete
50736	51073	break;
50737	51074	}
50738		- case 4231LLU: // copy-back deleter (switch)
	51075	+ case 4270LLU: // copy-back deleter (switch)
50739	51076	{
50740	51077	((uint64_t **)(stack[base + 23]))[1][1] = stack[base + 25];
50741	51078	((uint64_t **)(stack[base + 23]))[1][0] = stack[base + 24];
50742		- label = 4100LLU; // continue to unroll stack
	51079	+ label = 4139LLU; // continue to unroll stack
50743	51080	break;
50744	51081	}
50745		- case 4230LLU: // try next case
	51082	+ case 4269LLU: // try next case
50746	51083	{
50747	51084	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
50748	51085	exit(-1);
50749	51086	}
50750		- case 4229LLU: // completed switch
	51087	+ case 4268LLU: // completed switch
50751	51088	{
50752	51089
50753	51090	uint64_t newstack = (uint64_t )(stack[base + 23] - sizeof(uint64_t) * 4);

		@@ -50755,7 +51092,7 @@
50755	51092	newstack[0] = (uint64_t)stack; // backup stack location
50756	51093	newstack[1] = 1234567890;
50757	51094	newstack[2] = base;
50758		- newstack[3] = 4243LLU;
	51095	+ newstack[3] = 4282LLU;
50759	51096	stack = newstack;
50760	51097	// set stack-base & callee-address
50761	51098	base = 4/deloffset/;

		@@ -50762,7 +51099,7 @@
50762	51099	label = 558LLU; // ~scope
50763	51100	break;
50764	51101	}
50765		- case 4243LLU: // return from ~scope to procblock
	51102	+ case 4282LLU: // return from ~scope to procblock
50766	51103	{
50767	51104	stack = (uint64_t *)stack[0];
50768	51105	// releasing toplevel container

		@@ -50769,14 +51106,14 @@
50769	51106	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
50770	51107
50771	51108	// delete list
50772		- label = 4244LLU; // start to repeat
	51109	+ label = 4283LLU; // start to repeat
50773	51110	break;
50774	51111	}
50775		- case 4244LLU: // repeat from here
	51112	+ case 4283LLU: // repeat from here
50776	51113	{
50777	51114	if(!stack[base + 22])
50778	51115	{
50779		- label = 4245LLU; // break loop
	51116	+ label = 4284LLU; // break loop
50780	51117	break;
50781	51118	}
50782	51119

		@@ -50787,7 +51124,7 @@
50787	51124	newstack[0] = (uint64_t)stack; // backup stack location
50788	51125	newstack[1] = 1234567890;
50789	51126	newstack[2] = base;
50790		- newstack[3] = 4246LLU;
	51127	+ newstack[3] = 4285LLU;
50791	51128	stack = newstack;
50792	51129	// set stack-base & callee-address
50793	51130	base = 4/deloffset/;

		@@ -50794,7 +51131,7 @@
50794	51131	label = 395LLU; // ~typeidx
50795	51132	break;
50796	51133	}
50797		- case 4246LLU: // return from ~typeidx to procblock
	51134	+ case 4285LLU: // return from ~typeidx to procblock
50798	51135	{
50799	51136	stack = (uint64_t *)stack[0];
50800	51137	// releasing toplevel container

		@@ -50805,20 +51142,20 @@
50805	51142	stack[base + 22] = (uint64_t)list->next;
50806	51143	Free(1, sizeof(struct listnode), list);
50807	51144	}
50808		- label = 4244LLU; // repeat
	51145	+ label = 4283LLU; // repeat
50809	51146	break;
50810	51147	}
50811		- case 4245LLU: // loop finished
	51148	+ case 4284LLU: // loop finished
50812	51149	{
50813		- label = 4094LLU; // consequent complete
	51150	+ label = 4133LLU; // consequent complete
50814	51151	break;
50815	51152	}
50816		- case 4093LLU: // alternative
	51153	+ case 4132LLU: // alternative
50817	51154	{
50818	51155	// call equ from procblock
50819		- stack[base + 22LLU] = 4247LLU/throw to this address/;
	51156	+ stack[base + 22LLU] = 4286LLU/throw to this address/;
50820	51157	stack[base + 23LLU] = base;
50821		- stack[base + 24LLU] = 4248LLU;
	51158	+ stack[base + 24LLU] = 4287LLU;
50822	51159	// arguments for call to equ
50823	51160	stack[base + 26LLU] = stack[base + 15]/variant/;
50824	51161	stack[base + 27LLU] = 4LLU;

		@@ -50827,21 +51164,21 @@
50827	51164	label = 18446744073709551600LLU; // equ
50828	51165	break;
50829	51166	}
50830		- case 4247LLU: // copy-back deleter (equ to procblock)
	51167	+ case 4286LLU: // copy-back deleter (equ to procblock)
50831	51168	{
50832	51169	// copy mutable arguments back from call to equ
50833	51170	label = 3386LLU; // continue to roll stack
50834	51171	break;
50835	51172	}
50836		- case 4248LLU: // return from equ to procblock
	51173	+ case 4287LLU: // return from equ to procblock
50837	51174	{
50838	51175	// copy mutable arguments back from call to equ
50839	51176	// copy back results provided by call to equ
50840	51177	stack[base + 20] = stack[base + 25LLU];
50841		- label = 4250LLU; // skip deleter
	51178	+ label = 4289LLU; // skip deleter
50842	51179	break;
50843	51180	}
50844		- case 4249LLU: // deleter
	51181	+ case 4288LLU: // deleter
50845	51182	{
50846	51183	// throw from procblock
50847	51184	if(!stack[base + 22])

		@@ -50852,19 +51189,19 @@
50852	51189	label = 3386LLU; // continue unrolling stack, delete next variable
50853	51190	break;
50854	51191	}
50855		- case 4250LLU: // skipped deleter
	51192	+ case 4289LLU: // skipped deleter
50856	51193	{
50857	51194	if(!stack[base + 20]/isequal/)
50858	51195	{
50859		- label = 4251LLU; // jump to alternative
	51196	+ label = 4290LLU; // jump to alternative
50860	51197	break;
50861	51198	}
50862	51199
50863	51200	// consequent
50864	51201	// call equ from procblock
50865		- stack[base + 23LLU] = 4253LLU/throw to this address/;
	51202	+ stack[base + 23LLU] = 4292LLU/throw to this address/;
50866	51203	stack[base + 24LLU] = base;
50867		- stack[base + 25LLU] = 4254LLU;
	51204	+ stack[base + 25LLU] = 4293LLU;
50868	51205	// arguments for call to equ
50869	51206	stack[base + 27LLU] = stack[base + 16]/content/;
50870	51207	stack[base + 28LLU] = 734293447447412736LLU;

		@@ -50873,13 +51210,13 @@
50873	51210	label = 18446744073709551600LLU; // equ
50874	51211	break;
50875	51212	}
50876		- case 4253LLU: // copy-back deleter (equ to procblock)
	51213	+ case 4292LLU: // copy-back deleter (equ to procblock)
50877	51214	{
50878	51215	// copy mutable arguments back from call to equ
50879	51216	label = 3386LLU; // continue to roll stack
50880	51217	break;
50881	51218	}
50882		- case 4254LLU: // return from equ to procblock
	51219	+ case 4293LLU: // return from equ to procblock
50883	51220	{
50884	51221	// copy mutable arguments back from call to equ
50885	51222	// copy back results provided by call to equ

		@@ -50886,15 +51223,15 @@
50886	51223	stack[base + 20] = stack[base + 26LLU];
50887	51224	if(!stack[base + 20]/isequal/)
50888	51225	{
50889		- label = 4255LLU; // jump to alternative
	51226	+ label = 4294LLU; // jump to alternative
50890	51227	break;
50891	51228	}
50892	51229
50893	51230	// consequent
50894	51231	// call ParseToken from procblock
50895		- stack[base + 23LLU] = 4257LLU/throw to this address/;
	51232	+ stack[base + 23LLU] = 4296LLU/throw to this address/;
50896	51233	stack[base + 24LLU] = base;
50897		- stack[base + 25LLU] = 4258LLU;
	51234	+ stack[base + 25LLU] = 4297LLU;
50898	51235	// arguments for call to ParseToken
50899	51236	stack[base + 28LLU] = stack[base + 19]/lookahead/;
50900	51237	// set stack-base & callee-address

		@@ -50902,7 +51239,7 @@
50902	51239	label = 3LLU; // ParseToken
50903	51240	break;
50904	51241	}
50905		- case 4257LLU: // copy-back deleter (ParseToken to procblock)
	51242	+ case 4296LLU: // copy-back deleter (ParseToken to procblock)
50906	51243	{
50907	51244	// copy mutable arguments back from call to ParseToken
50908	51245	stack[base + 19]/lookahead/ = stack[base + 28LLU];

		@@ -50909,7 +51246,7 @@
50909	51246	label = 3386LLU; // continue to roll stack
50910	51247	break;
50911	51248	}
50912		- case 4258LLU: // return from ParseToken to procblock
	51249	+ case 4297LLU: // return from ParseToken to procblock
50913	51250	{
50914	51251	// copy mutable arguments back from call to ParseToken
50915	51252	stack[base + 19]/lookahead/ = stack[base + 28LLU];

		@@ -50916,10 +51253,10 @@
50916	51253	// copy back results provided by call to ParseToken
50917	51254	stack[base + 15] = stack[base + 26LLU];
50918	51255	stack[base + 16] = stack[base + 27LLU];
50919		- label = 4260LLU; // skip deleter
	51256	+ label = 4299LLU; // skip deleter
50920	51257	break;
50921	51258	}
50922		- case 4259LLU: // deleter
	51259	+ case 4298LLU: // deleter
50923	51260	{
50924	51261	// throw from procblock
50925	51262	if(!stack[base + 22])

		@@ -50930,18 +51267,18 @@
50930	51267	label = 3386LLU; // continue unrolling stack, delete next variable
50931	51268	break;
50932	51269	}
50933		- case 4260LLU: // skipped deleter
	51270	+ case 4299LLU: // skipped deleter
50934	51271	{
50935	51272	stack[base + 22] = 1;
50936		- label = 4256LLU; // consequent complete
	51273	+ label = 4295LLU; // consequent complete
50937	51274	break;
50938	51275	}
50939		- case 4255LLU: // alternative
	51276	+ case 4294LLU: // alternative
50940	51277	{
50941		- label = 4262LLU; // skip deleter
	51278	+ label = 4301LLU; // skip deleter
50942	51279	break;
50943	51280	}
50944		- case 4261LLU: // deleter
	51281	+ case 4300LLU: // deleter
50945	51282	{
50946	51283	// throw from procblock
50947	51284	if(!stack[base + 22])

		@@ -50952,23 +51289,23 @@
50952	51289	label = 3386LLU; // continue unrolling stack, delete next variable
50953	51290	break;
50954	51291	}
50955		- case 4262LLU: // skipped deleter
	51292	+ case 4301LLU: // skipped deleter
50956	51293	{
50957	51294	stack[base + 22] = 0;
50958		- label = 4256LLU; // alternative complete
	51295	+ label = 4295LLU; // alternative complete
50959	51296	break;
50960	51297	}
50961		- case 4256LLU: // completed if-then-else
	51298	+ case 4295LLU: // completed if-then-else
50962	51299	{
50963		- label = 4252LLU; // consequent complete
	51300	+ label = 4291LLU; // consequent complete
50964	51301	break;
50965	51302	}
50966		- case 4251LLU: // alternative
	51303	+ case 4290LLU: // alternative
50967	51304	{
50968		- label = 4264LLU; // skip deleter
	51305	+ label = 4303LLU; // skip deleter
50969	51306	break;
50970	51307	}
50971		- case 4263LLU: // deleter
	51308	+ case 4302LLU: // deleter
50972	51309	{
50973	51310	// throw from procblock
50974	51311	if(!stack[base + 22])

		@@ -50979,23 +51316,23 @@
50979	51316	label = 3386LLU; // continue unrolling stack, delete next variable
50980	51317	break;
50981	51318	}
50982		- case 4264LLU: // skipped deleter
	51319	+ case 4303LLU: // skipped deleter
50983	51320	{
50984	51321	stack[base + 22] = 0;
50985		- label = 4252LLU; // alternative complete
	51322	+ label = 4291LLU; // alternative complete
50986	51323	break;
50987	51324	}
50988		- case 4252LLU: // completed if-then-else
	51325	+ case 4291LLU: // completed if-then-else
50989	51326	{
50990		- label = 4266LLU; // skip deleter
	51327	+ label = 4305LLU; // skip deleter
50991	51328	break;
50992	51329	}
50993		- case 4265LLU: // deleter
	51330	+ case 4304LLU: // deleter
50994	51331	{
50995	51332	// throw from procblock
50996	51333	if(!stack[base + 23])
50997	51334	{
50998		- label = 4249LLU; // skip, variable already deleted/unscoped
	51335	+ label = 4288LLU; // skip, variable already deleted/unscoped
50999	51336	break;
51000	51337	}
51001	51338

		@@ -51004,7 +51341,7 @@
51004	51341	newstack[0] = (uint64_t)stack; // backup stack location
51005	51342	newstack[1] = 1234567890;
51006	51343	newstack[2] = base;
51007		- newstack[3] = 4267LLU;
	51344	+ newstack[3] = 4306LLU;
51008	51345	stack = newstack;
51009	51346	// set stack-base & callee-address
51010	51347	base = 4/deloffset/;

		@@ -51011,21 +51348,21 @@
51011	51348	label = 306LLU; // ~type
51012	51349	break;
51013	51350	}
51014		- case 4267LLU: // return from ~type to procblock
	51351	+ case 4306LLU: // return from ~type to procblock
51015	51352	{
51016	51353	stack = (uint64_t *)stack[0];
51017	51354	// releasing toplevel container
51018	51355	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
51019	51356
51020		- label = 4249LLU; // continue unrolling stack, delete next variable
	51357	+ label = 4288LLU; // continue unrolling stack, delete next variable
51021	51358	break;
51022	51359	}
51023		- case 4266LLU: // skipped deleter
	51360	+ case 4305LLU: // skipped deleter
51024	51361	{
51025	51362	// call PARSETYPE from procblock
51026		- stack[base + 24LLU] = 4268LLU/throw to this address/;
	51363	+ stack[base + 24LLU] = 4307LLU/throw to this address/;
51027	51364	stack[base + 25LLU] = base;
51028		- stack[base + 26LLU] = 4269LLU;
	51365	+ stack[base + 26LLU] = 4308LLU;
51029	51366	// arguments for call to PARSETYPE
51030	51367	stack[base + 28LLU] = stack[base + 8]/fnid/;
51031	51368	stack[base + 29LLU] = stack[base + 15]/variant/;

		@@ -51036,16 +51373,16 @@
51036	51373	label = 932LLU; // PARSETYPE
51037	51374	break;
51038	51375	}
51039		- case 4268LLU: // copy-back deleter (PARSETYPE to procblock)
	51376	+ case 4307LLU: // copy-back deleter (PARSETYPE to procblock)
51040	51377	{
51041	51378	// copy mutable arguments back from call to PARSETYPE
51042	51379	stack[base + 19]/lookahead/ = stack[base + 31LLU];
51043	51380	stack[base + 16]/content/ = stack[base + 30LLU];
51044	51381	stack[base + 15]/variant/ = stack[base + 29LLU];
51045		- label = 4249LLU; // continue to roll stack
	51382	+ label = 4288LLU; // continue to roll stack
51046	51383	break;
51047	51384	}
51048		- case 4269LLU: // return from PARSETYPE to procblock
	51385	+ case 4308LLU: // return from PARSETYPE to procblock
51049	51386	{
51050	51387	// copy mutable arguments back from call to PARSETYPE
51051	51388	stack[base + 19]/lookahead/ = stack[base + 31LLU];

		@@ -51054,9 +51391,9 @@
51054	51391	// copy back results provided by call to PARSETYPE
51055	51392	stack[base + 23] = stack[base + 27LLU];
51056	51393	// call ParseToken from procblock
51057		- stack[base + 24LLU] = 4270LLU/throw to this address/;
	51394	+ stack[base + 24LLU] = 4309LLU/throw to this address/;
51058	51395	stack[base + 25LLU] = base;
51059		- stack[base + 26LLU] = 4271LLU;
	51396	+ stack[base + 26LLU] = 4310LLU;
51060	51397	// arguments for call to ParseToken
51061	51398	stack[base + 29LLU] = stack[base + 19]/lookahead/;
51062	51399	// set stack-base & callee-address

		@@ -51064,14 +51401,14 @@
51064	51401	label = 3LLU; // ParseToken
51065	51402	break;
51066	51403	}
51067		- case 4270LLU: // copy-back deleter (ParseToken to procblock)
	51404	+ case 4309LLU: // copy-back deleter (ParseToken to procblock)
51068	51405	{
51069	51406	// copy mutable arguments back from call to ParseToken
51070	51407	stack[base + 19]/lookahead/ = stack[base + 29LLU];
51071		- label = 4265LLU; // continue to roll stack
	51408	+ label = 4304LLU; // continue to roll stack
51072	51409	break;
51073	51410	}
51074		- case 4271LLU: // return from ParseToken to procblock
	51411	+ case 4310LLU: // return from ParseToken to procblock
51075	51412	{
51076	51413	// copy mutable arguments back from call to ParseToken
51077	51414	stack[base + 19]/lookahead/ = stack[base + 29LLU];

		@@ -51079,9 +51416,9 @@
51079	51416	stack[base + 15] = stack[base + 27LLU];
51080	51417	stack[base + 16] = stack[base + 28LLU];
51081	51418	// call equ from procblock
51082		- stack[base + 24LLU] = 4272LLU/throw to this address/;
	51419	+ stack[base + 24LLU] = 4311LLU/throw to this address/;
51083	51420	stack[base + 25LLU] = base;
51084		- stack[base + 26LLU] = 4273LLU;
	51421	+ stack[base + 26LLU] = 4312LLU;
51085	51422	// arguments for call to equ
51086	51423	stack[base + 28LLU] = stack[base + 15]/variant/;
51087	51424	stack[base + 29LLU] = 4LLU;

		@@ -51090,13 +51427,13 @@
51090	51427	label = 18446744073709551600LLU; // equ
51091	51428	break;
51092	51429	}
51093		- case 4272LLU: // copy-back deleter (equ to procblock)
	51430	+ case 4311LLU: // copy-back deleter (equ to procblock)
51094	51431	{
51095	51432	// copy mutable arguments back from call to equ
51096		- label = 4265LLU; // continue to roll stack
	51433	+ label = 4304LLU; // continue to roll stack
51097	51434	break;
51098	51435	}
51099		- case 4273LLU: // return from equ to procblock
	51436	+ case 4312LLU: // return from equ to procblock
51100	51437	{
51101	51438	// copy mutable arguments back from call to equ
51102	51439	// copy back results provided by call to equ

		@@ -51103,21 +51440,21 @@
51103	51440	stack[base + 20] = stack[base + 27LLU];
51104	51441	if(!stack[base + 20]/isequal/)
51105	51442	{
51106		- label = 4274LLU; // jump to alternative
	51443	+ label = 4313LLU; // jump to alternative
51107	51444	break;
51108	51445	}
51109	51446
51110	51447	// consequent
51111		- label = 4275LLU; // consequent complete
	51448	+ label = 4314LLU; // consequent complete
51112	51449	break;
51113	51450	}
51114		- case 4274LLU: // alternative
	51451	+ case 4313LLU: // alternative
51115	51452	{
51116	51453	fprintf(stderr, "%s", "let expects identifier but found ");
51117	51454	// call reporttok from procblock
51118		- stack[base + 24LLU] = 4276LLU/throw to this address/;
	51455	+ stack[base + 24LLU] = 4315LLU/throw to this address/;
51119	51456	stack[base + 25LLU] = base;
51120		- stack[base + 26LLU] = 4277LLU;
	51457	+ stack[base + 26LLU] = 4316LLU;
51121	51458	// arguments for call to reporttok
51122	51459	stack[base + 27LLU] = stack[base + 15]/variant/;
51123	51460	stack[base + 28LLU] = stack[base + 16]/content/;

		@@ -51126,51 +51463,51 @@
51126	51463	label = 18446744073709551582LLU; // reporttok
51127	51464	break;
51128	51465	}
51129		- case 4276LLU: // copy-back deleter (reporttok to procblock)
	51466	+ case 4315LLU: // copy-back deleter (reporttok to procblock)
51130	51467	{
51131	51468	// copy mutable arguments back from call to reporttok
51132		- label = 4265LLU; // continue to roll stack
	51469	+ label = 4304LLU; // continue to roll stack
51133	51470	break;
51134	51471	}
51135		- case 4277LLU: // return from reporttok to procblock
	51472	+ case 4316LLU: // return from reporttok to procblock
51136	51473	{
51137	51474	// copy mutable arguments back from call to reporttok
51138	51475	{
51139		- label = 4265LLU; // throw: begin to unroll stack
	51476	+ label = 4304LLU; // throw: begin to unroll stack
51140	51477	break;
51141	51478	}
51142	51479
51143		- label = 4275LLU; // alternative complete
	51480	+ label = 4314LLU; // alternative complete
51144	51481	break;
51145	51482	}
51146		- case 4275LLU: // completed if-then-else
	51483	+ case 4314LLU: // completed if-then-else
51147	51484	{
51148		- label = 4279LLU; // skip deleter
	51485	+ label = 4318LLU; // skip deleter
51149	51486	break;
51150	51487	}
51151		- case 4278LLU: // deleter
	51488	+ case 4317LLU: // deleter
51152	51489	{
51153	51490	// throw from procblock
51154	51491	if(!stack[base + 24])
51155	51492	{
51156		- label = 4265LLU; // skip, variable already deleted/unscoped
	51493	+ label = 4304LLU; // skip, variable already deleted/unscoped
51157	51494	break;
51158	51495	}
51159		- label = 4265LLU; // continue unrolling stack, delete next variable
	51496	+ label = 4304LLU; // continue unrolling stack, delete next variable
51160	51497	break;
51161	51498	}
51162		- case 4279LLU: // skipped deleter
	51499	+ case 4318LLU: // skipped deleter
51163	51500	{
51164	51501	stack[base + 24] = stack[base + 16]/content/;
51165		- label = 4281LLU; // skip deleter
	51502	+ label = 4320LLU; // skip deleter
51166	51503	break;
51167	51504	}
51168		- case 4280LLU: // deleter
	51505	+ case 4319LLU: // deleter
51169	51506	{
51170	51507	// throw from procblock
51171	51508	if(!stack[base + 25])
51172	51509	{
51173		- label = 4278LLU; // skip, variable already deleted/unscoped
	51510	+ label = 4317LLU; // skip, variable already deleted/unscoped
51174	51511	break;
51175	51512	}
51176	51513

		@@ -51179,7 +51516,7 @@
51179	51516	newstack[0] = (uint64_t)stack; // backup stack location
51180	51517	newstack[1] = 1234567890;
51181	51518	newstack[2] = base;
51182		- newstack[3] = 4282LLU;
	51519	+ newstack[3] = 4321LLU;
51183	51520	stack = newstack;
51184	51521	// set stack-base & callee-address
51185	51522	base = 4/deloffset/;

		@@ -51186,21 +51523,21 @@
51186	51523	label = 558LLU; // ~scope
51187	51524	break;
51188	51525	}
51189		- case 4282LLU: // return from ~scope to procblock
	51526	+ case 4321LLU: // return from ~scope to procblock
51190	51527	{
51191	51528	stack = (uint64_t *)stack[0];
51192	51529	// releasing toplevel container
51193	51530	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 25] - sizeof(uint64_t) 4));
51194	51531
51195		- label = 4278LLU; // continue unrolling stack, delete next variable
	51532	+ label = 4317LLU; // continue unrolling stack, delete next variable
51196	51533	break;
51197	51534	}
51198		- case 4281LLU: // skipped deleter
	51535	+ case 4320LLU: // skipped deleter
51199	51536	{
51200	51537	// call emptyscope from procblock
51201		- stack[base + 26LLU] = 4283LLU/throw to this address/;
	51538	+ stack[base + 26LLU] = 4322LLU/throw to this address/;
51202	51539	stack[base + 27LLU] = base;
51203		- stack[base + 28LLU] = 4284LLU;
	51540	+ stack[base + 28LLU] = 4323LLU;
51204	51541	// arguments for call to emptyscope
51205	51542	// set stack-base & callee-address
51206	51543	base += 29LLU;

		@@ -51207,37 +51544,37 @@
51207	51544	label = 563LLU; // emptyscope
51208	51545	break;
51209	51546	}
51210		- case 4283LLU: // copy-back deleter (emptyscope to procblock)
	51547	+ case 4322LLU: // copy-back deleter (emptyscope to procblock)
51211	51548	{
51212	51549	// copy mutable arguments back from call to emptyscope
51213		- label = 4278LLU; // continue to roll stack
	51550	+ label = 4317LLU; // continue to roll stack
51214	51551	break;
51215	51552	}
51216		- case 4284LLU: // return from emptyscope to procblock
	51553	+ case 4323LLU: // return from emptyscope to procblock
51217	51554	{
51218	51555	// copy mutable arguments back from call to emptyscope
51219	51556	// copy back results provided by call to emptyscope
51220	51557	stack[base + 25] = stack[base + 29LLU];
51221		- label = 4286LLU; // skip deleter
	51558	+ label = 4325LLU; // skip deleter
51222	51559	break;
51223	51560	}
51224		- case 4285LLU: // deleter
	51561	+ case 4324LLU: // deleter
51225	51562	{
51226	51563	// throw from procblock
51227	51564	if(!stack[base + 26])
51228	51565	{
51229		- label = 4280LLU; // skip, variable already deleted/unscoped
	51566	+ label = 4319LLU; // skip, variable already deleted/unscoped
51230	51567	break;
51231	51568	}
51232		- label = 4280LLU; // continue unrolling stack, delete next variable
	51569	+ label = 4319LLU; // continue unrolling stack, delete next variable
51233	51570	break;
51234	51571	}
51235		- case 4286LLU: // skipped deleter
	51572	+ case 4325LLU: // skipped deleter
51236	51573	{
51237	51574	// call newvarraw from procblock
51238		- stack[base + 27LLU] = 4287LLU/throw to this address/;
	51575	+ stack[base + 27LLU] = 4326LLU/throw to this address/;
51239	51576	stack[base + 28LLU] = base;
51240		- stack[base + 29LLU] = 4288LLU;
	51577	+ stack[base + 29LLU] = 4327LLU;
51241	51578	// arguments for call to newvarraw
51242	51579	stack[base + 31LLU] = stack[base + 23]/type/;
51243	51580	stack[base + 32LLU] = stack[base + 24]/id/;

		@@ -51253,16 +51590,16 @@
51253	51590	label = 755LLU; // newvarraw
51254	51591	break;
51255	51592	}
51256		- case 4287LLU: // copy-back deleter (newvarraw to procblock)
	51593	+ case 4326LLU: // copy-back deleter (newvarraw to procblock)
51257	51594	{
51258	51595	// copy mutable arguments back from call to newvarraw
51259	51596	stack[base + 25]/NEWSCOPE/ = stack[base + 38LLU];
51260	51597	stack[base + 18]/varcount/ = stack[base + 37LLU];
51261	51598	stack[base + 12]/fnmaxcount/ = stack[base + 36LLU];
51262		- label = 4280LLU; // continue to roll stack
	51599	+ label = 4319LLU; // continue to roll stack
51263	51600	break;
51264	51601	}
51265		- case 4288LLU: // return from newvarraw to procblock
	51602	+ case 4327LLU: // return from newvarraw to procblock
51266	51603	{
51267	51604	// copy mutable arguments back from call to newvarraw
51268	51605	stack[base + 25]/NEWSCOPE/ = stack[base + 38LLU];

		@@ -51271,9 +51608,9 @@
51271	51608	// copy back results provided by call to newvarraw
51272	51609	stack[base + 26] = stack[base + 30LLU];
51273	51610	// call matchsym from procblock
51274		- stack[base + 27LLU] = 4289LLU/throw to this address/;
	51611	+ stack[base + 27LLU] = 4328LLU/throw to this address/;
51275	51612	stack[base + 28LLU] = base;
51276		- stack[base + 29LLU] = 4290LLU;
	51613	+ stack[base + 29LLU] = 4329LLU;
51277	51614	// arguments for call to matchsym
51278	51615	stack[base + 30LLU] = stack[base + 8]/fnid/;
51279	51616	stack[base + 31LLU] = 61LLU;

		@@ -51283,21 +51620,21 @@
51283	51620	label = 222LLU; // matchsym
51284	51621	break;
51285	51622	}
51286		- case 4289LLU: // copy-back deleter (matchsym to procblock)
	51623	+ case 4328LLU: // copy-back deleter (matchsym to procblock)
51287	51624	{
51288	51625	// copy mutable arguments back from call to matchsym
51289	51626	stack[base + 19]/lookahead/ = stack[base + 32LLU];
51290		- label = 4285LLU; // continue to roll stack
	51627	+ label = 4324LLU; // continue to roll stack
51291	51628	break;
51292	51629	}
51293		- case 4290LLU: // return from matchsym to procblock
	51630	+ case 4329LLU: // return from matchsym to procblock
51294	51631	{
51295	51632	// copy mutable arguments back from call to matchsym
51296	51633	stack[base + 19]/lookahead/ = stack[base + 32LLU];
51297	51634	// call initfrom from procblock
51298		- stack[base + 27LLU] = 4291LLU/throw to this address/;
	51635	+ stack[base + 27LLU] = 4330LLU/throw to this address/;
51299	51636	stack[base + 28LLU] = base;
51300		- stack[base + 29LLU] = 4292LLU;
	51637	+ stack[base + 29LLU] = 4331LLU;
51301	51638	// arguments for call to initfrom
51302	51639	stack[base + 30LLU] = stack[base + 8]/fnid/;
51303	51640	stack[base + 31LLU] = stack[base + 23]/type/;

		@@ -51314,16 +51651,16 @@
51314	51651	label = 2430LLU; // initfrom
51315	51652	break;
51316	51653	}
51317		- case 4291LLU: // copy-back deleter (initfrom to procblock)
	51654	+ case 4330LLU: // copy-back deleter (initfrom to procblock)
51318	51655	{
51319	51656	// copy mutable arguments back from call to initfrom
51320	51657	stack[base + 17]/label/ = stack[base + 38LLU];
51321	51658	stack[base + 19]/lookahead/ = stack[base + 37LLU];
51322	51659	stack[base + 3]/scope/ = stack[base + 36LLU];
51323		- label = 4285LLU; // continue to roll stack
	51660	+ label = 4324LLU; // continue to roll stack
51324	51661	break;
51325	51662	}
51326		- case 4292LLU: // return from initfrom to procblock
	51663	+ case 4331LLU: // return from initfrom to procblock
51327	51664	{
51328	51665	// copy mutable arguments back from call to initfrom
51329	51666	stack[base + 17]/label/ = stack[base + 38LLU];

		@@ -51331,7 +51668,7 @@
51331	51668	stack[base + 3]/scope/ = stack[base + 36LLU];
51332	51669	if(/scope/0 != ((uint64_t )(stack[base + 25]/NEWSCOPE*/))[0])
51333	51670	{
51334		- label = 4294LLU; // jump to alternative
	51671	+ label = 4333LLU; // jump to alternative
51335	51672	break;
51336	51673	}
51337	51674

		@@ -51339,14 +51676,14 @@
51339	51676	/LETDEFS/stack[base + 28] = ((uint64_t *)(stack[base + 25]/NEWSCOPE/))[1][1]/letdefs*/;
51340	51677
51341	51678	// case
51342		- label = 4296LLU; // start to repeat
	51679	+ label = 4335LLU; // start to repeat
51343	51680	break;
51344	51681	}
51345		- case 4296LLU: // repeat from here
	51682	+ case 4335LLU: // repeat from here
51346	51683	{
51347	51684	if(!stack[base + 28])
51348	51685	{
51349		- label = 4297LLU; // break loop
	51686	+ label = 4336LLU; // break loop
51350	51687	break;
51351	51688	}
51352	51689

		@@ -51359,7 +51696,7 @@
51359	51696	}
51360	51697	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
51361	51698	{
51362		- label = 4299LLU; // jump to alternative
	51699	+ label = 4338LLU; // jump to alternative
51363	51700	break;
51364	51701	}
51365	51702

		@@ -51367,15 +51704,15 @@
51367	51704	/letdefs/stack[base + 31] = ((uint64_t *)(stack[base + 3]/scope/))[1][1]/letdefs*/;
51368	51705
51369	51706	// case
51370		- label = 4302LLU; // skip deleter
	51707	+ label = 4341LLU; // skip deleter
51371	51708	break;
51372	51709	}
51373		- case 4301LLU: // deleter
	51710	+ case 4340LLU: // deleter
51374	51711	{
51375	51712	// throw from procblock
51376	51713	if(!stack[base + 32])
51377	51714	{
51378		- label = 4300LLU; // skip, variable already deleted/unscoped
	51715	+ label = 4339LLU; // skip, variable already deleted/unscoped
51379	51716	break;
51380	51717	}
51381	51718

		@@ -51384,7 +51721,7 @@
51384	51721	newstack[0] = (uint64_t)stack; // backup stack location
51385	51722	newstack[1] = 1234567890;
51386	51723	newstack[2] = base;
51387		- newstack[3] = 4303LLU;
	51724	+ newstack[3] = 4342LLU;
51388	51725	stack = newstack;
51389	51726	// set stack-base & callee-address
51390	51727	base = 4/deloffset/;

		@@ -51391,21 +51728,21 @@
51391	51728	label = 482LLU; // ~letdef
51392	51729	break;
51393	51730	}
51394		- case 4303LLU: // return from ~letdef to procblock
	51731	+ case 4342LLU: // return from ~letdef to procblock
51395	51732	{
51396	51733	stack = (uint64_t *)stack[0];
51397	51734	// releasing toplevel container
51398	51735	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 32] - sizeof(uint64_t) 4));
51399	51736
51400		- label = 4300LLU; // continue unrolling stack, delete next variable
	51737	+ label = 4339LLU; // continue unrolling stack, delete next variable
51401	51738	break;
51402	51739	}
51403		- case 4302LLU: // skipped deleter
	51740	+ case 4341LLU: // skipped deleter
51404	51741	{
51405	51742	// call mkletdummy from procblock
51406		- stack[base + 33LLU] = 4304LLU/throw to this address/;
	51743	+ stack[base + 33LLU] = 4343LLU/throw to this address/;
51407	51744	stack[base + 34LLU] = base;
51408		- stack[base + 35LLU] = 4305LLU;
	51745	+ stack[base + 35LLU] = 4344LLU;
51409	51746	// arguments for call to mkletdummy
51410	51747	// set stack-base & callee-address
51411	51748	base += 36LLU;

		@@ -51412,13 +51749,13 @@
51412	51749	label = 485LLU; // mkletdummy
51413	51750	break;
51414	51751	}
51415		- case 4304LLU: // copy-back deleter (mkletdummy to procblock)
	51752	+ case 4343LLU: // copy-back deleter (mkletdummy to procblock)
51416	51753	{
51417	51754	// copy mutable arguments back from call to mkletdummy
51418		- label = 4300LLU; // continue to roll stack
	51755	+ label = 4339LLU; // continue to roll stack
51419	51756	break;
51420	51757	}
51421		- case 4305LLU: // return from mkletdummy to procblock
	51758	+ case 4344LLU: // return from mkletdummy to procblock
51422	51759	{
51423	51760	// copy mutable arguments back from call to mkletdummy
51424	51761	// copy back results provided by call to mkletdummy

		@@ -51439,22 +51776,22 @@
51439	51776	}
51440	51777	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 31];
51441	51778	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 30];
51442		- label = 4298LLU; // case complete
	51779	+ label = 4337LLU; // case complete
51443	51780	break;
51444	51781	}
51445		- case 4300LLU: // copy-back deleter (switch)
	51782	+ case 4339LLU: // copy-back deleter (switch)
51446	51783	{
51447	51784	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 31];
51448	51785	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 30];
51449		- label = 4295LLU; // continue to unroll stack
	51786	+ label = 4334LLU; // continue to unroll stack
51450	51787	break;
51451	51788	}
51452		- case 4299LLU: // try next case
	51789	+ case 4338LLU: // try next case
51453	51790	{
51454	51791	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
51455	51792	exit(-1);
51456	51793	}
51457		- case 4298LLU: // completed switch
	51794	+ case 4337LLU: // completed switch
51458	51795	{
51459	51796
51460	51797	uint64_t newstack = (uint64_t )(stack[base + 29] - sizeof(uint64_t) * 4);

		@@ -51462,7 +51799,7 @@
51462	51799	newstack[0] = (uint64_t)stack; // backup stack location
51463	51800	newstack[1] = 1234567890;
51464	51801	newstack[2] = base;
51465		- newstack[3] = 4306LLU;
	51802	+ newstack[3] = 4345LLU;
51466	51803	stack = newstack;
51467	51804	// set stack-base & callee-address
51468	51805	base = 4/deloffset/;

		@@ -51469,35 +51806,35 @@
51469	51806	label = 482LLU; // ~letdef
51470	51807	break;
51471	51808	}
51472		- case 4306LLU: // return from ~letdef to procblock
	51809	+ case 4345LLU: // return from ~letdef to procblock
51473	51810	{
51474	51811	stack = (uint64_t *)stack[0];
51475	51812	// releasing toplevel container
51476	51813	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 29] - sizeof(uint64_t) 4));
51477	51814
51478		- label = 4296LLU; // repeat
	51815	+ label = 4335LLU; // repeat
51479	51816	break;
51480	51817	}
51481		- case 4297LLU: // loop finished
	51818	+ case 4336LLU: // loop finished
51482	51819	{
51483	51820	((uint64_t **)(stack[base + 25]))[1][1] = stack[base + 28];
51484	51821	((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 27];
51485		- label = 4293LLU; // case complete
	51822	+ label = 4332LLU; // case complete
51486	51823	break;
51487	51824	}
51488		- case 4295LLU: // copy-back deleter (switch)
	51825	+ case 4334LLU: // copy-back deleter (switch)
51489	51826	{
51490	51827	((uint64_t **)(stack[base + 25]))[1][1] = stack[base + 28];
51491	51828	((uint64_t **)(stack[base + 25]))[1][0] = stack[base + 27];
51492		- label = 4285LLU; // continue to unroll stack
	51829	+ label = 4324LLU; // continue to unroll stack
51493	51830	break;
51494	51831	}
51495		- case 4294LLU: // try next case
	51832	+ case 4333LLU: // try next case
51496	51833	{
51497	51834	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
51498	51835	exit(-1);
51499	51836	}
51500		- case 4293LLU: // completed switch
	51837	+ case 4332LLU: // completed switch
51501	51838	{
51502	51839
51503	51840	uint64_t newstack = (uint64_t )(stack[base + 25] - sizeof(uint64_t) * 4);

		@@ -51505,7 +51842,7 @@
51505	51842	newstack[0] = (uint64_t)stack; // backup stack location
51506	51843	newstack[1] = 1234567890;
51507	51844	newstack[2] = base;
51508		- newstack[3] = 4307LLU;
	51845	+ newstack[3] = 4346LLU;
51509	51846	stack = newstack;
51510	51847	// set stack-base & callee-address
51511	51848	base = 4/deloffset/;

		@@ -51512,7 +51849,7 @@
51512	51849	label = 558LLU; // ~scope
51513	51850	break;
51514	51851	}
51515		- case 4307LLU: // return from ~scope to procblock
	51852	+ case 4346LLU: // return from ~scope to procblock
51516	51853	{
51517	51854	stack = (uint64_t *)stack[0];
51518	51855	// releasing toplevel container

		@@ -51524,7 +51861,7 @@
51524	51861	newstack[0] = (uint64_t)stack; // backup stack location
51525	51862	newstack[1] = 1234567890;
51526	51863	newstack[2] = base;
51527		- newstack[3] = 4308LLU;
	51864	+ newstack[3] = 4347LLU;
51528	51865	stack = newstack;
51529	51866	// set stack-base & callee-address
51530	51867	base = 4/deloffset/;

		@@ -51531,21 +51868,21 @@
51531	51868	label = 306LLU; // ~type
51532	51869	break;
51533	51870	}
51534		- case 4308LLU: // return from ~type to procblock
	51871	+ case 4347LLU: // return from ~type to procblock
51535	51872	{
51536	51873	stack = (uint64_t *)stack[0];
51537	51874	// releasing toplevel container
51538	51875	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
51539	51876
51540		- label = 4094LLU; // alternative complete
	51877	+ label = 4133LLU; // alternative complete
51541	51878	break;
51542	51879	}
51543		- case 4094LLU: // completed if-then-else
	51880	+ case 4133LLU: // completed if-then-else
51544	51881	{
51545	51882	// call DELIMITER from procblock
51546		- stack[base + 22LLU] = 4309LLU/throw to this address/;
	51883	+ stack[base + 22LLU] = 4348LLU/throw to this address/;
51547	51884	stack[base + 23LLU] = base;
51548		- stack[base + 24LLU] = 4310LLU;
	51885	+ stack[base + 24LLU] = 4349LLU;
51549	51886	// arguments for call to DELIMITER
51550	51887	stack[base + 25LLU] = stack[base + 8]/fnid/;
51551	51888	stack[base + 26LLU] = stack[base + 19]/lookahead/;

		@@ -51554,7 +51891,7 @@
51554	51891	label = 17LLU; // DELIMITER
51555	51892	break;
51556	51893	}
51557		- case 4309LLU: // copy-back deleter (DELIMITER to procblock)
	51894	+ case 4348LLU: // copy-back deleter (DELIMITER to procblock)
51558	51895	{
51559	51896	// copy mutable arguments back from call to DELIMITER
51560	51897	stack[base + 19]/lookahead/ = stack[base + 26LLU];

		@@ -51561,19 +51898,19 @@
51561	51898	label = 3386LLU; // continue to roll stack
51562	51899	break;
51563	51900	}
51564		- case 4310LLU: // return from DELIMITER to procblock
	51901	+ case 4349LLU: // return from DELIMITER to procblock
51565	51902	{
51566	51903	// copy mutable arguments back from call to DELIMITER
51567	51904	stack[base + 19]/lookahead/ = stack[base + 26LLU];
51568		- label = 4088LLU; // consequent complete
	51905	+ label = 4127LLU; // consequent complete
51569	51906	break;
51570	51907	}
51571		- case 4087LLU: // alternative
	51908	+ case 4126LLU: // alternative
51572	51909	{
51573	51910	// call equ from procblock
51574		- stack[base + 22LLU] = 4311LLU/throw to this address/;
	51911	+ stack[base + 22LLU] = 4350LLU/throw to this address/;
51575	51912	stack[base + 23LLU] = base;
51576		- stack[base + 24LLU] = 4312LLU;
	51913	+ stack[base + 24LLU] = 4351LLU;
51577	51914	// arguments for call to equ
51578	51915	stack[base + 26LLU] = stack[base + 16]/content/;
51579	51916	stack[base + 27LLU] = 788334650111033344LLU;

		@@ -51582,13 +51919,13 @@
51582	51919	label = 18446744073709551600LLU; // equ
51583	51920	break;
51584	51921	}
51585		- case 4311LLU: // copy-back deleter (equ to procblock)
	51922	+ case 4350LLU: // copy-back deleter (equ to procblock)
51586	51923	{
51587	51924	// copy mutable arguments back from call to equ
51588	51925	label = 3386LLU; // continue to roll stack
51589	51926	break;
51590	51927	}
51591		- case 4312LLU: // return from equ to procblock
	51928	+ case 4351LLU: // return from equ to procblock
51592	51929	{
51593	51930	// copy mutable arguments back from call to equ
51594	51931	// copy back results provided by call to equ

		@@ -51595,15 +51932,15 @@
51595	51932	stack[base + 20] = stack[base + 25LLU];
51596	51933	if(!stack[base + 20]/isequal/)
51597	51934	{
51598		- label = 4313LLU; // jump to alternative
	51935	+ label = 4352LLU; // jump to alternative
51599	51936	break;
51600	51937	}
51601	51938
51602	51939	// consequent
51603	51940	// call matchsym from procblock
51604		- stack[base + 22LLU] = 4315LLU/throw to this address/;
	51941	+ stack[base + 22LLU] = 4354LLU/throw to this address/;
51605	51942	stack[base + 23LLU] = base;
51606		- stack[base + 24LLU] = 4316LLU;
	51943	+ stack[base + 24LLU] = 4355LLU;
51607	51944	// arguments for call to matchsym
51608	51945	stack[base + 25LLU] = stack[base + 8]/fnid/;
51609	51946	stack[base + 26LLU] = 40LLU;

		@@ -51613,7 +51950,7 @@
51613	51950	label = 222LLU; // matchsym
51614	51951	break;
51615	51952	}
51616		- case 4315LLU: // copy-back deleter (matchsym to procblock)
	51953	+ case 4354LLU: // copy-back deleter (matchsym to procblock)
51617	51954	{
51618	51955	// copy mutable arguments back from call to matchsym
51619	51956	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -51620,14 +51957,14 @@
51620	51957	label = 3386LLU; // continue to roll stack
51621	51958	break;
51622	51959	}
51623		- case 4316LLU: // return from matchsym to procblock
	51960	+ case 4355LLU: // return from matchsym to procblock
51624	51961	{
51625	51962	// copy mutable arguments back from call to matchsym
51626	51963	stack[base + 19]/lookahead/ = stack[base + 27LLU];
51627	51964	// call ParseToken from procblock
51628		- stack[base + 22LLU] = 4317LLU/throw to this address/;
	51965	+ stack[base + 22LLU] = 4356LLU/throw to this address/;
51629	51966	stack[base + 23LLU] = base;
51630		- stack[base + 24LLU] = 4318LLU;
	51967	+ stack[base + 24LLU] = 4357LLU;
51631	51968	// arguments for call to ParseToken
51632	51969	stack[base + 27LLU] = stack[base + 19]/lookahead/;
51633	51970	// set stack-base & callee-address

		@@ -51635,7 +51972,7 @@
51635	51972	label = 3LLU; // ParseToken
51636	51973	break;
51637	51974	}
51638		- case 4317LLU: // copy-back deleter (ParseToken to procblock)
	51975	+ case 4356LLU: // copy-back deleter (ParseToken to procblock)
51639	51976	{
51640	51977	// copy mutable arguments back from call to ParseToken
51641	51978	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -51642,7 +51979,7 @@
51642	51979	label = 3386LLU; // continue to roll stack
51643	51980	break;
51644	51981	}
51645		- case 4318LLU: // return from ParseToken to procblock
	51982	+ case 4357LLU: // return from ParseToken to procblock
51646	51983	{
51647	51984	// copy mutable arguments back from call to ParseToken
51648	51985	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -51650,9 +51987,9 @@
51650	51987	stack[base + 15] = stack[base + 25LLU];
51651	51988	stack[base + 16] = stack[base + 26LLU];
51652	51989	// call equ from procblock
51653		- stack[base + 22LLU] = 4319LLU/throw to this address/;
	51990	+ stack[base + 22LLU] = 4358LLU/throw to this address/;
51654	51991	stack[base + 23LLU] = base;
51655		- stack[base + 24LLU] = 4320LLU;
	51992	+ stack[base + 24LLU] = 4359LLU;
51656	51993	// arguments for call to equ
51657	51994	stack[base + 26LLU] = stack[base + 15]/variant/;
51658	51995	stack[base + 27LLU] = 4LLU;

		@@ -51661,13 +51998,13 @@
51661	51998	label = 18446744073709551600LLU; // equ
51662	51999	break;
51663	52000	}
51664		- case 4319LLU: // copy-back deleter (equ to procblock)
	52001	+ case 4358LLU: // copy-back deleter (equ to procblock)
51665	52002	{
51666	52003	// copy mutable arguments back from call to equ
51667	52004	label = 3386LLU; // continue to roll stack
51668	52005	break;
51669	52006	}
51670		- case 4320LLU: // return from equ to procblock
	52007	+ case 4359LLU: // return from equ to procblock
51671	52008	{
51672	52009	// copy mutable arguments back from call to equ
51673	52010	// copy back results provided by call to equ

		@@ -51674,15 +52011,15 @@
51674	52011	stack[base

Part of diff was cut off due to size limit. Use your local client to view the full diff.

Show on old repository browser