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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisão	1210 (tree)
Hora	2021-03-28 08:13:23
Autor	jakobthomsen

Mensagem de Log

cleanup

Mudança Sumário

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

Diff

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

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

		@@ -37304,13 +37304,13 @@
37304	37304	base = stack[base - 2];
37305	37305	break;
37306	37306	}
37307		- case 3142LLU: // function AssignFrom failed
	37307	+ case 3142LLU: // function assignment failed
37308	37308	{
37309	37309	label = stack[base - 3];
37310	37310	base = stack[base - 2];
37311	37311	break;
37312	37312	}
37313		- case 3141LLU: // AssignFrom
	37313	+ case 3141LLU: // assignment
37314	37314	{
37315	37315	//#define arg0 0
37316	37316	//#define arg1 1

		@@ -37318,20 +37318,13 @@
37318	37318	//#define arg3 3
37319	37319	//#define arg4 4
37320	37320	//#define arg5 5
37321		-//#define arg6 6
37322		-//#define arg7 7
37323		-//#define arg8 8
37324		-//#define arg9 9
37325		-//#define arg10 10
37326		-//#define arg11 11
37327		-//#define arg12 12
37328	37321	label = 3144LLU; // skip deleter
37329	37322	break;
37330	37323	}
37331	37324	case 3143LLU: // deleter
37332	37325	{
37333		- // throw from AssignFrom
37334		- if(!stack[base + 13])
	37326	+ // throw from assignment
	37327	+ if(!stack[base + 6])
37335	37328	{
37336	37329	label = 3142LLU; // skip, variable already deleted/unscoped
37337	37330	break;

		@@ -37341,332 +37334,407 @@
37341	37334	}
37342	37335	case 3144LLU: // skipped deleter
37343	37336	{
37344		- stack[base + 13] = 0;
37345		- label = 3146LLU; // skip deleter
	37337	+ stack[base + 6] = 0;
	37338	+ if(/letdef/0 != ((uint64_t )(stack[base + 1]/letdef*/))[0])
	37339	+ {
	37340	+ label = 3146LLU; // jump to alternative
	37341	+ break;
	37342	+ }
	37343	+
	37344	+ /type/stack[base + 7] = ((uint64_t *)(stack[base + 1]/letdef/))[1][0]/type*/;
	37345	+ /id/stack[base + 8] = ((uint64_t *)(stack[base + 1]/letdef/))[1][1]/id*/;
	37346	+ /index/stack[base + 9] = ((uint64_t *)(stack[base + 1]/letdef/))[1][2]/index*/;
	37347	+ /mutable/stack[base + 10] = ((uint64_t *)(stack[base + 1]/letdef/))[1][3]/mutable*/;
	37348	+ /substruct/stack[base + 11] = ((uint64_t *)(stack[base + 1]/letdef/))[1][4]/substruct*/;
	37349	+
	37350	+ // case
	37351	+ if(!stack[base + 10]/mutable/)
	37352	+ {
	37353	+ label = 3148LLU; // jump to alternative
	37354	+ break;
	37355	+ }
	37356	+
	37357	+ // consequent
	37358	+ label = 3149LLU; // consequent complete
37346	37359	break;
37347	37360	}
37348		- case 3145LLU: // deleter
	37361	+ case 3148LLU: // alternative
37349	37362	{
37350		- // throw from AssignFrom
37351		- if(!stack[base + 14])
	37363	+ fprintf(stderr, "%s", "in function ");
	37364	+ // call reportid from assignment
	37365	+ stack[base + 12LLU] = 3150LLU/throw to this address/;
	37366	+ stack[base + 13LLU] = base;
	37367	+ stack[base + 14LLU] = 3151LLU;
	37368	+ // arguments for call to reportid
	37369	+ stack[base + 15LLU] = stack[base + 0]/fnid/;
	37370	+ // set stack-base & callee-address
	37371	+ base += 15LLU;
	37372	+ label = 18446744073709551586LLU; // reportid
	37373	+ break;
	37374	+ }
	37375	+ case 3150LLU: // copy-back deleter (reportid to assignment)
	37376	+ {
	37377	+ // copy mutable arguments back from call to reportid
	37378	+ label = 3147LLU; // continue to roll stack
	37379	+ break;
	37380	+ }
	37381	+ case 3151LLU: // return from reportid to assignment
	37382	+ {
	37383	+ // copy mutable arguments back from call to reportid
	37384	+ fprintf(stderr, "%s", ": assignment to constant ");
	37385	+ // call reportid from assignment
	37386	+ stack[base + 12LLU] = 3152LLU/throw to this address/;
	37387	+ stack[base + 13LLU] = base;
	37388	+ stack[base + 14LLU] = 3153LLU;
	37389	+ // arguments for call to reportid
	37390	+ stack[base + 15LLU] = stack[base + 8]/id/;
	37391	+ // set stack-base & callee-address
	37392	+ base += 15LLU;
	37393	+ label = 18446744073709551586LLU; // reportid
	37394	+ break;
	37395	+ }
	37396	+ case 3152LLU: // copy-back deleter (reportid to assignment)
	37397	+ {
	37398	+ // copy mutable arguments back from call to reportid
	37399	+ label = 3147LLU; // continue to roll stack
	37400	+ break;
	37401	+ }
	37402	+ case 3153LLU: // return from reportid to assignment
	37403	+ {
	37404	+ // copy mutable arguments back from call to reportid
	37405	+ fprintf(stderr, "%s", "\n");
37352	37406	{
37353		- label = 3143LLU; // skip, variable already deleted/unscoped
	37407	+ label = 3147LLU; // throw: begin to unroll stack
37354	37408	break;
37355	37409	}
37356	37410
37357		- uint64_t newstack = (uint64_t )(stack[base + 14] - sizeof(uint64_t) * 4);
37358		- // call ~type from AssignFrom
37359		- newstack[0] = (uint64_t)stack; // backup stack location
37360		- newstack[1] = 1234567890;
37361		- newstack[2] = base;
37362		- newstack[3] = 3147LLU;
37363		- stack = newstack;
37364		- // set stack-base & callee-address
37365		- base = 4/deloffset/;
37366		- label = 310LLU; // ~type
	37411	+ label = 3149LLU; // alternative complete
37367	37412	break;
37368	37413	}
37369		- case 3147LLU: // return from ~type to AssignFrom
	37414	+ case 3149LLU: // completed if-then-else
37370	37415	{
37371		- stack = (uint64_t *)stack[0];
37372		- // releasing toplevel container
37373		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 14] - sizeof(uint64_t) 4));
37374		-
37375		- label = 3143LLU; // continue unrolling stack, delete next variable
	37416	+ label = 3155LLU; // skip deleter
37376	37417	break;
37377	37418	}
37378		- case 3146LLU: // skipped deleter
	37419	+ case 3154LLU: // deleter
37379	37420	{
37380		- // call getlettype from AssignFrom
37381		- stack[base + 15LLU] = 3148LLU/throw to this address/;
37382		- stack[base + 16LLU] = base;
37383		- stack[base + 17LLU] = 3149LLU;
37384		- // arguments for call to getlettype
37385		- stack[base + 19LLU] = stack[base + 0]/fnid/;
37386		- stack[base + 20LLU] = stack[base + 1]/id/;
37387		- stack[base + 21LLU] = stack[base + 4]/scopes/;
37388		- stack[base + 22LLU] = stack[base + 5]/scope/;
	37421	+ // throw from assignment
	37422	+ if(!stack[base + 12])
	37423	+ {
	37424	+ label = 3147LLU; // skip, variable already deleted/unscoped
	37425	+ break;
	37426	+ }
	37427	+ label = 3147LLU; // continue unrolling stack, delete next variable
	37428	+ break;
	37429	+ }
	37430	+ case 3155LLU: // skipped deleter
	37431	+ {
	37432	+ label = 3157LLU; // skip deleter
	37433	+ break;
	37434	+ }
	37435	+ case 3156LLU: // deleter
	37436	+ {
	37437	+ // throw from assignment
	37438	+ if(!stack[base + 13])
	37439	+ {
	37440	+ label = 3154LLU; // skip, variable already deleted/unscoped
	37441	+ break;
	37442	+ }
	37443	+ label = 3154LLU; // continue unrolling stack, delete next variable
	37444	+ break;
	37445	+ }
	37446	+ case 3157LLU: // skipped deleter
	37447	+ {
	37448	+ // call ParseToken from assignment
	37449	+ stack[base + 14LLU] = 3158LLU/throw to this address/;
	37450	+ stack[base + 15LLU] = base;
	37451	+ stack[base + 16LLU] = 3159LLU;
	37452	+ // arguments for call to ParseToken
	37453	+ stack[base + 19LLU] = stack[base + 5]/lookahead/;
37389	37454	// set stack-base & callee-address
37390		- base += 18LLU;
37391		- label = 692LLU; // getlettype
	37455	+ base += 17LLU;
	37456	+ label = 3LLU; // ParseToken
37392	37457	break;
37393	37458	}
37394		- case 3148LLU: // copy-back deleter (getlettype to AssignFrom)
	37459	+ case 3158LLU: // copy-back deleter (ParseToken to assignment)
37395	37460	{
37396		- // copy mutable arguments back from call to getlettype
37397		- label = 3143LLU; // continue to roll stack
	37461	+ // copy mutable arguments back from call to ParseToken
	37462	+ stack[base + 5]/lookahead/ = stack[base + 19LLU];
	37463	+ label = 3147LLU; // continue to roll stack
37398	37464	break;
37399	37465	}
37400		- case 3149LLU: // return from getlettype to AssignFrom
	37466	+ case 3159LLU: // return from ParseToken to assignment
37401	37467	{
37402		- // copy mutable arguments back from call to getlettype
37403		- // copy back results provided by call to getlettype
37404		- stack[base + 14] = stack[base + 18LLU];
37405		- if(/typedata/0 != ((uint64_t )(stack[base + 14]/type*/))[0])
	37468	+ // copy mutable arguments back from call to ParseToken
	37469	+ stack[base + 5]/lookahead/ = stack[base + 19LLU];
	37470	+ // copy back results provided by call to ParseToken
	37471	+ stack[base + 12] = stack[base + 17LLU];
	37472	+ stack[base + 13] = stack[base + 18LLU];
	37473	+ if(/typedata/0 != ((uint64_t )(stack[base + 7]/type*/))[0])
37406	37474	{
37407		- label = 3151LLU; // jump to alternative
	37475	+ label = 3161LLU; // jump to alternative
37408	37476	break;
37409	37477	}
37410	37478
37411		- /name/stack[base + 15] = ((uint64_t *)(stack[base + 14]/type/))[1][0]/name*/;
	37479	+ /name/stack[base + 14] = ((uint64_t *)(stack[base + 7]/type/))[1][0]/name*/;
37412	37480
37413	37481	// case
37414		- // call equ from AssignFrom
37415		- stack[base + 16LLU] = 3153LLU/throw to this address/;
37416		- stack[base + 17LLU] = base;
37417		- stack[base + 18LLU] = 3154LLU;
	37482	+ // call equ from assignment
	37483	+ stack[base + 15LLU] = 3163LLU/throw to this address/;
	37484	+ stack[base + 16LLU] = base;
	37485	+ stack[base + 17LLU] = 3164LLU;
37418	37486	// arguments for call to equ
37419		- stack[base + 20LLU] = 881834713755418624LLU;
37420		- stack[base + 21LLU] = stack[base + 15]/name/;
	37487	+ stack[base + 19LLU] = 881834713755418624LLU;
	37488	+ stack[base + 20LLU] = stack[base + 14]/name/;
37421	37489	// set stack-base & callee-address
37422		- base += 19LLU;
	37490	+ base += 18LLU;
37423	37491	label = 18446744073709551600LLU; // equ
37424	37492	break;
37425	37493	}
37426		- case 3153LLU: // copy-back deleter (equ to AssignFrom)
	37494	+ case 3163LLU: // copy-back deleter (equ to assignment)
37427	37495	{
37428	37496	// copy mutable arguments back from call to equ
37429		- label = 3152LLU; // continue to roll stack
	37497	+ label = 3162LLU; // continue to roll stack
37430	37498	break;
37431	37499	}
37432		- case 3154LLU: // return from equ to AssignFrom
	37500	+ case 3164LLU: // return from equ to assignment
37433	37501	{
37434	37502	// copy mutable arguments back from call to equ
37435	37503	// copy back results provided by call to equ
37436		- stack[base + 13] = stack[base + 19LLU];
37437		- if(!stack[base + 13]/isequal/)
	37504	+ stack[base + 6] = stack[base + 18LLU];
	37505	+ if(!stack[base + 6]/isequal/)
37438	37506	{
37439		- label = 3155LLU; // jump to alternative
	37507	+ label = 3165LLU; // jump to alternative
37440	37508	break;
37441	37509	}
37442	37510
37443	37511	// consequent
37444		- // call isncs from AssignFrom
37445		- stack[base + 16LLU] = 3157LLU/throw to this address/;
37446		- stack[base + 17LLU] = base;
37447		- stack[base + 18LLU] = 3158LLU;
	37512	+ // call isncs from assignment
	37513	+ stack[base + 15LLU] = 3167LLU/throw to this address/;
	37514	+ stack[base + 16LLU] = base;
	37515	+ stack[base + 17LLU] = 3168LLU;
37448	37516	// arguments for call to isncs
37449		- stack[base + 20LLU] = stack[base + 11]/variant/;
	37517	+ stack[base + 19LLU] = stack[base + 12]/variant/;
37450	37518	// set stack-base & callee-address
37451		- base += 19LLU;
	37519	+ base += 18LLU;
37452	37520	label = 286LLU; // isncs
37453	37521	break;
37454	37522	}
37455		- case 3157LLU: // copy-back deleter (isncs to AssignFrom)
	37523	+ case 3167LLU: // copy-back deleter (isncs to assignment)
37456	37524	{
37457	37525	// copy mutable arguments back from call to isncs
37458		- label = 3152LLU; // continue to roll stack
	37526	+ label = 3162LLU; // continue to roll stack
37459	37527	break;
37460	37528	}
37461		- case 3158LLU: // return from isncs to AssignFrom
	37529	+ case 3168LLU: // return from isncs to assignment
37462	37530	{
37463	37531	// copy mutable arguments back from call to isncs
37464	37532	// copy back results provided by call to isncs
37465		- stack[base + 13] = stack[base + 19LLU];
37466		- if(!stack[base + 13]/isequal/)
	37533	+ stack[base + 6] = stack[base + 18LLU];
	37534	+ if(!stack[base + 6]/isequal/)
37467	37535	{
37468		- label = 3159LLU; // jump to alternative
	37536	+ label = 3169LLU; // jump to alternative
37469	37537	break;
37470	37538	}
37471	37539
37472	37540	// consequent
37473	37541	printf("%s", "\n ");
37474		- // call emitvar from AssignFrom
37475		- stack[base + 16LLU] = 3161LLU/throw to this address/;
37476		- stack[base + 17LLU] = base;
37477		- stack[base + 18LLU] = 3162LLU;
	37542	+ // call emitvar from assignment
	37543	+ stack[base + 15LLU] = 3171LLU/throw to this address/;
	37544	+ stack[base + 16LLU] = base;
	37545	+ stack[base + 17LLU] = 3172LLU;
37478	37546	// arguments for call to emitvar
37479		- stack[base + 19LLU] = stack[base + 0]/fnid/;
37480		- stack[base + 20LLU] = stack[base + 1]/id/;
37481		- stack[base + 21LLU] = stack[base + 4]/scopes/;
37482		- stack[base + 22LLU] = stack[base + 5]/scope/;
	37547	+ stack[base + 18LLU] = stack[base + 0]/fnid/;
	37548	+ stack[base + 19LLU] = stack[base + 8]/id/;
	37549	+ stack[base + 20LLU] = stack[base + 3]/scopes/;
	37550	+ stack[base + 21LLU] = stack[base + 4]/scope/;
37483	37551	// set stack-base & callee-address
37484		- base += 19LLU;
	37552	+ base += 18LLU;
37485	37553	label = 749LLU; // emitvar
37486	37554	break;
37487	37555	}
37488		- case 3161LLU: // copy-back deleter (emitvar to AssignFrom)
	37556	+ case 3171LLU: // copy-back deleter (emitvar to assignment)
37489	37557	{
37490	37558	// copy mutable arguments back from call to emitvar
37491		- label = 3152LLU; // continue to roll stack
	37559	+ label = 3162LLU; // continue to roll stack
37492	37560	break;
37493	37561	}
37494		- case 3162LLU: // return from emitvar to AssignFrom
	37562	+ case 3172LLU: // return from emitvar to assignment
37495	37563	{
37496	37564	// copy mutable arguments back from call to emitvar
37497	37565	printf("%s", " = ");
37498		- // call printnr from AssignFrom
37499		- stack[base + 16LLU] = 3163LLU/throw to this address/;
37500		- stack[base + 17LLU] = base;
37501		- stack[base + 18LLU] = 3164LLU;
	37566	+ // call printnr from assignment
	37567	+ stack[base + 15LLU] = 3173LLU/throw to this address/;
	37568	+ stack[base + 16LLU] = base;
	37569	+ stack[base + 17LLU] = 3174LLU;
37502	37570	// arguments for call to printnr
37503		- stack[base + 19LLU] = stack[base + 12]/content/;
	37571	+ stack[base + 18LLU] = stack[base + 13]/content/;
37504	37572	// set stack-base & callee-address
37505		- base += 19LLU;
	37573	+ base += 18LLU;
37506	37574	label = 18446744073709551590LLU; // printnr
37507	37575	break;
37508	37576	}
37509		- case 3163LLU: // copy-back deleter (printnr to AssignFrom)
	37577	+ case 3173LLU: // copy-back deleter (printnr to assignment)
37510	37578	{
37511	37579	// copy mutable arguments back from call to printnr
37512		- label = 3152LLU; // continue to roll stack
	37580	+ label = 3162LLU; // continue to roll stack
37513	37581	break;
37514	37582	}
37515		- case 3164LLU: // return from printnr to AssignFrom
	37583	+ case 3174LLU: // return from printnr to assignment
37516	37584	{
37517	37585	// copy mutable arguments back from call to printnr
37518	37586	printf("%s", ";");
37519		- label = 3160LLU; // consequent complete
	37587	+ label = 3170LLU; // consequent complete
37520	37588	break;
37521	37589	}
37522		- case 3159LLU: // alternative
	37590	+ case 3169LLU: // alternative
37523	37591	{
37524		- // call equ from AssignFrom
37525		- stack[base + 16LLU] = 3165LLU/throw to this address/;
37526		- stack[base + 17LLU] = base;
37527		- stack[base + 18LLU] = 3166LLU;
	37592	+ // call equ from assignment
	37593	+ stack[base + 15LLU] = 3175LLU/throw to this address/;
	37594	+ stack[base + 16LLU] = base;
	37595	+ stack[base + 17LLU] = 3176LLU;
37528	37596	// arguments for call to equ
37529		- stack[base + 20LLU] = stack[base + 11]/variant/;
37530		- stack[base + 21LLU] = 4LLU;
	37597	+ stack[base + 19LLU] = stack[base + 12]/variant/;
	37598	+ stack[base + 20LLU] = 4LLU;
37531	37599	// set stack-base & callee-address
37532		- base += 19LLU;
	37600	+ base += 18LLU;
37533	37601	label = 18446744073709551600LLU; // equ
37534	37602	break;
37535	37603	}
37536		- case 3165LLU: // copy-back deleter (equ to AssignFrom)
	37604	+ case 3175LLU: // copy-back deleter (equ to assignment)
37537	37605	{
37538	37606	// copy mutable arguments back from call to equ
37539		- label = 3152LLU; // continue to roll stack
	37607	+ label = 3162LLU; // continue to roll stack
37540	37608	break;
37541	37609	}
37542		- case 3166LLU: // return from equ to AssignFrom
	37610	+ case 3176LLU: // return from equ to assignment
37543	37611	{
37544	37612	// copy mutable arguments back from call to equ
37545	37613	// copy back results provided by call to equ
37546		- stack[base + 13] = stack[base + 19LLU];
37547		- if(!stack[base + 13]/isequal/)
	37614	+ stack[base + 6] = stack[base + 18LLU];
	37615	+ if(!stack[base + 6]/isequal/)
37548	37616	{
37549		- label = 3167LLU; // jump to alternative
	37617	+ label = 3177LLU; // jump to alternative
37550	37618	break;
37551	37619	}
37552	37620
37553	37621	// consequent
37554	37622	printf("%s", "\n ");
37555		- // call emitvar from AssignFrom
37556		- stack[base + 16LLU] = 3169LLU/throw to this address/;
37557		- stack[base + 17LLU] = base;
37558		- stack[base + 18LLU] = 3170LLU;
	37623	+ // call emitvar from assignment
	37624	+ stack[base + 15LLU] = 3179LLU/throw to this address/;
	37625	+ stack[base + 16LLU] = base;
	37626	+ stack[base + 17LLU] = 3180LLU;
37559	37627	// arguments for call to emitvar
37560		- stack[base + 19LLU] = stack[base + 0]/fnid/;
37561		- stack[base + 20LLU] = stack[base + 1]/id/;
37562		- stack[base + 21LLU] = stack[base + 4]/scopes/;
37563		- stack[base + 22LLU] = stack[base + 5]/scope/;
	37628	+ stack[base + 18LLU] = stack[base + 0]/fnid/;
	37629	+ stack[base + 19LLU] = stack[base + 8]/id/;
	37630	+ stack[base + 20LLU] = stack[base + 3]/scopes/;
	37631	+ stack[base + 21LLU] = stack[base + 4]/scope/;
37564	37632	// set stack-base & callee-address
37565		- base += 19LLU;
	37633	+ base += 18LLU;
37566	37634	label = 749LLU; // emitvar
37567	37635	break;
37568	37636	}
37569		- case 3169LLU: // copy-back deleter (emitvar to AssignFrom)
	37637	+ case 3179LLU: // copy-back deleter (emitvar to assignment)
37570	37638	{
37571	37639	// copy mutable arguments back from call to emitvar
37572		- label = 3152LLU; // continue to roll stack
	37640	+ label = 3162LLU; // continue to roll stack
37573	37641	break;
37574	37642	}
37575		- case 3170LLU: // return from emitvar to AssignFrom
	37643	+ case 3180LLU: // return from emitvar to assignment
37576	37644	{
37577	37645	// copy mutable arguments back from call to emitvar
37578	37646	printf("%s", " = ");
37579		- // call emitvar from AssignFrom
37580		- stack[base + 16LLU] = 3171LLU/throw to this address/;
37581		- stack[base + 17LLU] = base;
37582		- stack[base + 18LLU] = 3172LLU;
	37647	+ // call emitvar from assignment
	37648	+ stack[base + 15LLU] = 3181LLU/throw to this address/;
	37649	+ stack[base + 16LLU] = base;
	37650	+ stack[base + 17LLU] = 3182LLU;
37583	37651	// arguments for call to emitvar
37584		- stack[base + 19LLU] = stack[base + 0]/fnid/;
37585		- stack[base + 20LLU] = stack[base + 12]/content/;
37586		- stack[base + 21LLU] = stack[base + 4]/scopes/;
37587		- stack[base + 22LLU] = stack[base + 5]/scope/;
	37652	+ stack[base + 18LLU] = stack[base + 0]/fnid/;
	37653	+ stack[base + 19LLU] = stack[base + 13]/content/;
	37654	+ stack[base + 20LLU] = stack[base + 3]/scopes/;
	37655	+ stack[base + 21LLU] = stack[base + 4]/scope/;
37588	37656	// set stack-base & callee-address
37589		- base += 19LLU;
	37657	+ base += 18LLU;
37590	37658	label = 749LLU; // emitvar
37591	37659	break;
37592	37660	}
37593		- case 3171LLU: // copy-back deleter (emitvar to AssignFrom)
	37661	+ case 3181LLU: // copy-back deleter (emitvar to assignment)
37594	37662	{
37595	37663	// copy mutable arguments back from call to emitvar
37596		- label = 3152LLU; // continue to roll stack
	37664	+ label = 3162LLU; // continue to roll stack
37597	37665	break;
37598	37666	}
37599		- case 3172LLU: // return from emitvar to AssignFrom
	37667	+ case 3182LLU: // return from emitvar to assignment
37600	37668	{
37601	37669	// copy mutable arguments back from call to emitvar
37602	37670	printf("%s", ";");
37603		- label = 3168LLU; // consequent complete
	37671	+ label = 3178LLU; // consequent complete
37604	37672	break;
37605	37673	}
37606		- case 3167LLU: // alternative
	37674	+ case 3177LLU: // alternative
37607	37675	{
37608	37676	fprintf(stderr, "%s", "parsing assignment unexpected token ");
37609		- // call reporttok from AssignFrom
37610		- stack[base + 16LLU] = 3173LLU/throw to this address/;
37611		- stack[base + 17LLU] = base;
37612		- stack[base + 18LLU] = 3174LLU;
	37677	+ // call reporttok from assignment
	37678	+ stack[base + 15LLU] = 3183LLU/throw to this address/;
	37679	+ stack[base + 16LLU] = base;
	37680	+ stack[base + 17LLU] = 3184LLU;
37613	37681	// arguments for call to reporttok
37614		- stack[base + 19LLU] = stack[base + 11]/variant/;
37615		- stack[base + 20LLU] = stack[base + 12]/content/;
	37682	+ stack[base + 18LLU] = stack[base + 12]/variant/;
	37683	+ stack[base + 19LLU] = stack[base + 13]/content/;
37616	37684	// set stack-base & callee-address
37617		- base += 19LLU;
	37685	+ base += 18LLU;
37618	37686	label = 18446744073709551582LLU; // reporttok
37619	37687	break;
37620	37688	}
37621		- case 3173LLU: // copy-back deleter (reporttok to AssignFrom)
	37689	+ case 3183LLU: // copy-back deleter (reporttok to assignment)
37622	37690	{
37623	37691	// copy mutable arguments back from call to reporttok
37624		- label = 3152LLU; // continue to roll stack
	37692	+ label = 3162LLU; // continue to roll stack
37625	37693	break;
37626	37694	}
37627		- case 3174LLU: // return from reporttok to AssignFrom
	37695	+ case 3184LLU: // return from reporttok to assignment
37628	37696	{
37629	37697	// copy mutable arguments back from call to reporttok
37630	37698	fprintf(stderr, "%s", "\n");
37631	37699	{
37632		- label = 3152LLU; // throw: begin to unroll stack
	37700	+ label = 3162LLU; // throw: begin to unroll stack
37633	37701	break;
37634	37702	}
37635	37703
37636		- label = 3168LLU; // alternative complete
	37704	+ label = 3178LLU; // alternative complete
37637	37705	break;
37638	37706	}
37639		- case 3168LLU: // completed if-then-else
	37707	+ case 3178LLU: // completed if-then-else
37640	37708	{
37641		- label = 3160LLU; // alternative complete
	37709	+ label = 3170LLU; // alternative complete
37642	37710	break;
37643	37711	}
37644		- case 3160LLU: // completed if-then-else
	37712	+ case 3170LLU: // completed if-then-else
37645	37713	{
37646		- label = 3156LLU; // consequent complete
	37714	+ label = 3166LLU; // consequent complete
37647	37715	break;
37648	37716	}
37649		- case 3155LLU: // alternative
	37717	+ case 3165LLU: // alternative
37650	37718	{
37651	37719	fprintf(stderr, "%s", "in function ");
37652		- // call reportid from AssignFrom
37653		- stack[base + 16LLU] = 3175LLU/throw to this address/;
37654		- stack[base + 17LLU] = base;
37655		- stack[base + 18LLU] = 3176LLU;
	37720	+ // call reportid from assignment
	37721	+ stack[base + 15LLU] = 3185LLU/throw to this address/;
	37722	+ stack[base + 16LLU] = base;
	37723	+ stack[base + 17LLU] = 3186LLU;
37656	37724	// arguments for call to reportid
37657		- stack[base + 19LLU] = stack[base + 0]/fnid/;
	37725	+ stack[base + 18LLU] = stack[base + 0]/fnid/;
37658	37726	// set stack-base & callee-address
37659		- base += 19LLU;
	37727	+ base += 18LLU;
37660	37728	label = 18446744073709551586LLU; // reportid
37661	37729	break;
37662	37730	}
37663		- case 3175LLU: // copy-back deleter (reportid to AssignFrom)
	37731	+ case 3185LLU: // copy-back deleter (reportid to assignment)
37664	37732	{
37665	37733	// copy mutable arguments back from call to reportid
37666		- label = 3152LLU; // continue to roll stack
	37734	+ label = 3162LLU; // continue to roll stack
37667	37735	break;
37668	37736	}
37669		- case 3176LLU: // return from reportid to AssignFrom
	37737	+ case 3186LLU: // return from reportid to assignment
37670	37738	{
37671	37739	// copy mutable arguments back from call to reportid
37672	37740	fprintf(stderr, "%s", ": can only assign to u64 but found ");

		@@ -37673,18 +37741,18 @@
37673	37741	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
37674	37742	if(!newstack)
37675	37743	{
37676		- label = 3152LLU; // throw: begin to unroll stack
	37744	+ label = 3162LLU; // throw: begin to unroll stack
37677	37745	break;
37678	37746	}
37679	37747
37680	37748	newstack[10LLU] = 9876543210LLU; // overflow-marker
37681		- // call reporttype from AssignFrom
	37749	+ // call reporttype from assignment
37682	37750	newstack[0] = (uint64_t)stack; // backup stack location
37683		- newstack[1] = 3177LLU;
	37751	+ newstack[1] = 3187LLU;
37684	37752	newstack[2] = base;
37685		- newstack[3] = 3178LLU;
	37753	+ newstack[3] = 3188LLU;
37686	37754	// arguments for call to reporttype
37687		- newstack[4LLU] = stack[base + 14]/type/;
	37755	+ newstack[4LLU] = stack[base + 7]/type/;
37688	37756	stack = newstack;
37689	37757	// set stack-base & callee-address
37690	37758	base = 4/deloffset/;

		@@ -37691,7 +37759,7 @@
37691	37759	label = 330LLU; // reporttype
37692	37760	break;
37693	37761	}
37694		- case 3177LLU: // copy-back deleter (reporttype to AssignFrom)
	37762	+ case 3187LLU: // copy-back deleter (reporttype to assignment)
37695	37763	{
37696	37764	uint64_t oldstack = (uint64_t )stack[0];
37697	37765	// copy mutable arguments back from call to reporttype

		@@ -37702,10 +37770,10 @@
37702	37770	}
37703	37771	Free(10LLU + 1, sizeof(uint64_t), stack);
37704	37772	stack = oldstack;
37705		- label = 3152LLU; // continue to unroll stack
	37773	+ label = 3162LLU; // continue to unroll stack
37706	37774	break;
37707	37775	}
37708		- case 3178LLU: // return from reporttype to AssignFrom
	37776	+ case 3188LLU: // return from reporttype to assignment
37709	37777	{
37710	37778	uint64_t oldstack = (uint64_t )stack[0];
37711	37779	// copy mutable arguments back from call to reporttype

		@@ -37717,77 +37785,77 @@
37717	37785	Free(10LLU + 1, sizeof(uint64_t), stack);
37718	37786	stack = oldstack;
37719	37787	fprintf(stderr, "%s", " ");
37720		- // call reportid from AssignFrom
37721		- stack[base + 16LLU] = 3179LLU/throw to this address/;
37722		- stack[base + 17LLU] = base;
37723		- stack[base + 18LLU] = 3180LLU;
	37788	+ // call reportid from assignment
	37789	+ stack[base + 15LLU] = 3189LLU/throw to this address/;
	37790	+ stack[base + 16LLU] = base;
	37791	+ stack[base + 17LLU] = 3190LLU;
37724	37792	// arguments for call to reportid
37725		- stack[base + 19LLU] = stack[base + 1]/id/;
	37793	+ stack[base + 18LLU] = stack[base + 8]/id/;
37726	37794	// set stack-base & callee-address
37727		- base += 19LLU;
	37795	+ base += 18LLU;
37728	37796	label = 18446744073709551586LLU; // reportid
37729	37797	break;
37730	37798	}
37731		- case 3179LLU: // copy-back deleter (reportid to AssignFrom)
	37799	+ case 3189LLU: // copy-back deleter (reportid to assignment)
37732	37800	{
37733	37801	// copy mutable arguments back from call to reportid
37734		- label = 3152LLU; // continue to roll stack
	37802	+ label = 3162LLU; // continue to roll stack
37735	37803	break;
37736	37804	}
37737		- case 3180LLU: // return from reportid to AssignFrom
	37805	+ case 3190LLU: // return from reportid to assignment
37738	37806	{
37739	37807	// copy mutable arguments back from call to reportid
37740	37808	fprintf(stderr, "%s", " instead - use SWAP\n");
37741	37809	{
37742		- label = 3152LLU; // throw: begin to unroll stack
	37810	+ label = 3162LLU; // throw: begin to unroll stack
37743	37811	break;
37744	37812	}
37745	37813
37746		- label = 3156LLU; // alternative complete
	37814	+ label = 3166LLU; // alternative complete
37747	37815	break;
37748	37816	}
37749		- case 3156LLU: // completed if-then-else
	37817	+ case 3166LLU: // completed if-then-else
37750	37818	{
37751		- ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
37752		- label = 3150LLU; // case complete
	37819	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
	37820	+ label = 3160LLU; // case complete
37753	37821	break;
37754	37822	}
37755		- case 3152LLU: // copy-back deleter (switch)
	37823	+ case 3162LLU: // copy-back deleter (switch)
37756	37824	{
37757		- ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
37758		- label = 3145LLU; // continue to unroll stack
	37825	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
	37826	+ label = 3156LLU; // continue to unroll stack
37759	37827	break;
37760	37828	}
37761		- case 3151LLU: // try next case
	37829	+ case 3161LLU: // try next case
37762	37830	{
37763		- if(/typelist/1 != ((uint64_t )(stack[base + 14]/type*/))[0])
	37831	+ if(/typelist/1 != ((uint64_t )(stack[base + 7]/type*/))[0])
37764	37832	{
37765		- label = 3181LLU; // jump to alternative
	37833	+ label = 3191LLU; // jump to alternative
37766	37834	break;
37767	37835	}
37768	37836
37769		- /subtype/stack[base + 15] = ((uint64_t *)(stack[base + 14]/type/))[1][0]/subtype*/;
	37837	+ /subtype/stack[base + 14] = ((uint64_t *)(stack[base + 7]/type/))[1][0]/subtype*/;
37770	37838
37771	37839	// case
37772	37840	fprintf(stderr, "%s", "in function ");
37773		- // call reportid from AssignFrom
37774		- stack[base + 16LLU] = 3183LLU/throw to this address/;
37775		- stack[base + 17LLU] = base;
37776		- stack[base + 18LLU] = 3184LLU;
	37841	+ // call reportid from assignment
	37842	+ stack[base + 15LLU] = 3193LLU/throw to this address/;
	37843	+ stack[base + 16LLU] = base;
	37844	+ stack[base + 17LLU] = 3194LLU;
37777	37845	// arguments for call to reportid
37778		- stack[base + 19LLU] = stack[base + 0]/fnid/;
	37846	+ stack[base + 18LLU] = stack[base + 0]/fnid/;
37779	37847	// set stack-base & callee-address
37780		- base += 19LLU;
	37848	+ base += 18LLU;
37781	37849	label = 18446744073709551586LLU; // reportid
37782	37850	break;
37783	37851	}
37784		- case 3183LLU: // copy-back deleter (reportid to AssignFrom)
	37852	+ case 3193LLU: // copy-back deleter (reportid to assignment)
37785	37853	{
37786	37854	// copy mutable arguments back from call to reportid
37787		- label = 3182LLU; // continue to roll stack
	37855	+ label = 3192LLU; // continue to roll stack
37788	37856	break;
37789	37857	}
37790		- case 3184LLU: // return from reportid to AssignFrom
	37858	+ case 3194LLU: // return from reportid to assignment
37791	37859	{
37792	37860	// copy mutable arguments back from call to reportid
37793	37861	fprintf(stderr, "%s", ": cannot assign to list ");

		@@ -37794,18 +37862,18 @@
37794	37862	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
37795	37863	if(!newstack)
37796	37864	{
37797		- label = 3182LLU; // throw: begin to unroll stack
	37865	+ label = 3192LLU; // throw: begin to unroll stack
37798	37866	break;
37799	37867	}
37800	37868
37801	37869	newstack[10LLU] = 9876543210LLU; // overflow-marker
37802		- // call reporttype from AssignFrom
	37870	+ // call reporttype from assignment
37803	37871	newstack[0] = (uint64_t)stack; // backup stack location
37804		- newstack[1] = 3185LLU;
	37872	+ newstack[1] = 3195LLU;
37805	37873	newstack[2] = base;
37806		- newstack[3] = 3186LLU;
	37874	+ newstack[3] = 3196LLU;
37807	37875	// arguments for call to reporttype
37808		- newstack[4LLU] = stack[base + 14]/type/;
	37876	+ newstack[4LLU] = stack[base + 7]/type/;
37809	37877	stack = newstack;
37810	37878	// set stack-base & callee-address
37811	37879	base = 4/deloffset/;

		@@ -37812,7 +37880,7 @@
37812	37880	label = 330LLU; // reporttype
37813	37881	break;
37814	37882	}
37815		- case 3185LLU: // copy-back deleter (reporttype to AssignFrom)
	37883	+ case 3195LLU: // copy-back deleter (reporttype to assignment)
37816	37884	{
37817	37885	uint64_t oldstack = (uint64_t )stack[0];
37818	37886	// copy mutable arguments back from call to reporttype

		@@ -37823,10 +37891,10 @@
37823	37891	}
37824	37892	Free(10LLU + 1, sizeof(uint64_t), stack);
37825	37893	stack = oldstack;
37826		- label = 3182LLU; // continue to unroll stack
	37894	+ label = 3192LLU; // continue to unroll stack
37827	37895	break;
37828	37896	}
37829		- case 3186LLU: // return from reporttype to AssignFrom
	37897	+ case 3196LLU: // return from reporttype to assignment
37830	37898	{
37831	37899	uint64_t oldstack = (uint64_t )stack[0];
37832	37900	// copy mutable arguments back from call to reporttype

		@@ -37838,80 +37906,86 @@
37838	37906	Free(10LLU + 1, sizeof(uint64_t), stack);
37839	37907	stack = oldstack;
37840	37908	fprintf(stderr, "%s", " ");
37841		- // call reportid from AssignFrom
37842		- stack[base + 16LLU] = 3187LLU/throw to this address/;
37843		- stack[base + 17LLU] = base;
37844		- stack[base + 18LLU] = 3188LLU;
	37909	+ // call reportid from assignment
	37910	+ stack[base + 15LLU] = 3197LLU/throw to this address/;
	37911	+ stack[base + 16LLU] = base;
	37912	+ stack[base + 17LLU] = 3198LLU;
37845	37913	// arguments for call to reportid
37846		- stack[base + 19LLU] = stack[base + 1]/id/;
	37914	+ stack[base + 18LLU] = stack[base + 8]/id/;
37847	37915	// set stack-base & callee-address
37848		- base += 19LLU;
	37916	+ base += 18LLU;
37849	37917	label = 18446744073709551586LLU; // reportid
37850	37918	break;
37851	37919	}
37852		- case 3187LLU: // copy-back deleter (reportid to AssignFrom)
	37920	+ case 3197LLU: // copy-back deleter (reportid to assignment)
37853	37921	{
37854	37922	// copy mutable arguments back from call to reportid
37855		- label = 3182LLU; // continue to roll stack
	37923	+ label = 3192LLU; // continue to roll stack
37856	37924	break;
37857	37925	}
37858		- case 3188LLU: // return from reportid to AssignFrom
	37926	+ case 3198LLU: // return from reportid to assignment
37859	37927	{
37860	37928	// copy mutable arguments back from call to reportid
37861	37929	fprintf(stderr, "%s", " - use SWAP instead\n");
37862	37930	{
37863		- label = 3182LLU; // throw: begin to unroll stack
	37931	+ label = 3192LLU; // throw: begin to unroll stack
37864	37932	break;
37865	37933	}
37866	37934
37867		- ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
37868		- label = 3150LLU; // case complete
	37935	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
	37936	+ label = 3160LLU; // case complete
37869	37937	break;
37870	37938	}
37871		- case 3182LLU: // copy-back deleter (switch)
	37939	+ case 3192LLU: // copy-back deleter (switch)
37872	37940	{
37873		- ((uint64_t **)(stack[base + 14]))[1][0] = stack[base + 15];
37874		- label = 3145LLU; // continue to unroll stack
	37941	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 14];
	37942	+ label = 3156LLU; // continue to unroll stack
37875	37943	break;
37876	37944	}
37877		- case 3181LLU: // try next case
	37945	+ case 3191LLU: // try next case
37878	37946	{
37879	37947	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
37880	37948	exit(-1);
37881	37949	}
37882		- case 3150LLU: // completed switch
	37950	+ case 3160LLU: // completed switch
37883	37951	{
37884		-
37885		- uint64_t newstack = (uint64_t )(stack[base + 14] - sizeof(uint64_t) * 4);
37886		- // call ~type from AssignFrom
37887		- newstack[0] = (uint64_t)stack; // backup stack location
37888		- newstack[1] = 1234567890;
37889		- newstack[2] = base;
37890		- newstack[3] = 3189LLU;
37891		- stack = newstack;
37892		- // set stack-base & callee-address
37893		- base = 4/deloffset/;
37894		- label = 310LLU; // ~type
	37952	+ ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11];
	37953	+ ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10];
	37954	+ ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9];
	37955	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8];
	37956	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7];
	37957	+ label = 3145LLU; // case complete
37895	37958	break;
37896	37959	}
37897		- case 3189LLU: // return from ~type to AssignFrom
	37960	+ case 3147LLU: // copy-back deleter (switch)
37898	37961	{
37899		- stack = (uint64_t *)stack[0];
37900		- // releasing toplevel container
37901		- Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 14] - sizeof(uint64_t) 4));
37902		-
37903		- // return from AssignFrom
	37962	+ ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 11];
	37963	+ ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 10];
	37964	+ ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 9];
	37965	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 8];
	37966	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 7];
	37967	+ label = 3143LLU; // continue to unroll stack
	37968	+ break;
	37969	+ }
	37970	+ case 3146LLU: // try next case
	37971	+ {
	37972	+ fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
	37973	+ exit(-1);
	37974	+ }
	37975	+ case 3145LLU: // completed switch
	37976	+ {
	37977	+ // return from assignment
37904	37978	label = stack[base - 1];
37905	37979	base = stack[base - 2];
37906	37980	break;
37907	37981	}
37908		- case 3191LLU: // function closescope failed
	37982	+ case 3200LLU: // function closescope failed
37909	37983	{
37910	37984	label = stack[base - 3];
37911	37985	base = stack[base - 2];
37912	37986	break;
37913	37987	}
37914		- case 3190LLU: // closescope
	37988	+ case 3199LLU: // closescope
37915	37989	{
37916	37990	//#define arg0 0
37917	37991	//#define arg1 1

		@@ -37919,7 +37993,7 @@
37919	37993	//#define arg3 3
37920	37994	if(/scope/0 != ((uint64_t )(stack[base + 2]/scope*/))[0])
37921	37995	{
37922		- label = 3193LLU; // jump to alternative
	37996	+ label = 3202LLU; // jump to alternative
37923	37997	break;
37924	37998	}
37925	37999

		@@ -37928,14 +38002,14 @@
37928	38002
37929	38003	// case
37930	38004	flippedassign(stack[base + 5]/letdefs/, &stack[base + 6]);
37931		- label = 3195LLU; // start to repeat
	38005	+ label = 3204LLU; // start to repeat
37932	38006	break;
37933	38007	}
37934		- case 3195LLU: // repeat from here
	38008	+ case 3204LLU: // repeat from here
37935	38009	{
37936	38010	if(!stack[base + 6])
37937	38011	{
37938		- label = 3196LLU; // break loop
	38012	+ label = 3205LLU; // break loop
37939	38013	break;
37940	38014	}
37941	38015

		@@ -37945,7 +38019,7 @@
37945	38019	stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
37946	38020	if(/letdef/0 != ((uint64_t )(stack[base + 7]/letdef*/))[0])
37947	38021	{
37948		- label = 3199LLU; // jump to alternative
	38022	+ label = 3208LLU; // jump to alternative
37949	38023	break;
37950	38024	}
37951	38025

		@@ -37959,7 +38033,7 @@
37959	38033	uint64_t newstack = (uint64_t )Calloc(75LLU + 1, sizeof(uint64_t));
37960	38034	if(!newstack)
37961	38035	{
37962		- label = 3200LLU; // throw: begin to unroll stack
	38036	+ label = 3209LLU; // throw: begin to unroll stack
37963	38037	break;
37964	38038	}
37965	38039

		@@ -37966,9 +38040,9 @@
37966	38040	newstack[75LLU] = 9876543210LLU; // overflow-marker
37967	38041	// call calldestr from closescope
37968	38042	newstack[0] = (uint64_t)stack; // backup stack location
37969		- newstack[1] = 3201LLU;
	38043	+ newstack[1] = 3210LLU;
37970	38044	newstack[2] = base;
37971		- newstack[3] = 3202LLU;
	38045	+ newstack[3] = 3211LLU;
37972	38046	// arguments for call to calldestr
37973	38047	newstack[4LLU] = stack[base + 0]/fnid/;
37974	38048	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -37982,7 +38056,7 @@
37982	38056	label = 1150LLU; // calldestr
37983	38057	break;
37984	38058	}
37985		- case 3201LLU: // copy-back deleter (calldestr to closescope)
	38059	+ case 3210LLU: // copy-back deleter (calldestr to closescope)
37986	38060	{
37987	38061	uint64_t oldstack = (uint64_t )stack[0];
37988	38062	// copy mutable arguments back from call to calldestr

		@@ -37994,10 +38068,10 @@
37994	38068	}
37995	38069	Free(75LLU + 1, sizeof(uint64_t), stack);
37996	38070	stack = oldstack;
37997		- label = 3200LLU; // continue to unroll stack
	38071	+ label = 3209LLU; // continue to unroll stack
37998	38072	break;
37999	38073	}
38000		- case 3202LLU: // return from calldestr to closescope
	38074	+ case 3211LLU: // return from calldestr to closescope
38001	38075	{
38002	38076	uint64_t oldstack = (uint64_t )stack[0];
38003	38077	// copy mutable arguments back from call to calldestr

		@@ -38014,10 +38088,10 @@
38014	38088	((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
38015	38089	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
38016	38090	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
38017		- label = 3198LLU; // case complete
	38091	+ label = 3207LLU; // case complete
38018	38092	break;
38019	38093	}
38020		- case 3200LLU: // copy-back deleter (switch)
	38094	+ case 3209LLU: // copy-back deleter (switch)
38021	38095	{
38022	38096	((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 13];
38023	38097	((uint64_t **)(stack[base + 7]))[1][3] = stack[base + 12];

		@@ -38024,46 +38098,46 @@
38024	38098	((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 11];
38025	38099	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
38026	38100	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
38027		- label = 3197LLU; // continue to unroll stack
	38101	+ label = 3206LLU; // continue to unroll stack
38028	38102	break;
38029	38103	}
38030		- case 3199LLU: // try next case
	38104	+ case 3208LLU: // try next case
38031	38105	{
38032	38106	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38033	38107	exit(-1);
38034	38108	}
38035		- case 3198LLU: // completed switch
	38109	+ case 3207LLU: // completed switch
38036	38110	{
38037	38111	((struct listnode )(stack[base + 8]/previous*/))->data = stack[base + 7];
38038		- label = 3195LLU; // repeat
	38112	+ label = 3204LLU; // repeat
38039	38113	break;
38040	38114	}
38041		- case 3197LLU: // copy-back deleter for while next
	38115	+ case 3206LLU: // copy-back deleter for while next
38042	38116	{
38043	38117	((struct listnode )(stack[base + 8]/previous*/))->data = stack[base + 7];
38044		- label = 3194LLU; // continue to unroll stack
	38118	+ label = 3203LLU; // continue to unroll stack
38045	38119	break;
38046	38120	}
38047		- case 3196LLU: // loop finished
	38121	+ case 3205LLU: // loop finished
38048	38122	{
38049	38123	((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5];
38050	38124	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
38051		- label = 3192LLU; // case complete
	38125	+ label = 3201LLU; // case complete
38052	38126	break;
38053	38127	}
38054		- case 3194LLU: // copy-back deleter (switch)
	38128	+ case 3203LLU: // copy-back deleter (switch)
38055	38129	{
38056	38130	((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 5];
38057	38131	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
38058		- label = 3191LLU; // continue to unroll stack
	38132	+ label = 3200LLU; // continue to unroll stack
38059	38133	break;
38060	38134	}
38061		- case 3193LLU: // try next case
	38135	+ case 3202LLU: // try next case
38062	38136	{
38063	38137	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38064	38138	exit(-1);
38065	38139	}
38066		- case 3192LLU: // completed switch
	38140	+ case 3201LLU: // completed switch
38067	38141	{
38068	38142	// return from closescope
38069	38143	label = stack[base - 1];

		@@ -38070,13 +38144,13 @@
38070	38144	base = stack[base - 2];
38071	38145	break;
38072	38146	}
38073		- case 3204LLU: // function VERBATIM failed
	38147	+ case 3213LLU: // function VERBATIM failed
38074	38148	{
38075	38149	label = stack[base - 3];
38076	38150	base = stack[base - 2];
38077	38151	break;
38078	38152	}
38079		- case 3203LLU: // VERBATIM
	38153	+ case 3212LLU: // VERBATIM
38080	38154	{
38081	38155	//#define arg0 0
38082	38156	#define lookahead stack[base + 0]

		@@ -38097,38 +38171,38 @@
38097	38171
38098	38172	#undef lookahead
38099	38173	printf("%s", "\n");
38100		- label = 3205LLU; // start to repeat
	38174	+ label = 3214LLU; // start to repeat
38101	38175	break;
38102	38176	}
38103		- case 3205LLU: // repeat from here
	38177	+ case 3214LLU: // repeat from here
38104	38178	{
38105	38179	if(stack[base + 0]/lookahead/ > 0xFF)
38106	38180	{
38107		- label = 3206LLU; // break loop
	38181	+ label = 3215LLU; // break loop
38108	38182	break;
38109	38183	}
38110	38184
38111	38185	// loop body
38112		- label = 3208LLU; // skip deleter
	38186	+ label = 3217LLU; // skip deleter
38113	38187	break;
38114	38188	}
38115		- case 3207LLU: // deleter
	38189	+ case 3216LLU: // deleter
38116	38190	{
38117	38191	// throw from VERBATIM
38118	38192	if(!stack[base + 1])
38119	38193	{
38120		- label = 3204LLU; // skip, variable already deleted/unscoped
	38194	+ label = 3213LLU; // skip, variable already deleted/unscoped
38121	38195	break;
38122	38196	}
38123		- label = 3204LLU; // continue unrolling stack, delete next variable
	38197	+ label = 3213LLU; // continue unrolling stack, delete next variable
38124	38198	break;
38125	38199	}
38126		- case 3208LLU: // skipped deleter
	38200	+ case 3217LLU: // skipped deleter
38127	38201	{
38128	38202	// call equ from VERBATIM
38129		- stack[base + 2LLU] = 3209LLU/throw to this address/;
	38203	+ stack[base + 2LLU] = 3218LLU/throw to this address/;
38130	38204	stack[base + 3LLU] = base;
38131		- stack[base + 4LLU] = 3210LLU;
	38205	+ stack[base + 4LLU] = 3219LLU;
38132	38206	// arguments for call to equ
38133	38207	stack[base + 6LLU] = stack[base + 0]/lookahead/;
38134	38208	stack[base + 7LLU] = 96LLU;

		@@ -38137,13 +38211,13 @@
38137	38211	label = 18446744073709551600LLU; // equ
38138	38212	break;
38139	38213	}
38140		- case 3209LLU: // copy-back deleter (equ to VERBATIM)
	38214	+ case 3218LLU: // copy-back deleter (equ to VERBATIM)
38141	38215	{
38142	38216	// copy mutable arguments back from call to equ
38143		- label = 3204LLU; // continue to roll stack
	38217	+ label = 3213LLU; // continue to roll stack
38144	38218	break;
38145	38219	}
38146		- case 3210LLU: // return from equ to VERBATIM
	38220	+ case 3219LLU: // return from equ to VERBATIM
38147	38221	{
38148	38222	// copy mutable arguments back from call to equ
38149	38223	// copy back results provided by call to equ

		@@ -38150,15 +38224,15 @@
38150	38224	stack[base + 1] = stack[base + 5LLU];
38151	38225	if(!stack[base + 1]/isequal/)
38152	38226	{
38153		- label = 3211LLU; // jump to alternative
	38227	+ label = 3220LLU; // jump to alternative
38154	38228	break;
38155	38229	}
38156	38230
38157	38231	// consequent
38158	38232	// call EOSbyte from VERBATIM
38159		- stack[base + 2LLU] = 3213LLU/throw to this address/;
	38233	+ stack[base + 2LLU] = 3222LLU/throw to this address/;
38160	38234	stack[base + 3LLU] = base;
38161		- stack[base + 4LLU] = 3214LLU;
	38235	+ stack[base + 4LLU] = 3223LLU;
38162	38236	// arguments for call to EOSbyte
38163	38237	// set stack-base & callee-address
38164	38238	base += 5LLU;

		@@ -38165,26 +38239,26 @@
38165	38239	label = 77LLU; // EOSbyte
38166	38240	break;
38167	38241	}
38168		- case 3213LLU: // copy-back deleter (EOSbyte to VERBATIM)
	38242	+ case 3222LLU: // copy-back deleter (EOSbyte to VERBATIM)
38169	38243	{
38170	38244	// copy mutable arguments back from call to EOSbyte
38171		- label = 3207LLU; // continue to roll stack
	38245	+ label = 3216LLU; // continue to roll stack
38172	38246	break;
38173	38247	}
38174		- case 3214LLU: // return from EOSbyte to VERBATIM
	38248	+ case 3223LLU: // return from EOSbyte to VERBATIM
38175	38249	{
38176	38250	// copy mutable arguments back from call to EOSbyte
38177	38251	// copy back results provided by call to EOSbyte
38178	38252	stack[base + 0] = stack[base + 5LLU];
38179		- label = 3212LLU; // consequent complete
	38253	+ label = 3221LLU; // consequent complete
38180	38254	break;
38181	38255	}
38182		- case 3211LLU: // alternative
	38256	+ case 3220LLU: // alternative
38183	38257	{
38184	38258	// call printbyte from VERBATIM
38185		- stack[base + 2LLU] = 3215LLU/throw to this address/;
	38259	+ stack[base + 2LLU] = 3224LLU/throw to this address/;
38186	38260	stack[base + 3LLU] = base;
38187		- stack[base + 4LLU] = 3216LLU;
	38261	+ stack[base + 4LLU] = 3225LLU;
38188	38262	// arguments for call to printbyte
38189	38263	stack[base + 5LLU] = stack[base + 0]/lookahead/;
38190	38264	// set stack-base & callee-address

		@@ -38192,25 +38266,25 @@
38192	38266	label = 18446744073709551592LLU; // printbyte
38193	38267	break;
38194	38268	}
38195		- case 3215LLU: // copy-back deleter (printbyte to VERBATIM)
	38269	+ case 3224LLU: // copy-back deleter (printbyte to VERBATIM)
38196	38270	{
38197	38271	// copy mutable arguments back from call to printbyte
38198		- label = 3207LLU; // continue to roll stack
	38272	+ label = 3216LLU; // continue to roll stack
38199	38273	break;
38200	38274	}
38201		- case 3216LLU: // return from printbyte to VERBATIM
	38275	+ case 3225LLU: // return from printbyte to VERBATIM
38202	38276	{
38203	38277	// copy mutable arguments back from call to printbyte
38204		- label = 3212LLU; // alternative complete
	38278	+ label = 3221LLU; // alternative complete
38205	38279	break;
38206	38280	}
38207		- case 3212LLU: // completed if-then-else
	38281	+ case 3221LLU: // completed if-then-else
38208	38282	{
38209	38283	if(stack[base + 0]/lookahead/ <= 0xFF) stack[base + 0]/lookahead/ = getchar();
38210		- label = 3205LLU; // repeat
	38284	+ label = 3214LLU; // repeat
38211	38285	break;
38212	38286	}
38213		- case 3206LLU: // loop finished
	38287	+ case 3215LLU: // loop finished
38214	38288	{
38215	38289	stack[base + 0]/lookahead/ = 32;
38216	38290	// return from VERBATIM

		@@ -38218,18 +38292,18 @@
38218	38292	base = stack[base - 2];
38219	38293	break;
38220	38294	}
38221		- case 3218LLU: // function emitdefine failed
	38295	+ case 3227LLU: // function emitdefine failed
38222	38296	{
38223	38297	label = stack[base - 3];
38224	38298	base = stack[base - 2];
38225	38299	break;
38226	38300	}
38227		- case 3217LLU: // emitdefine
	38301	+ case 3226LLU: // emitdefine
38228	38302	{
38229	38303	//#define arg0 0
38230	38304	if(/scope/0 != ((uint64_t )(stack[base + 0]/scope*/))[0])
38231	38305	{
38232		- label = 3220LLU; // jump to alternative
	38306	+ label = 3229LLU; // jump to alternative
38233	38307	break;
38234	38308	}
38235	38309

		@@ -38238,14 +38312,14 @@
38238	38312
38239	38313	// case
38240	38314	flippedassign(stack[base + 2]/letdefs/, &stack[base + 3]);
38241		- label = 3222LLU; // start to repeat
	38315	+ label = 3231LLU; // start to repeat
38242	38316	break;
38243	38317	}
38244		- case 3222LLU: // repeat from here
	38318	+ case 3231LLU: // repeat from here
38245	38319	{
38246	38320	if(!stack[base + 3])
38247	38321	{
38248		- label = 3223LLU; // break loop
	38322	+ label = 3232LLU; // break loop
38249	38323	break;
38250	38324	}
38251	38325

		@@ -38255,7 +38329,7 @@
38255	38329	stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
38256	38330	if(/letdef/0 != ((uint64_t )(stack[base + 4]/letdef*/))[0])
38257	38331	{
38258		- label = 3226LLU; // jump to alternative
	38332	+ label = 3235LLU; // jump to alternative
38259	38333	break;
38260	38334	}
38261	38335

		@@ -38268,9 +38342,9 @@
38268	38342	// case
38269	38343	printf("%s", "\n#define ");
38270	38344	// call printid from emitdefine
38271		- stack[base + 11LLU] = 3228LLU/throw to this address/;
	38345	+ stack[base + 11LLU] = 3237LLU/throw to this address/;
38272	38346	stack[base + 12LLU] = base;
38273		- stack[base + 13LLU] = 3229LLU;
	38347	+ stack[base + 13LLU] = 3238LLU;
38274	38348	// arguments for call to printid
38275	38349	stack[base + 14LLU] = stack[base + 7]/id/;
38276	38350	// set stack-base & callee-address

		@@ -38278,20 +38352,20 @@
38278	38352	label = 18446744073709551587LLU; // printid
38279	38353	break;
38280	38354	}
38281		- case 3228LLU: // copy-back deleter (printid to emitdefine)
	38355	+ case 3237LLU: // copy-back deleter (printid to emitdefine)
38282	38356	{
38283	38357	// copy mutable arguments back from call to printid
38284		- label = 3227LLU; // continue to roll stack
	38358	+ label = 3236LLU; // continue to roll stack
38285	38359	break;
38286	38360	}
38287		- case 3229LLU: // return from printid to emitdefine
	38361	+ case 3238LLU: // return from printid to emitdefine
38288	38362	{
38289	38363	// copy mutable arguments back from call to printid
38290	38364	printf("%s", " ");
38291	38365	// call emitvaridx from emitdefine
38292		- stack[base + 11LLU] = 3230LLU/throw to this address/;
	38366	+ stack[base + 11LLU] = 3239LLU/throw to this address/;
38293	38367	stack[base + 12LLU] = base;
38294		- stack[base + 13LLU] = 3231LLU;
	38368	+ stack[base + 13LLU] = 3240LLU;
38295	38369	// arguments for call to emitvaridx
38296	38370	stack[base + 14LLU] = stack[base + 8]/index/;
38297	38371	// set stack-base & callee-address

		@@ -38299,13 +38373,13 @@
38299	38373	label = 745LLU; // emitvaridx
38300	38374	break;
38301	38375	}
38302		- case 3230LLU: // copy-back deleter (emitvaridx to emitdefine)
	38376	+ case 3239LLU: // copy-back deleter (emitvaridx to emitdefine)
38303	38377	{
38304	38378	// copy mutable arguments back from call to emitvaridx
38305		- label = 3227LLU; // continue to roll stack
	38379	+ label = 3236LLU; // continue to roll stack
38306	38380	break;
38307	38381	}
38308		- case 3231LLU: // return from emitvaridx to emitdefine
	38382	+ case 3240LLU: // return from emitvaridx to emitdefine
38309	38383	{
38310	38384	// copy mutable arguments back from call to emitvaridx
38311	38385	((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];

		@@ -38313,10 +38387,10 @@
38313	38387	((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
38314	38388	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
38315	38389	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38316		- label = 3225LLU; // case complete
	38390	+ label = 3234LLU; // case complete
38317	38391	break;
38318	38392	}
38319		- case 3227LLU: // copy-back deleter (switch)
	38393	+ case 3236LLU: // copy-back deleter (switch)
38320	38394	{
38321	38395	((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
38322	38396	((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9];

		@@ -38323,46 +38397,46 @@
38323	38397	((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
38324	38398	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
38325	38399	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38326		- label = 3224LLU; // continue to unroll stack
	38400	+ label = 3233LLU; // continue to unroll stack
38327	38401	break;
38328	38402	}
38329		- case 3226LLU: // try next case
	38403	+ case 3235LLU: // try next case
38330	38404	{
38331	38405	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38332	38406	exit(-1);
38333	38407	}
38334		- case 3225LLU: // completed switch
	38408	+ case 3234LLU: // completed switch
38335	38409	{
38336	38410	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38337		- label = 3222LLU; // repeat
	38411	+ label = 3231LLU; // repeat
38338	38412	break;
38339	38413	}
38340		- case 3224LLU: // copy-back deleter for while next
	38414	+ case 3233LLU: // copy-back deleter for while next
38341	38415	{
38342	38416	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38343		- label = 3221LLU; // continue to unroll stack
	38417	+ label = 3230LLU; // continue to unroll stack
38344	38418	break;
38345	38419	}
38346		- case 3223LLU: // loop finished
	38420	+ case 3232LLU: // loop finished
38347	38421	{
38348	38422	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
38349	38423	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38350		- label = 3219LLU; // case complete
	38424	+ label = 3228LLU; // case complete
38351	38425	break;
38352	38426	}
38353		- case 3221LLU: // copy-back deleter (switch)
	38427	+ case 3230LLU: // copy-back deleter (switch)
38354	38428	{
38355	38429	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
38356	38430	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38357		- label = 3218LLU; // continue to unroll stack
	38431	+ label = 3227LLU; // continue to unroll stack
38358	38432	break;
38359	38433	}
38360		- case 3220LLU: // try next case
	38434	+ case 3229LLU: // try next case
38361	38435	{
38362	38436	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38363	38437	exit(-1);
38364	38438	}
38365		- case 3219LLU: // completed switch
	38439	+ case 3228LLU: // completed switch
38366	38440	{
38367	38441	// return from emitdefine
38368	38442	label = stack[base - 1];

		@@ -38369,18 +38443,18 @@
38369	38443	base = stack[base - 2];
38370	38444	break;
38371	38445	}
38372		- case 3233LLU: // function emitundef failed
	38446	+ case 3242LLU: // function emitundef failed
38373	38447	{
38374	38448	label = stack[base - 3];
38375	38449	base = stack[base - 2];
38376	38450	break;
38377	38451	}
38378		- case 3232LLU: // emitundef
	38452	+ case 3241LLU: // emitundef
38379	38453	{
38380	38454	//#define arg0 0
38381	38455	if(/scope/0 != ((uint64_t )(stack[base + 0]/scope*/))[0])
38382	38456	{
38383		- label = 3235LLU; // jump to alternative
	38457	+ label = 3244LLU; // jump to alternative
38384	38458	break;
38385	38459	}
38386	38460

		@@ -38389,14 +38463,14 @@
38389	38463
38390	38464	// case
38391	38465	flippedassign(stack[base + 2]/letdefs/, &stack[base + 3]);
38392		- label = 3237LLU; // start to repeat
	38466	+ label = 3246LLU; // start to repeat
38393	38467	break;
38394	38468	}
38395		- case 3237LLU: // repeat from here
	38469	+ case 3246LLU: // repeat from here
38396	38470	{
38397	38471	if(!stack[base + 3])
38398	38472	{
38399		- label = 3238LLU; // break loop
	38473	+ label = 3247LLU; // break loop
38400	38474	break;
38401	38475	}
38402	38476

		@@ -38406,7 +38480,7 @@
38406	38480	stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
38407	38481	if(/letdef/0 != ((uint64_t )(stack[base + 4]/letdef*/))[0])
38408	38482	{
38409		- label = 3241LLU; // jump to alternative
	38483	+ label = 3250LLU; // jump to alternative
38410	38484	break;
38411	38485	}
38412	38486

		@@ -38419,9 +38493,9 @@
38419	38493	// case
38420	38494	printf("%s", "\n#undef ");
38421	38495	// call printid from emitundef
38422		- stack[base + 11LLU] = 3243LLU/throw to this address/;
	38496	+ stack[base + 11LLU] = 3252LLU/throw to this address/;
38423	38497	stack[base + 12LLU] = base;
38424		- stack[base + 13LLU] = 3244LLU;
	38498	+ stack[base + 13LLU] = 3253LLU;
38425	38499	// arguments for call to printid
38426	38500	stack[base + 14LLU] = stack[base + 7]/id/;
38427	38501	// set stack-base & callee-address

		@@ -38429,13 +38503,13 @@
38429	38503	label = 18446744073709551587LLU; // printid
38430	38504	break;
38431	38505	}
38432		- case 3243LLU: // copy-back deleter (printid to emitundef)
	38506	+ case 3252LLU: // copy-back deleter (printid to emitundef)
38433	38507	{
38434	38508	// copy mutable arguments back from call to printid
38435		- label = 3242LLU; // continue to roll stack
	38509	+ label = 3251LLU; // continue to roll stack
38436	38510	break;
38437	38511	}
38438		- case 3244LLU: // return from printid to emitundef
	38512	+ case 3253LLU: // return from printid to emitundef
38439	38513	{
38440	38514	// copy mutable arguments back from call to printid
38441	38515	((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];

		@@ -38443,10 +38517,10 @@
38443	38517	((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
38444	38518	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
38445	38519	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38446		- label = 3240LLU; // case complete
	38520	+ label = 3249LLU; // case complete
38447	38521	break;
38448	38522	}
38449		- case 3242LLU: // copy-back deleter (switch)
	38523	+ case 3251LLU: // copy-back deleter (switch)
38450	38524	{
38451	38525	((uint64_t **)(stack[base + 4]))[1][4] = stack[base + 10];
38452	38526	((uint64_t **)(stack[base + 4]))[1][3] = stack[base + 9];

		@@ -38453,46 +38527,46 @@
38453	38527	((uint64_t **)(stack[base + 4]))[1][2] = stack[base + 8];
38454	38528	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 7];
38455	38529	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 6];
38456		- label = 3239LLU; // continue to unroll stack
	38530	+ label = 3248LLU; // continue to unroll stack
38457	38531	break;
38458	38532	}
38459		- case 3241LLU: // try next case
	38533	+ case 3250LLU: // try next case
38460	38534	{
38461	38535	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38462	38536	exit(-1);
38463	38537	}
38464		- case 3240LLU: // completed switch
	38538	+ case 3249LLU: // completed switch
38465	38539	{
38466	38540	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38467		- label = 3237LLU; // repeat
	38541	+ label = 3246LLU; // repeat
38468	38542	break;
38469	38543	}
38470		- case 3239LLU: // copy-back deleter for while next
	38544	+ case 3248LLU: // copy-back deleter for while next
38471	38545	{
38472	38546	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38473		- label = 3236LLU; // continue to unroll stack
	38547	+ label = 3245LLU; // continue to unroll stack
38474	38548	break;
38475	38549	}
38476		- case 3238LLU: // loop finished
	38550	+ case 3247LLU: // loop finished
38477	38551	{
38478	38552	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
38479	38553	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38480		- label = 3234LLU; // case complete
	38554	+ label = 3243LLU; // case complete
38481	38555	break;
38482	38556	}
38483		- case 3236LLU: // copy-back deleter (switch)
	38557	+ case 3245LLU: // copy-back deleter (switch)
38484	38558	{
38485	38559	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
38486	38560	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
38487		- label = 3233LLU; // continue to unroll stack
	38561	+ label = 3242LLU; // continue to unroll stack
38488	38562	break;
38489	38563	}
38490		- case 3235LLU: // try next case
	38564	+ case 3244LLU: // try next case
38491	38565	{
38492	38566	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
38493	38567	exit(-1);
38494	38568	}
38495		- case 3234LLU: // completed switch
	38569	+ case 3243LLU: // completed switch
38496	38570	{
38497	38571	// return from emitundef
38498	38572	label = stack[base - 1];

		@@ -38499,26 +38573,26 @@
38499	38573	base = stack[base - 2];
38500	38574	break;
38501	38575	}
38502		- case 3246LLU: // function verbatim failed
	38576	+ case 3255LLU: // function verbatim failed
38503	38577	{
38504	38578	label = stack[base - 3];
38505	38579	base = stack[base - 2];
38506	38580	break;
38507	38581	}
38508		- case 3245LLU: // verbatim
	38582	+ case 3254LLU: // verbatim
38509	38583	{
38510	38584	//#define arg0 0
38511	38585	//#define arg1 1
38512	38586	//#define arg2 2
38513	38587	flippedassign(stack[base + 0]/scopes/, &stack[base + 3]);
38514		- label = 3247LLU; // start to repeat
	38588	+ label = 3256LLU; // start to repeat
38515	38589	break;
38516	38590	}
38517		- case 3247LLU: // repeat from here
	38591	+ case 3256LLU: // repeat from here
38518	38592	{
38519	38593	if(!stack[base + 3])
38520	38594	{
38521		- label = 3248LLU; // break loop
	38595	+ label = 3257LLU; // break loop
38522	38596	break;
38523	38597	}
38524	38598

		@@ -38527,88 +38601,88 @@
38527	38601	stack[base + 5]/previous/ = stack[base + 3];
38528	38602	stack[base + 3] = (uint64_t)(((const struct listnode *)(stack[base + 3]))->next);
38529	38603	// call emitdefine from verbatim
38530		- stack[base + 6LLU] = 3250LLU/throw to this address/;
	38604	+ stack[base + 6LLU] = 3259LLU/throw to this address/;
38531	38605	stack[base + 7LLU] = base;
38532		- stack[base + 8LLU] = 3251LLU;
	38606	+ stack[base + 8LLU] = 3260LLU;
38533	38607	// arguments for call to emitdefine
38534	38608	stack[base + 9LLU] = stack[base + 4]/scope/;
38535	38609	// set stack-base & callee-address
38536	38610	base += 9LLU;
38537		- label = 3217LLU; // emitdefine
	38611	+ label = 3226LLU; // emitdefine
38538	38612	break;
38539	38613	}
38540		- case 3250LLU: // copy-back deleter (emitdefine to verbatim)
	38614	+ case 3259LLU: // copy-back deleter (emitdefine to verbatim)
38541	38615	{
38542	38616	// copy mutable arguments back from call to emitdefine
38543		- label = 3249LLU; // continue to roll stack
	38617	+ label = 3258LLU; // continue to roll stack
38544	38618	break;
38545	38619	}
38546		- case 3251LLU: // return from emitdefine to verbatim
	38620	+ case 3260LLU: // return from emitdefine to verbatim
38547	38621	{
38548	38622	// copy mutable arguments back from call to emitdefine
38549	38623	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38550		- label = 3247LLU; // repeat
	38624	+ label = 3256LLU; // repeat
38551	38625	break;
38552	38626	}
38553		- case 3249LLU: // copy-back deleter for while next
	38627	+ case 3258LLU: // copy-back deleter for while next
38554	38628	{
38555	38629	((struct listnode )(stack[base + 5]/previous*/))->data = stack[base + 4];
38556		- label = 3246LLU; // continue to unroll stack
	38630	+ label = 3255LLU; // continue to unroll stack
38557	38631	break;
38558	38632	}
38559		- case 3248LLU: // loop finished
	38633	+ case 3257LLU: // loop finished
38560	38634	{
38561	38635	// call emitdefine from verbatim
38562		- stack[base + 6LLU] = 3252LLU/throw to this address/;
	38636	+ stack[base + 6LLU] = 3261LLU/throw to this address/;
38563	38637	stack[base + 7LLU] = base;
38564		- stack[base + 8LLU] = 3253LLU;
	38638	+ stack[base + 8LLU] = 3262LLU;
38565	38639	// arguments for call to emitdefine
38566	38640	stack[base + 9LLU] = stack[base + 1]/scope/;
38567	38641	// set stack-base & callee-address
38568	38642	base += 9LLU;
38569		- label = 3217LLU; // emitdefine
	38643	+ label = 3226LLU; // emitdefine
38570	38644	break;
38571	38645	}
38572		- case 3252LLU: // copy-back deleter (emitdefine to verbatim)
	38646	+ case 3261LLU: // copy-back deleter (emitdefine to verbatim)
38573	38647	{
38574	38648	// copy mutable arguments back from call to emitdefine
38575		- label = 3246LLU; // continue to roll stack
	38649	+ label = 3255LLU; // continue to roll stack
38576	38650	break;
38577	38651	}
38578		- case 3253LLU: // return from emitdefine to verbatim
	38652	+ case 3262LLU: // return from emitdefine to verbatim
38579	38653	{
38580	38654	// copy mutable arguments back from call to emitdefine
38581	38655	// call VERBATIM from verbatim
38582		- stack[base + 6LLU] = 3254LLU/throw to this address/;
	38656	+ stack[base + 6LLU] = 3263LLU/throw to this address/;
38583	38657	stack[base + 7LLU] = base;
38584		- stack[base + 8LLU] = 3255LLU;
	38658	+ stack[base + 8LLU] = 3264LLU;
38585	38659	// arguments for call to VERBATIM
38586	38660	stack[base + 9LLU] = stack[base + 2]/lookahead/;
38587	38661	// set stack-base & callee-address
38588	38662	base += 9LLU;
38589		- label = 3203LLU; // VERBATIM
	38663	+ label = 3212LLU; // VERBATIM
38590	38664	break;
38591	38665	}
38592		- case 3254LLU: // copy-back deleter (VERBATIM to verbatim)
	38666	+ case 3263LLU: // copy-back deleter (VERBATIM to verbatim)
38593	38667	{
38594	38668	// copy mutable arguments back from call to VERBATIM
38595	38669	stack[base + 2]/lookahead/ = stack[base + 9LLU];
38596		- label = 3246LLU; // continue to roll stack
	38670	+ label = 3255LLU; // continue to roll stack
38597	38671	break;
38598	38672	}
38599		- case 3255LLU: // return from VERBATIM to verbatim
	38673	+ case 3264LLU: // return from VERBATIM to verbatim
38600	38674	{
38601	38675	// copy mutable arguments back from call to VERBATIM
38602	38676	stack[base + 2]/lookahead/ = stack[base + 9LLU];
38603	38677	flippedassign(stack[base + 0]/scopes/, &stack[base + 6]);
38604		- label = 3256LLU; // start to repeat
	38678	+ label = 3265LLU; // start to repeat
38605	38679	break;
38606	38680	}
38607		- case 3256LLU: // repeat from here
	38681	+ case 3265LLU: // repeat from here
38608	38682	{
38609	38683	if(!stack[base + 6])
38610	38684	{
38611		- label = 3257LLU; // break loop
	38685	+ label = 3266LLU; // break loop
38612	38686	break;
38613	38687	}
38614	38688

		@@ -38617,55 +38691,55 @@
38617	38691	stack[base + 8]/previous/ = stack[base + 6];
38618	38692	stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
38619	38693	// call emitundef from verbatim
38620		- stack[base + 9LLU] = 3259LLU/throw to this address/;
	38694	+ stack[base + 9LLU] = 3268LLU/throw to this address/;
38621	38695	stack[base + 10LLU] = base;
38622		- stack[base + 11LLU] = 3260LLU;
	38696	+ stack[base + 11LLU] = 3269LLU;
38623	38697	// arguments for call to emitundef
38624	38698	stack[base + 12LLU] = stack[base + 7]/scope/;
38625	38699	// set stack-base & callee-address
38626	38700	base += 12LLU;
38627		- label = 3232LLU; // emitundef
	38701	+ label = 3241LLU; // emitundef
38628	38702	break;
38629	38703	}
38630		- case 3259LLU: // copy-back deleter (emitundef to verbatim)
	38704	+ case 3268LLU: // copy-back deleter (emitundef to verbatim)
38631	38705	{
38632	38706	// copy mutable arguments back from call to emitundef
38633		- label = 3258LLU; // continue to roll stack
	38707	+ label = 3267LLU; // continue to roll stack
38634	38708	break;
38635	38709	}
38636		- case 3260LLU: // return from emitundef to verbatim
	38710	+ case 3269LLU: // return from emitundef to verbatim
38637	38711	{
38638	38712	// copy mutable arguments back from call to emitundef
38639	38713	((struct listnode )(stack[base + 8]/previous*/))->data = stack[base + 7];
38640		- label = 3256LLU; // repeat
	38714	+ label = 3265LLU; // repeat
38641	38715	break;
38642	38716	}
38643		- case 3258LLU: // copy-back deleter for while next
	38717	+ case 3267LLU: // copy-back deleter for while next
38644	38718	{
38645	38719	((struct listnode )(stack[base + 8]/previous*/))->data = stack[base + 7];
38646		- label = 3246LLU; // continue to unroll stack
	38720	+ label = 3255LLU; // continue to unroll stack
38647	38721	break;
38648	38722	}
38649		- case 3257LLU: // loop finished
	38723	+ case 3266LLU: // loop finished
38650	38724	{
38651	38725	// call emitundef from verbatim
38652		- stack[base + 9LLU] = 3261LLU/throw to this address/;
	38726	+ stack[base + 9LLU] = 3270LLU/throw to this address/;
38653	38727	stack[base + 10LLU] = base;
38654		- stack[base + 11LLU] = 3262LLU;
	38728	+ stack[base + 11LLU] = 3271LLU;
38655	38729	// arguments for call to emitundef
38656	38730	stack[base + 12LLU] = stack[base + 1]/scope/;
38657	38731	// set stack-base & callee-address
38658	38732	base += 12LLU;
38659		- label = 3232LLU; // emitundef
	38733	+ label = 3241LLU; // emitundef
38660	38734	break;
38661	38735	}
38662		- case 3261LLU: // copy-back deleter (emitundef to verbatim)
	38736	+ case 3270LLU: // copy-back deleter (emitundef to verbatim)
38663	38737	{
38664	38738	// copy mutable arguments back from call to emitundef
38665		- label = 3246LLU; // continue to roll stack
	38739	+ label = 3255LLU; // continue to roll stack
38666	38740	break;
38667	38741	}
38668		- case 3262LLU: // return from emitundef to verbatim
	38742	+ case 3271LLU: // return from emitundef to verbatim
38669	38743	{
38670	38744	// copy mutable arguments back from call to emitundef
38671	38745	// return from verbatim

		@@ -38673,39 +38747,39 @@
38673	38747	base = stack[base - 2];
38674	38748	break;
38675	38749	}
38676		- case 3264LLU: // function listtoelem failed
	38750	+ case 3273LLU: // function listtoelem failed
38677	38751	{
38678	38752	label = stack[base - 3];
38679	38753	base = stack[base - 2];
38680	38754	break;
38681	38755	}
38682		- case 3263LLU: // listtoelem
	38756	+ case 3272LLU: // listtoelem
38683	38757	{
38684	38758	//#define res0 0
38685	38759	//#define res1 1
38686	38760	//#define arg0 2
38687	38761	//#define arg1 3
38688		- label = 3266LLU; // skip deleter
	38762	+ label = 3275LLU; // skip deleter
38689	38763	break;
38690	38764	}
38691		- case 3265LLU: // deleter
	38765	+ case 3274LLU: // deleter
38692	38766	{
38693	38767	// throw from listtoelem
38694	38768	if(!stack[base + 4])
38695	38769	{
38696		- label = 3264LLU; // skip, variable already deleted/unscoped
	38770	+ label = 3273LLU; // skip, variable already deleted/unscoped
38697	38771	break;
38698	38772	}
38699		- label = 3264LLU; // continue unrolling stack, delete next variable
	38773	+ label = 3273LLU; // continue unrolling stack, delete next variable
38700	38774	break;
38701	38775	}
38702		- case 3266LLU: // skipped deleter
	38776	+ case 3275LLU: // skipped deleter
38703	38777	{
38704	38778	stack[base + 4] = 0;
38705	38779	// call matchsym from listtoelem
38706		- stack[base + 5LLU] = 3267LLU/throw to this address/;
	38780	+ stack[base + 5LLU] = 3276LLU/throw to this address/;
38707	38781	stack[base + 6LLU] = base;
38708		- stack[base + 7LLU] = 3268LLU;
	38782	+ stack[base + 7LLU] = 3277LLU;
38709	38783	// arguments for call to matchsym
38710	38784	stack[base + 8LLU] = stack[base + 2]/fnid/;
38711	38785	stack[base + 9LLU] = 40LLU;

		@@ -38715,53 +38789,53 @@
38715	38789	label = 246LLU; // matchsym
38716	38790	break;
38717	38791	}
38718		- case 3267LLU: // copy-back deleter (matchsym to listtoelem)
	38792	+ case 3276LLU: // copy-back deleter (matchsym to listtoelem)
38719	38793	{
38720	38794	// copy mutable arguments back from call to matchsym
38721	38795	stack[base + 3]/lookahead/ = stack[base + 10LLU];
38722		- label = 3265LLU; // continue to roll stack
	38796	+ label = 3274LLU; // continue to roll stack
38723	38797	break;
38724	38798	}
38725		- case 3268LLU: // return from matchsym to listtoelem
	38799	+ case 3277LLU: // return from matchsym to listtoelem
38726	38800	{
38727	38801	// copy mutable arguments back from call to matchsym
38728	38802	stack[base + 3]/lookahead/ = stack[base + 10LLU];
38729		- label = 3270LLU; // skip deleter
	38803	+ label = 3279LLU; // skip deleter
38730	38804	break;
38731	38805	}
38732		- case 3269LLU: // deleter
	38806	+ case 3278LLU: // deleter
38733	38807	{
38734	38808	// throw from listtoelem
38735	38809	if(!stack[base + 5])
38736	38810	{
38737		- label = 3265LLU; // skip, variable already deleted/unscoped
	38811	+ label = 3274LLU; // skip, variable already deleted/unscoped
38738	38812	break;
38739	38813	}
38740		- label = 3265LLU; // continue unrolling stack, delete next variable
	38814	+ label = 3274LLU; // continue unrolling stack, delete next variable
38741	38815	break;
38742	38816	}
38743		- case 3270LLU: // skipped deleter
	38817	+ case 3279LLU: // skipped deleter
38744	38818	{
38745		- label = 3272LLU; // skip deleter
	38819	+ label = 3281LLU; // skip deleter
38746	38820	break;
38747	38821	}
38748		- case 3271LLU: // deleter
	38822	+ case 3280LLU: // deleter
38749	38823	{
38750	38824	// throw from listtoelem
38751	38825	if(!stack[base + 6])
38752	38826	{
38753		- label = 3269LLU; // skip, variable already deleted/unscoped
	38827	+ label = 3278LLU; // skip, variable already deleted/unscoped
38754	38828	break;
38755	38829	}
38756		- label = 3269LLU; // continue unrolling stack, delete next variable
	38830	+ label = 3278LLU; // continue unrolling stack, delete next variable
38757	38831	break;
38758	38832	}
38759		- case 3272LLU: // skipped deleter
	38833	+ case 3281LLU: // skipped deleter
38760	38834	{
38761	38835	// call ParseToken from listtoelem
38762		- stack[base + 7LLU] = 3273LLU/throw to this address/;
	38836	+ stack[base + 7LLU] = 3282LLU/throw to this address/;
38763	38837	stack[base + 8LLU] = base;
38764		- stack[base + 9LLU] = 3274LLU;
	38838	+ stack[base + 9LLU] = 3283LLU;
38765	38839	// arguments for call to ParseToken
38766	38840	stack[base + 12LLU] = stack[base + 3]/lookahead/;
38767	38841	// set stack-base & callee-address

		@@ -38769,14 +38843,14 @@
38769	38843	label = 3LLU; // ParseToken
38770	38844	break;
38771	38845	}
38772		- case 3273LLU: // copy-back deleter (ParseToken to listtoelem)
	38846	+ case 3282LLU: // copy-back deleter (ParseToken to listtoelem)
38773	38847	{
38774	38848	// copy mutable arguments back from call to ParseToken
38775	38849	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38776		- label = 3265LLU; // continue to roll stack
	38850	+ label = 3274LLU; // continue to roll stack
38777	38851	break;
38778	38852	}
38779		- case 3274LLU: // return from ParseToken to listtoelem
	38853	+ case 3283LLU: // return from ParseToken to listtoelem
38780	38854	{
38781	38855	// copy mutable arguments back from call to ParseToken
38782	38856	stack[base + 3]/lookahead/ = stack[base + 12LLU];

		@@ -38784,9 +38858,9 @@
38784	38858	stack[base + 5] = stack[base + 10LLU];
38785	38859	stack[base + 6] = stack[base + 11LLU];
38786	38860	// call equ from listtoelem
38787		- stack[base + 7LLU] = 3275LLU/throw to this address/;
	38861	+ stack[base + 7LLU] = 3284LLU/throw to this address/;
38788	38862	stack[base + 8LLU] = base;
38789		- stack[base + 9LLU] = 3276LLU;
	38863	+ stack[base + 9LLU] = 3285LLU;
38790	38864	// arguments for call to equ
38791	38865	stack[base + 11LLU] = stack[base + 5]/variant/;
38792	38866	stack[base + 12LLU] = 4LLU;

		@@ -38795,13 +38869,13 @@
38795	38869	label = 18446744073709551600LLU; // equ
38796	38870	break;
38797	38871	}
38798		- case 3275LLU: // copy-back deleter (equ to listtoelem)
	38872	+ case 3284LLU: // copy-back deleter (equ to listtoelem)
38799	38873	{
38800	38874	// copy mutable arguments back from call to equ
38801		- label = 3271LLU; // continue to roll stack
	38875	+ label = 3280LLU; // continue to roll stack
38802	38876	break;
38803	38877	}
38804		- case 3276LLU: // return from equ to listtoelem
	38878	+ case 3285LLU: // return from equ to listtoelem
38805	38879	{
38806	38880	// copy mutable arguments back from call to equ
38807	38881	// copy back results provided by call to equ

		@@ -38808,21 +38882,21 @@
38808	38882	stack[base + 4] = stack[base + 10LLU];
38809	38883	if(!stack[base + 4]/isequal/)
38810	38884	{
38811		- label = 3277LLU; // jump to alternative
	38885	+ label = 3286LLU; // jump to alternative
38812	38886	break;
38813	38887	}
38814	38888
38815	38889	// consequent
38816		- label = 3278LLU; // consequent complete
	38890	+ label = 3287LLU; // consequent complete
38817	38891	break;
38818	38892	}
38819		- case 3277LLU: // alternative
	38893	+ case 3286LLU: // alternative
38820	38894	{
38821	38895	fprintf(stderr, "%s", "expected identifier in while next but found ");
38822	38896	// call reporttok from listtoelem
38823		- stack[base + 7LLU] = 3279LLU/throw to this address/;
	38897	+ stack[base + 7LLU] = 3288LLU/throw to this address/;
38824	38898	stack[base + 8LLU] = base;
38825		- stack[base + 9LLU] = 3280LLU;
	38899	+ stack[base + 9LLU] = 3289LLU;
38826	38900	// arguments for call to reporttok
38827	38901	stack[base + 10LLU] = stack[base + 5]/variant/;
38828	38902	stack[base + 11LLU] = stack[base + 6]/listid/;

		@@ -38831,30 +38905,30 @@
38831	38905	label = 18446744073709551582LLU; // reporttok
38832	38906	break;
38833	38907	}
38834		- case 3279LLU: // copy-back deleter (reporttok to listtoelem)
	38908	+ case 3288LLU: // copy-back deleter (reporttok to listtoelem)
38835	38909	{
38836	38910	// copy mutable arguments back from call to reporttok
38837		- label = 3271LLU; // continue to roll stack
	38911	+ label = 3280LLU; // continue to roll stack
38838	38912	break;
38839	38913	}
38840		- case 3280LLU: // return from reporttok to listtoelem
	38914	+ case 3289LLU: // return from reporttok to listtoelem
38841	38915	{
38842	38916	// copy mutable arguments back from call to reporttok
38843	38917	fprintf(stderr, "%s", "\n");
38844	38918	{
38845		- label = 3271LLU; // throw: begin to unroll stack
	38919	+ label = 3280LLU; // throw: begin to unroll stack
38846	38920	break;
38847	38921	}
38848	38922
38849		- label = 3278LLU; // alternative complete
	38923	+ label = 3287LLU; // alternative complete
38850	38924	break;
38851	38925	}
38852		- case 3278LLU: // completed if-then-else
	38926	+ case 3287LLU: // completed if-then-else
38853	38927	{
38854	38928	// call matchsym from listtoelem
38855		- stack[base + 7LLU] = 3281LLU/throw to this address/;
	38929	+ stack[base + 7LLU] = 3290LLU/throw to this address/;
38856	38930	stack[base + 8LLU] = base;
38857		- stack[base + 9LLU] = 3282LLU;
	38931	+ stack[base + 9LLU] = 3291LLU;
38858	38932	// arguments for call to matchsym
38859	38933	stack[base + 10LLU] = stack[base + 2]/fnid/;
38860	38934	stack[base + 11LLU] = 41LLU;

		@@ -38864,21 +38938,21 @@
38864	38938	label = 246LLU; // matchsym
38865	38939	break;
38866	38940	}
38867		- case 3281LLU: // copy-back deleter (matchsym to listtoelem)
	38941	+ case 3290LLU: // copy-back deleter (matchsym to listtoelem)
38868	38942	{
38869	38943	// copy mutable arguments back from call to matchsym
38870	38944	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38871		- label = 3271LLU; // continue to roll stack
	38945	+ label = 3280LLU; // continue to roll stack
38872	38946	break;
38873	38947	}
38874		- case 3282LLU: // return from matchsym to listtoelem
	38948	+ case 3291LLU: // return from matchsym to listtoelem
38875	38949	{
38876	38950	// copy mutable arguments back from call to matchsym
38877	38951	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38878	38952	// call matchsym from listtoelem
38879		- stack[base + 7LLU] = 3283LLU/throw to this address/;
	38953	+ stack[base + 7LLU] = 3292LLU/throw to this address/;
38880	38954	stack[base + 8LLU] = base;
38881		- stack[base + 9LLU] = 3284LLU;
	38955	+ stack[base + 9LLU] = 3293LLU;
38882	38956	// arguments for call to matchsym
38883	38957	stack[base + 10LLU] = stack[base + 2]/fnid/;
38884	38958	stack[base + 11LLU] = 45LLU;

		@@ -38888,21 +38962,21 @@
38888	38962	label = 246LLU; // matchsym
38889	38963	break;
38890	38964	}
38891		- case 3283LLU: // copy-back deleter (matchsym to listtoelem)
	38965	+ case 3292LLU: // copy-back deleter (matchsym to listtoelem)
38892	38966	{
38893	38967	// copy mutable arguments back from call to matchsym
38894	38968	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38895		- label = 3271LLU; // continue to roll stack
	38969	+ label = 3280LLU; // continue to roll stack
38896	38970	break;
38897	38971	}
38898		- case 3284LLU: // return from matchsym to listtoelem
	38972	+ case 3293LLU: // return from matchsym to listtoelem
38899	38973	{
38900	38974	// copy mutable arguments back from call to matchsym
38901	38975	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38902	38976	// call matchsym from listtoelem
38903		- stack[base + 7LLU] = 3285LLU/throw to this address/;
	38977	+ stack[base + 7LLU] = 3294LLU/throw to this address/;
38904	38978	stack[base + 8LLU] = base;
38905		- stack[base + 9LLU] = 3286LLU;
	38979	+ stack[base + 9LLU] = 3295LLU;
38906	38980	// arguments for call to matchsym
38907	38981	stack[base + 10LLU] = stack[base + 2]/fnid/;
38908	38982	stack[base + 11LLU] = 62LLU;

		@@ -38912,21 +38986,21 @@
38912	38986	label = 246LLU; // matchsym
38913	38987	break;
38914	38988	}
38915		- case 3285LLU: // copy-back deleter (matchsym to listtoelem)
	38989	+ case 3294LLU: // copy-back deleter (matchsym to listtoelem)
38916	38990	{
38917	38991	// copy mutable arguments back from call to matchsym
38918	38992	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38919		- label = 3271LLU; // continue to roll stack
	38993	+ label = 3280LLU; // continue to roll stack
38920	38994	break;
38921	38995	}
38922		- case 3286LLU: // return from matchsym to listtoelem
	38996	+ case 3295LLU: // return from matchsym to listtoelem
38923	38997	{
38924	38998	// copy mutable arguments back from call to matchsym
38925	38999	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38926	39000	// call matchsym from listtoelem
38927		- stack[base + 7LLU] = 3287LLU/throw to this address/;
	39001	+ stack[base + 7LLU] = 3296LLU/throw to this address/;
38928	39002	stack[base + 8LLU] = base;
38929		- stack[base + 9LLU] = 3288LLU;
	39003	+ stack[base + 9LLU] = 3297LLU;
38930	39004	// arguments for call to matchsym
38931	39005	stack[base + 10LLU] = stack[base + 2]/fnid/;
38932	39006	stack[base + 11LLU] = 40LLU;

		@@ -38936,53 +39010,53 @@
38936	39010	label = 246LLU; // matchsym
38937	39011	break;
38938	39012	}
38939		- case 3287LLU: // copy-back deleter (matchsym to listtoelem)
	39013	+ case 3296LLU: // copy-back deleter (matchsym to listtoelem)
38940	39014	{
38941	39015	// copy mutable arguments back from call to matchsym
38942	39016	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38943		- label = 3271LLU; // continue to roll stack
	39017	+ label = 3280LLU; // continue to roll stack
38944	39018	break;
38945	39019	}
38946		- case 3288LLU: // return from matchsym to listtoelem
	39020	+ case 3297LLU: // return from matchsym to listtoelem
38947	39021	{
38948	39022	// copy mutable arguments back from call to matchsym
38949	39023	stack[base + 3]/lookahead/ = stack[base + 12LLU];
38950		- label = 3290LLU; // skip deleter
	39024	+ label = 3299LLU; // skip deleter
38951	39025	break;
38952	39026	}
38953		- case 3289LLU: // deleter
	39027	+ case 3298LLU: // deleter
38954	39028	{
38955	39029	// throw from listtoelem
38956	39030	if(!stack[base + 7])
38957	39031	{
38958		- label = 3271LLU; // skip, variable already deleted/unscoped
	39032	+ label = 3280LLU; // skip, variable already deleted/unscoped
38959	39033	break;
38960	39034	}
38961		- label = 3271LLU; // continue unrolling stack, delete next variable
	39035	+ label = 3280LLU; // continue unrolling stack, delete next variable
38962	39036	break;
38963	39037	}
38964		- case 3290LLU: // skipped deleter
	39038	+ case 3299LLU: // skipped deleter
38965	39039	{
38966		- label = 3292LLU; // skip deleter
	39040	+ label = 3301LLU; // skip deleter
38967	39041	break;
38968	39042	}
38969		- case 3291LLU: // deleter
	39043	+ case 3300LLU: // deleter
38970	39044	{
38971	39045	// throw from listtoelem
38972	39046	if(!stack[base + 8])
38973	39047	{
38974		- label = 3289LLU; // skip, variable already deleted/unscoped
	39048	+ label = 3298LLU; // skip, variable already deleted/unscoped
38975	39049	break;
38976	39050	}
38977		- label = 3289LLU; // continue unrolling stack, delete next variable
	39051	+ label = 3298LLU; // continue unrolling stack, delete next variable
38978	39052	break;
38979	39053	}
38980		- case 3292LLU: // skipped deleter
	39054	+ case 3301LLU: // skipped deleter
38981	39055	{
38982	39056	// call ParseToken from listtoelem
38983		- stack[base + 9LLU] = 3293LLU/throw to this address/;
	39057	+ stack[base + 9LLU] = 3302LLU/throw to this address/;
38984	39058	stack[base + 10LLU] = base;
38985		- stack[base + 11LLU] = 3294LLU;
	39059	+ stack[base + 11LLU] = 3303LLU;
38986	39060	// arguments for call to ParseToken
38987	39061	stack[base + 14LLU] = stack[base + 3]/lookahead/;
38988	39062	// set stack-base & callee-address

		@@ -38990,14 +39064,14 @@
38990	39064	label = 3LLU; // ParseToken
38991	39065	break;
38992	39066	}
38993		- case 3293LLU: // copy-back deleter (ParseToken to listtoelem)
	39067	+ case 3302LLU: // copy-back deleter (ParseToken to listtoelem)
38994	39068	{
38995	39069	// copy mutable arguments back from call to ParseToken
38996	39070	stack[base + 3]/lookahead/ = stack[base + 14LLU];
38997		- label = 3271LLU; // continue to roll stack
	39071	+ label = 3280LLU; // continue to roll stack
38998	39072	break;
38999	39073	}
39000		- case 3294LLU: // return from ParseToken to listtoelem
	39074	+ case 3303LLU: // return from ParseToken to listtoelem
39001	39075	{
39002	39076	// copy mutable arguments back from call to ParseToken
39003	39077	stack[base + 3]/lookahead/ = stack[base + 14LLU];

		@@ -39005,9 +39079,9 @@
39005	39079	stack[base + 7] = stack[base + 12LLU];
39006	39080	stack[base + 8] = stack[base + 13LLU];
39007	39081	// call equ from listtoelem
39008		- stack[base + 9LLU] = 3295LLU/throw to this address/;
	39082	+ stack[base + 9LLU] = 3304LLU/throw to this address/;
39009	39083	stack[base + 10LLU] = base;
39010		- stack[base + 11LLU] = 3296LLU;
	39084	+ stack[base + 11LLU] = 3305LLU;
39011	39085	// arguments for call to equ
39012	39086	stack[base + 13LLU] = stack[base + 7]/variant/;
39013	39087	stack[base + 14LLU] = 4LLU;

		@@ -39016,13 +39090,13 @@
39016	39090	label = 18446744073709551600LLU; // equ
39017	39091	break;
39018	39092	}
39019		- case 3295LLU: // copy-back deleter (equ to listtoelem)
	39093	+ case 3304LLU: // copy-back deleter (equ to listtoelem)
39020	39094	{
39021	39095	// copy mutable arguments back from call to equ
39022		- label = 3291LLU; // continue to roll stack
	39096	+ label = 3300LLU; // continue to roll stack
39023	39097	break;
39024	39098	}
39025		- case 3296LLU: // return from equ to listtoelem
	39099	+ case 3305LLU: // return from equ to listtoelem
39026	39100	{
39027	39101	// copy mutable arguments back from call to equ
39028	39102	// copy back results provided by call to equ

		@@ -39029,21 +39103,21 @@
39029	39103	stack[base + 4] = stack[base + 12LLU];
39030	39104	if(!stack[base + 4]/isequal/)
39031	39105	{
39032		- label = 3297LLU; // jump to alternative
	39106	+ label = 3306LLU; // jump to alternative
39033	39107	break;
39034	39108	}
39035	39109
39036	39110	// consequent
39037		- label = 3298LLU; // consequent complete
	39111	+ label = 3307LLU; // consequent complete
39038	39112	break;
39039	39113	}
39040		- case 3297LLU: // alternative
	39114	+ case 3306LLU: // alternative
39041	39115	{
39042	39116	fprintf(stderr, "%s", "expected identifier in while next but found ");
39043	39117	// call reporttok from listtoelem
39044		- stack[base + 9LLU] = 3299LLU/throw to this address/;
	39118	+ stack[base + 9LLU] = 3308LLU/throw to this address/;
39045	39119	stack[base + 10LLU] = base;
39046		- stack[base + 11LLU] = 3300LLU;
	39120	+ stack[base + 11LLU] = 3309LLU;
39047	39121	// arguments for call to reporttok
39048	39122	stack[base + 12LLU] = stack[base + 7]/variant/;
39049	39123	stack[base + 13LLU] = stack[base + 8]/elemid/;

		@@ -39052,30 +39126,30 @@
39052	39126	label = 18446744073709551582LLU; // reporttok
39053	39127	break;
39054	39128	}
39055		- case 3299LLU: // copy-back deleter (reporttok to listtoelem)
	39129	+ case 3308LLU: // copy-back deleter (reporttok to listtoelem)
39056	39130	{
39057	39131	// copy mutable arguments back from call to reporttok
39058		- label = 3291LLU; // continue to roll stack
	39132	+ label = 3300LLU; // continue to roll stack
39059	39133	break;
39060	39134	}
39061		- case 3300LLU: // return from reporttok to listtoelem
	39135	+ case 3309LLU: // return from reporttok to listtoelem
39062	39136	{
39063	39137	// copy mutable arguments back from call to reporttok
39064	39138	fprintf(stderr, "%s", "\n");
39065	39139	{
39066		- label = 3291LLU; // throw: begin to unroll stack
	39140	+ label = 3300LLU; // throw: begin to unroll stack
39067	39141	break;
39068	39142	}
39069	39143
39070		- label = 3298LLU; // alternative complete
	39144	+ label = 3307LLU; // alternative complete
39071	39145	break;
39072	39146	}
39073		- case 3298LLU: // completed if-then-else
	39147	+ case 3307LLU: // completed if-then-else
39074	39148	{
39075	39149	// call matchsym from listtoelem
39076		- stack[base + 9LLU] = 3301LLU/throw to this address/;
	39150	+ stack[base + 9LLU] = 3310LLU/throw to this address/;
39077	39151	stack[base + 10LLU] = base;
39078		- stack[base + 11LLU] = 3302LLU;
	39152	+ stack[base + 11LLU] = 3311LLU;
39079	39153	// arguments for call to matchsym
39080	39154	stack[base + 12LLU] = stack[base + 2]/fnid/;
39081	39155	stack[base + 13LLU] = 41LLU;

		@@ -39085,49 +39159,49 @@
39085	39159	label = 246LLU; // matchsym
39086	39160	break;
39087	39161	}
39088		- case 3301LLU: // copy-back deleter (matchsym to listtoelem)
	39162	+ case 3310LLU: // copy-back deleter (matchsym to listtoelem)
39089	39163	{
39090	39164	// copy mutable arguments back from call to matchsym
39091	39165	stack[base + 3]/lookahead/ = stack[base + 14LLU];
39092		- label = 3291LLU; // continue to roll stack
	39166	+ label = 3300LLU; // continue to roll stack
39093	39167	break;
39094	39168	}
39095		- case 3302LLU: // return from matchsym to listtoelem
	39169	+ case 3311LLU: // return from matchsym to listtoelem
39096	39170	{
39097	39171	// copy mutable arguments back from call to matchsym
39098	39172	stack[base + 3]/lookahead/ = stack[base + 14LLU];
39099		- label = 3304LLU; // skip deleter
	39173	+ label = 3313LLU; // skip deleter
39100	39174	break;
39101	39175	}
39102		- case 3303LLU: // deleter
	39176	+ case 3312LLU: // deleter
39103	39177	{
39104	39178	// throw from listtoelem
39105	39179	if(!stack[base + 0])
39106	39180	{
39107		- label = 3291LLU; // skip, variable already deleted/unscoped
	39181	+ label = 3300LLU; // skip, variable already deleted/unscoped
39108	39182	break;
39109	39183	}
39110		- label = 3291LLU; // continue unrolling stack, delete next variable
	39184	+ label = 3300LLU; // continue unrolling stack, delete next variable
39111	39185	break;
39112	39186	}
39113		- case 3304LLU: // skipped deleter
	39187	+ case 3313LLU: // skipped deleter
39114	39188	{
39115	39189	stack[base + 0] = stack[base + 6]/listid/;
39116		- label = 3306LLU; // skip deleter
	39190	+ label = 3315LLU; // skip deleter
39117	39191	break;
39118	39192	}
39119		- case 3305LLU: // deleter
	39193	+ case 3314LLU: // deleter
39120	39194	{
39121	39195	// throw from listtoelem
39122	39196	if(!stack[base + 1])
39123	39197	{
39124		- label = 3303LLU; // skip, variable already deleted/unscoped
	39198	+ label = 3312LLU; // skip, variable already deleted/unscoped
39125	39199	break;
39126	39200	}
39127		- label = 3303LLU; // continue unrolling stack, delete next variable
	39201	+ label = 3312LLU; // continue unrolling stack, delete next variable
39128	39202	break;
39129	39203	}
39130		- case 3306LLU: // skipped deleter
	39204	+ case 3315LLU: // skipped deleter
39131	39205	{
39132	39206	stack[base + 1] = stack[base + 8]/elemid/;
39133	39207	// return from listtoelem

		@@ -39135,7 +39209,7 @@
39135	39209	base = stack[base - 2];
39136	39210	break;
39137	39211	}
39138		- case 3307LLU: // ~popnext
	39212	+ case 3316LLU: // ~popnext
39139	39213	{
39140	39214	if(stack[base + 0]/variant-nr/ >= 2)
39141	39215	{

		@@ -39142,10 +39216,10 @@
39142	39216	fprintf(stderr, "in ~popnext: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
39143	39217	exit(-1);
39144	39218	}
39145		- label = 3307LLU + 1LLU + stack[base + 0]/variant-nr/;
	39219	+ label = 3316LLU + 1LLU + stack[base + 0]/variant-nr/;
39146	39220	break;
39147	39221	}
39148		- case 3307LLU + 1LLU + 0LLU: // ~popnext.pop
	39222	+ case 3316LLU + 1LLU + 0LLU: // ~popnext.pop
39149	39223	{
39150	39224	// release variant container
39151	39225	Free(0, sizeof(uint64_t), ((uint64_t )stack[base + 1]/variant*/));

		@@ -39153,7 +39227,7 @@
39153	39227	base = stack[base - 2];
39154	39228	break;
39155	39229	}
39156		- case 3307LLU + 1LLU + 1LLU: // ~popnext.next
	39230	+ case 3316LLU + 1LLU + 1LLU: // ~popnext.next
39157	39231	{
39158	39232	// release element previdx
39159	39233	// release variant container

		@@ -39162,7 +39236,7 @@
39162	39236	base = stack[base - 2];
39163	39237	break;
39164	39238	}
39165		- case 3310LLU: // ~listtoelem
	39239	+ case 3319LLU: // ~listtoelem
39166	39240	{
39167	39241	if(stack[base + 0]/variant-nr/ >= 1)
39168	39242	{

		@@ -39169,10 +39243,10 @@
39169	39243	fprintf(stderr, "in ~listtoelem: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
39170	39244	exit(-1);
39171	39245	}
39172		- label = 3310LLU + 1LLU + stack[base + 0]/variant-nr/;
	39246	+ label = 3319LLU + 1LLU + stack[base + 0]/variant-nr/;
39173	39247	break;
39174	39248	}
39175		- case 3310LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem
	39249	+ case 3319LLU + 1LLU + 0LLU: // ~listtoelem.listtoelem
39176	39250	{
39177	39251	// release element listindex
39178	39252	// release element popnext

		@@ -39183,14 +39257,14 @@
39183	39257	newstack[0] = (uint64_t)stack; // backup stack location
39184	39258	newstack[1] = 1234567890;
39185	39259	newstack[2] = base;
39186		- newstack[3] = 3312LLU;
	39260	+ newstack[3] = 3321LLU;
39187	39261	stack = newstack;
39188	39262	// set stack-base & callee-address
39189	39263	base = 4/deloffset/;
39190		- label = 3307LLU; // ~popnext
	39264	+ label = 3316LLU; // ~popnext
39191	39265	break;
39192	39266	}
39193		- case 3312LLU: // return from ~popnext to listtoelem
	39267	+ case 3321LLU: // return from ~popnext to listtoelem
39194	39268	{
39195	39269	stack = (uint64_t *)stack[0];
39196	39270	// releasing toplevel container

		@@ -39204,7 +39278,7 @@
39204	39278	newstack[0] = (uint64_t)stack; // backup stack location
39205	39279	newstack[1] = 1234567890;
39206	39280	newstack[2] = base;
39207		- newstack[3] = 3313LLU;
	39281	+ newstack[3] = 3322LLU;
39208	39282	stack = newstack;
39209	39283	// set stack-base & callee-address
39210	39284	base = 4/deloffset/;

		@@ -39211,7 +39285,7 @@
39211	39285	label = 310LLU; // ~type
39212	39286	break;
39213	39287	}
39214		- case 3313LLU: // return from ~type to listtoelem
	39288	+ case 3322LLU: // return from ~type to listtoelem
39215	39289	{
39216	39290	stack = (uint64_t *)stack[0];
39217	39291	// releasing toplevel container

		@@ -39224,13 +39298,13 @@
39224	39298	base = stack[base - 2];
39225	39299	break;
39226	39300	}
39227		- case 3315LLU: // function shadowlock failed
	39301	+ case 3324LLU: // function shadowlock failed
39228	39302	{
39229	39303	label = stack[base - 3];
39230	39304	base = stack[base - 2];
39231	39305	break;
39232	39306	}
39233		- case 3314LLU: // shadowlock
	39307	+ case 3323LLU: // shadowlock
39234	39308	{
39235	39309	//#define res0 0
39236	39310	//#define arg0 1

		@@ -39244,15 +39318,15 @@
39244	39318	//#define arg8 9
39245	39319	//#define arg9 10
39246	39320	//#define arg10 11
39247		- label = 3317LLU; // skip deleter
	39321	+ label = 3326LLU; // skip deleter
39248	39322	break;
39249	39323	}
39250		- case 3316LLU: // deleter
	39324	+ case 3325LLU: // deleter
39251	39325	{
39252	39326	// throw from shadowlock
39253	39327	if(!stack[base + 12])
39254	39328	{
39255		- label = 3315LLU; // skip, variable already deleted/unscoped
	39329	+ label = 3324LLU; // skip, variable already deleted/unscoped
39256	39330	break;
39257	39331	}
39258	39332

		@@ -39261,7 +39335,7 @@
39261	39335	newstack[0] = (uint64_t)stack; // backup stack location
39262	39336	newstack[1] = 1234567890;
39263	39337	newstack[2] = base;
39264		- newstack[3] = 3318LLU;
	39338	+ newstack[3] = 3327LLU;
39265	39339	stack = newstack;
39266	39340	// set stack-base & callee-address
39267	39341	base = 4/deloffset/;

		@@ -39268,21 +39342,21 @@
39268	39342	label = 486LLU; // ~letdef
39269	39343	break;
39270	39344	}
39271		- case 3318LLU: // return from ~letdef to shadowlock
	39345	+ case 3327LLU: // return from ~letdef to shadowlock
39272	39346	{
39273	39347	stack = (uint64_t *)stack[0];
39274	39348	// releasing toplevel container
39275	39349	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 12] - sizeof(uint64_t) 4));
39276	39350
39277		- label = 3315LLU; // continue unrolling stack, delete next variable
	39351	+ label = 3324LLU; // continue unrolling stack, delete next variable
39278	39352	break;
39279	39353	}
39280		- case 3317LLU: // skipped deleter
	39354	+ case 3326LLU: // skipped deleter
39281	39355	{
39282	39356	// call FindLet from shadowlock
39283		- stack[base + 13LLU] = 3319LLU/throw to this address/;
	39357	+ stack[base + 13LLU] = 3328LLU/throw to this address/;
39284	39358	stack[base + 14LLU] = base;
39285		- stack[base + 15LLU] = 3320LLU;
	39359	+ stack[base + 15LLU] = 3329LLU;
39286	39360	// arguments for call to FindLet
39287	39361	stack[base + 17LLU] = stack[base + 1]/fnid/;
39288	39362	stack[base + 18LLU] = stack[base + 9]/listid/;

		@@ -39293,13 +39367,13 @@
39293	39367	label = 619LLU; // FindLet
39294	39368	break;
39295	39369	}
39296		- case 3319LLU: // copy-back deleter (FindLet to shadowlock)
	39370	+ case 3328LLU: // copy-back deleter (FindLet to shadowlock)
39297	39371	{
39298	39372	// copy mutable arguments back from call to FindLet
39299		- label = 3315LLU; // continue to roll stack
	39373	+ label = 3324LLU; // continue to roll stack
39300	39374	break;
39301	39375	}
39302		- case 3320LLU: // return from FindLet to shadowlock
	39376	+ case 3329LLU: // return from FindLet to shadowlock
39303	39377	{
39304	39378	// copy mutable arguments back from call to FindLet
39305	39379	// copy back results provided by call to FindLet

		@@ -39306,7 +39380,7 @@
39306	39380	stack[base + 12] = stack[base + 16LLU];
39307	39381	if(/letdef/0 != ((uint64_t )(stack[base + 12]/letdef*/))[0])
39308	39382	{
39309		- label = 3322LLU; // jump to alternative
	39383	+ label = 3331LLU; // jump to alternative
39310	39384	break;
39311	39385	}
39312	39386

		@@ -39317,15 +39391,15 @@
39317	39391	/substruct/stack[base + 17] = ((uint64_t *)(stack[base + 12]/letdef/))[1][4]/substruct*/;
39318	39392
39319	39393	// case
39320		- label = 3325LLU; // skip deleter
	39394	+ label = 3334LLU; // skip deleter
39321	39395	break;
39322	39396	}
39323		- case 3324LLU: // deleter
	39397	+ case 3333LLU: // deleter
39324	39398	{
39325	39399	// throw from shadowlock
39326	39400	if(!stack[base + 18])
39327	39401	{
39328		- label = 3323LLU; // skip, variable already deleted/unscoped
	39402	+ label = 3332LLU; // skip, variable already deleted/unscoped
39329	39403	break;
39330	39404	}
39331	39405

		@@ -39334,7 +39408,7 @@
39334	39408	newstack[0] = (uint64_t)stack; // backup stack location
39335	39409	newstack[1] = 1234567890;
39336	39410	newstack[2] = base;
39337		- newstack[3] = 3326LLU;
	39411	+ newstack[3] = 3335LLU;
39338	39412	stack = newstack;
39339	39413	// set stack-base & callee-address
39340	39414	base = 4/deloffset/;

		@@ -39341,20 +39415,20 @@
39341	39415	label = 310LLU; // ~type
39342	39416	break;
39343	39417	}
39344		- case 3326LLU: // return from ~type to shadowlock
	39418	+ case 3335LLU: // return from ~type to shadowlock
39345	39419	{
39346	39420	stack = (uint64_t *)stack[0];
39347	39421	// releasing toplevel container
39348	39422	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 18] - sizeof(uint64_t) 4));
39349	39423
39350		- label = 3323LLU; // continue unrolling stack, delete next variable
	39424	+ label = 3332LLU; // continue unrolling stack, delete next variable
39351	39425	break;
39352	39426	}
39353		- case 3325LLU: // skipped deleter
	39427	+ case 3334LLU: // skipped deleter
39354	39428	{
39355	39429	if(/typelist/1 != ((uint64_t )(stack[base + 13]/listtype*/))[0])
39356	39430	{
39357		- label = 3328LLU; // jump to alternative
	39431	+ label = 3337LLU; // jump to alternative
39358	39432	break;
39359	39433	}
39360	39434

		@@ -39364,7 +39438,7 @@
39364	39438	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
39365	39439	if(!newstack)
39366	39440	{
39367		- label = 3329LLU; // throw: begin to unroll stack
	39441	+ label = 3338LLU; // throw: begin to unroll stack
39368	39442	break;
39369	39443	}
39370	39444

		@@ -39371,9 +39445,9 @@
39371	39445	newstack[15LLU] = 9876543210LLU; // overflow-marker
39372	39446	// call copytype from shadowlock
39373	39447	newstack[0] = (uint64_t)stack; // backup stack location
39374		- newstack[1] = 3330LLU;
	39448	+ newstack[1] = 3339LLU;
39375	39449	newstack[2] = base;
39376		- newstack[3] = 3331LLU;
	39450	+ newstack[3] = 3340LLU;
39377	39451	// arguments for call to copytype
39378	39452	newstack[5LLU] = stack[base + 19]/elemtype/;
39379	39453	stack = newstack;

		@@ -39382,7 +39456,7 @@
39382	39456	label = 341LLU; // copytype
39383	39457	break;
39384	39458	}
39385		- case 3330LLU: // copy-back deleter (copytype to shadowlock)
	39459	+ case 3339LLU: // copy-back deleter (copytype to shadowlock)
39386	39460	{
39387	39461	uint64_t oldstack = (uint64_t )stack[0];
39388	39462	// copy mutable arguments back from call to copytype

		@@ -39393,10 +39467,10 @@
39393	39467	}
39394	39468	Free(15LLU + 1, sizeof(uint64_t), stack);
39395	39469	stack = oldstack;
39396		- label = 3329LLU; // continue to unroll stack
	39470	+ label = 3338LLU; // continue to unroll stack
39397	39471	break;
39398	39472	}
39399		- case 3331LLU: // return from copytype to shadowlock
	39473	+ case 3340LLU: // return from copytype to shadowlock
39400	39474	{
39401	39475	uint64_t oldstack = (uint64_t )stack[0];
39402	39476	// copy mutable arguments back from call to copytype

		@@ -39410,23 +39484,23 @@
39410	39484	Free(15LLU + 1, sizeof(uint64_t), stack);
39411	39485	stack = oldstack;
39412	39486	((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19];
39413		- label = 3327LLU; // case complete
	39487	+ label = 3336LLU; // case complete
39414	39488	break;
39415	39489	}
39416		- case 3329LLU: // copy-back deleter (switch)
	39490	+ case 3338LLU: // copy-back deleter (switch)
39417	39491	{
39418	39492	((uint64_t **)(stack[base + 13]))[1][0] = stack[base + 19];
39419		- label = 3323LLU; // continue to unroll stack
	39493	+ label = 3332LLU; // continue to unroll stack
39420	39494	break;
39421	39495	}
39422		- case 3328LLU: // try next case
	39496	+ case 3337LLU: // try next case
39423	39497	{
39424	39498	// default
39425	39499	fprintf(stderr, "%s", "in function ");
39426	39500	// call reportid from shadowlock
39427		- stack[base + 19LLU] = 3332LLU/throw to this address/;
	39501	+ stack[base + 19LLU] = 3341LLU/throw to this address/;
39428	39502	stack[base + 20LLU] = base;
39429		- stack[base + 21LLU] = 3333LLU;
	39503	+ stack[base + 21LLU] = 3342LLU;
39430	39504	// arguments for call to reportid
39431	39505	stack[base + 22LLU] = stack[base + 1]/fnid/;
39432	39506	// set stack-base & callee-address

		@@ -39434,13 +39508,13 @@
39434	39508	label = 18446744073709551586LLU; // reportid
39435	39509	break;
39436	39510	}
39437		- case 3332LLU: // copy-back deleter (reportid to shadowlock)
	39511	+ case 3341LLU: // copy-back deleter (reportid to shadowlock)
39438	39512	{
39439	39513	// copy mutable arguments back from call to reportid
39440		- label = 3323LLU; // continue to roll stack
	39514	+ label = 3332LLU; // continue to roll stack
39441	39515	break;
39442	39516	}
39443		- case 3333LLU: // return from reportid to shadowlock
	39517	+ case 3342LLU: // return from reportid to shadowlock
39444	39518	{
39445	39519	// copy mutable arguments back from call to reportid
39446	39520	fprintf(stderr, "%s", ": ");

		@@ -39448,7 +39522,7 @@
39448	39522	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
39449	39523	if(!newstack)
39450	39524	{
39451		- label = 3323LLU; // throw: begin to unroll stack
	39525	+ label = 3332LLU; // throw: begin to unroll stack
39452	39526	break;
39453	39527	}
39454	39528

		@@ -39455,9 +39529,9 @@
39455	39529	newstack[10LLU] = 9876543210LLU; // overflow-marker
39456	39530	// call reporttype from shadowlock
39457	39531	newstack[0] = (uint64_t)stack; // backup stack location
39458		- newstack[1] = 3334LLU;
	39532	+ newstack[1] = 3343LLU;
39459	39533	newstack[2] = base;
39460		- newstack[3] = 3335LLU;
	39534	+ newstack[3] = 3344LLU;
39461	39535	// arguments for call to reporttype
39462	39536	newstack[4LLU] = stack[base + 13]/listtype/;
39463	39537	stack = newstack;

		@@ -39466,7 +39540,7 @@
39466	39540	label = 330LLU; // reporttype
39467	39541	break;
39468	39542	}
39469		- case 3334LLU: // copy-back deleter (reporttype to shadowlock)
	39543	+ case 3343LLU: // copy-back deleter (reporttype to shadowlock)
39470	39544	{
39471	39545	uint64_t oldstack = (uint64_t )stack[0];
39472	39546	// copy mutable arguments back from call to reporttype

		@@ -39477,10 +39551,10 @@
39477	39551	}
39478	39552	Free(10LLU + 1, sizeof(uint64_t), stack);
39479	39553	stack = oldstack;
39480		- label = 3323LLU; // continue to unroll stack
	39554	+ label = 3332LLU; // continue to unroll stack
39481	39555	break;
39482	39556	}
39483		- case 3335LLU: // return from reporttype to shadowlock
	39557	+ case 3344LLU: // return from reporttype to shadowlock
39484	39558	{
39485	39559	uint64_t oldstack = (uint64_t )stack[0];
39486	39560	// copy mutable arguments back from call to reporttype

		@@ -39493,80 +39567,80 @@
39493	39567	stack = oldstack;
39494	39568	fprintf(stderr, "%s", "\n");
39495	39569	{
39496		- label = 3323LLU; // throw: begin to unroll stack
	39570	+ label = 3332LLU; // throw: begin to unroll stack
39497	39571	break;
39498	39572	}
39499	39573
39500		- label = 3327LLU; // default complete
	39574	+ label = 3336LLU; // default complete
39501	39575	break;
39502	39576	}
39503		- case 3327LLU: // completed switch
	39577	+ case 3336LLU: // completed switch
39504	39578	{
39505		- label = 3337LLU; // skip deleter
	39579	+ label = 3346LLU; // skip deleter
39506	39580	break;
39507	39581	}
39508		- case 3336LLU: // deleter
	39582	+ case 3345LLU: // deleter
39509	39583	{
39510	39584	// throw from shadowlock
39511	39585	if(!stack[base + 19])
39512	39586	{
39513		- label = 3324LLU; // skip, variable already deleted/unscoped
	39587	+ label = 3333LLU; // skip, variable already deleted/unscoped
39514	39588	break;
39515	39589	}
39516		- label = 3324LLU; // continue unrolling stack, delete next variable
	39590	+ label = 3333LLU; // continue unrolling stack, delete next variable
39517	39591	break;
39518	39592	}
39519		- case 3337LLU: // skipped deleter
	39593	+ case 3346LLU: // skipped deleter
39520	39594	{
39521	39595	if(!stack[base + 16]/mutable/)
39522	39596	{
39523		- label = 3338LLU; // jump to alternative
	39597	+ label = 3347LLU; // jump to alternative
39524	39598	break;
39525	39599	}
39526	39600
39527	39601	// consequent
39528		- label = 3341LLU; // skip deleter
	39602	+ label = 3350LLU; // skip deleter
39529	39603	break;
39530	39604	}
39531		- case 3340LLU: // deleter
	39605	+ case 3349LLU: // deleter
39532	39606	{
39533	39607	// throw from shadowlock
39534	39608	if(!stack[base + 19])
39535	39609	{
39536		- label = 3324LLU; // skip, variable already deleted/unscoped
	39610	+ label = 3333LLU; // skip, variable already deleted/unscoped
39537	39611	break;
39538	39612	}
39539		- label = 3324LLU; // continue unrolling stack, delete next variable
	39613	+ label = 3333LLU; // continue unrolling stack, delete next variable
39540	39614	break;
39541	39615	}
39542		- case 3341LLU: // skipped deleter
	39616	+ case 3350LLU: // skipped deleter
39543	39617	{
39544	39618	stack[base + 19] = 0;
39545		- label = 3339LLU; // consequent complete
	39619	+ label = 3348LLU; // consequent complete
39546	39620	break;
39547	39621	}
39548		- case 3338LLU: // alternative
	39622	+ case 3347LLU: // alternative
39549	39623	{
39550		- label = 3343LLU; // skip deleter
	39624	+ label = 3352LLU; // skip deleter
39551	39625	break;
39552	39626	}
39553		- case 3342LLU: // deleter
	39627	+ case 3351LLU: // deleter
39554	39628	{
39555	39629	// throw from shadowlock
39556	39630	if(!stack[base + 20])
39557	39631	{
39558		- label = 3324LLU; // skip, variable already deleted/unscoped
	39632	+ label = 3333LLU; // skip, variable already deleted/unscoped
39559	39633	break;
39560	39634	}
39561		- label = 3324LLU; // continue unrolling stack, delete next variable
	39635	+ label = 3333LLU; // continue unrolling stack, delete next variable
39562	39636	break;
39563	39637	}
39564		- case 3343LLU: // skipped deleter
	39638	+ case 3352LLU: // skipped deleter
39565	39639	{
39566	39640	// call isparam from shadowlock
39567		- stack[base + 21LLU] = 3344LLU/throw to this address/;
	39641	+ stack[base + 21LLU] = 3353LLU/throw to this address/;
39568	39642	stack[base + 22LLU] = base;
39569		- stack[base + 23LLU] = 3345LLU;
	39643	+ stack[base + 23LLU] = 3354LLU;
39570	39644	// arguments for call to isparam
39571	39645	stack[base + 25LLU] = stack[base + 4]/fnrescount/;
39572	39646	stack[base + 26LLU] = stack[base + 5]/fnargcount/;

		@@ -39576,21 +39650,21 @@
39576	39650	label = 1635LLU; // isparam
39577	39651	break;
39578	39652	}
39579		- case 3344LLU: // copy-back deleter (isparam to shadowlock)
	39653	+ case 3353LLU: // copy-back deleter (isparam to shadowlock)
39580	39654	{
39581	39655	// copy mutable arguments back from call to isparam
39582		- label = 3324LLU; // continue to roll stack
	39656	+ label = 3333LLU; // continue to roll stack
39583	39657	break;
39584	39658	}
39585		- case 3345LLU: // return from isparam to shadowlock
	39659	+ case 3354LLU: // return from isparam to shadowlock
39586	39660	{
39587	39661	// copy mutable arguments back from call to isparam
39588	39662	// copy back results provided by call to isparam
39589	39663	stack[base + 20] = stack[base + 24LLU];
39590	39664	// call or from shadowlock
39591		- stack[base + 21LLU] = 3346LLU/throw to this address/;
	39665	+ stack[base + 21LLU] = 3355LLU/throw to this address/;
39592	39666	stack[base + 22LLU] = base;
39593		- stack[base + 23LLU] = 3347LLU;
	39667	+ stack[base + 23LLU] = 3356LLU;
39594	39668	// arguments for call to or
39595	39669	stack[base + 25LLU] = stack[base + 17]/substruct/;
39596	39670	stack[base + 26LLU] = stack[base + 20]/param/;

		@@ -39599,41 +39673,41 @@
39599	39673	label = 18446744073709551611LLU; // or
39600	39674	break;
39601	39675	}
39602		- case 3346LLU: // copy-back deleter (or to shadowlock)
	39676	+ case 3355LLU: // copy-back deleter (or to shadowlock)
39603	39677	{
39604	39678	// copy mutable arguments back from call to or
39605		- label = 3342LLU; // continue to roll stack
	39679	+ label = 3351LLU; // continue to roll stack
39606	39680	break;
39607	39681	}
39608		- case 3347LLU: // return from or to shadowlock
	39682	+ case 3356LLU: // return from or to shadowlock
39609	39683	{
39610	39684	// copy mutable arguments back from call to or
39611	39685	// copy back results provided by call to or
39612	39686	stack[base + 19] = stack[base + 24LLU];
39613		- label = 3339LLU; // alternative complete
	39687	+ label = 3348LLU; // alternative complete
39614	39688	break;
39615	39689	}
39616		- case 3339LLU: // completed if-then-else
	39690	+ case 3348LLU: // completed if-then-else
39617	39691	{
39618		- label = 3349LLU; // skip deleter
	39692	+ label = 3358LLU; // skip deleter
39619	39693	break;
39620	39694	}
39621		- case 3348LLU: // deleter
	39695	+ case 3357LLU: // deleter
39622	39696	{
39623	39697	// throw from shadowlock
39624	39698	if(!stack[base + 20])
39625	39699	{
39626		- label = 3336LLU; // skip, variable already deleted/unscoped
	39700	+ label = 3345LLU; // skip, variable already deleted/unscoped
39627	39701	break;
39628	39702	}
39629		- label = 3336LLU; // continue unrolling stack, delete next variable
	39703	+ label = 3345LLU; // continue unrolling stack, delete next variable
39630	39704	break;
39631	39705	}
39632		- case 3349LLU: // skipped deleter
	39706	+ case 3358LLU: // skipped deleter
39633	39707	{
39634	39708	if(!stack[base + 11]/consume/)
39635	39709	{
39636		- label = 3350LLU; // jump to alternative
	39710	+ label = 3359LLU; // jump to alternative
39637	39711	break;
39638	39712	}
39639	39713

		@@ -39640,21 +39714,21 @@
39640	39714	// consequent
39641	39715	if(!stack[base + 16]/mutable/)
39642	39716	{
39643		- label = 3352LLU; // jump to alternative
	39717	+ label = 3361LLU; // jump to alternative
39644	39718	break;
39645	39719	}
39646	39720
39647	39721	// consequent
39648		- label = 3353LLU; // consequent complete
	39722	+ label = 3362LLU; // consequent complete
39649	39723	break;
39650	39724	}
39651		- case 3352LLU: // alternative
	39725	+ case 3361LLU: // alternative
39652	39726	{
39653	39727	fprintf(stderr, "%s", "in function ");
39654	39728	// call reportid from shadowlock
39655		- stack[base + 21LLU] = 3354LLU/throw to this address/;
	39729	+ stack[base + 21LLU] = 3363LLU/throw to this address/;
39656	39730	stack[base + 22LLU] = base;
39657		- stack[base + 23LLU] = 3355LLU;
	39731	+ stack[base + 23LLU] = 3364LLU;
39658	39732	// arguments for call to reportid
39659	39733	stack[base + 24LLU] = stack[base + 1]/fnid/;
39660	39734	// set stack-base & callee-address

		@@ -39662,13 +39736,13 @@
39662	39736	label = 18446744073709551586LLU; // reportid
39663	39737	break;
39664	39738	}
39665		- case 3354LLU: // copy-back deleter (reportid to shadowlock)
	39739	+ case 3363LLU: // copy-back deleter (reportid to shadowlock)
39666	39740	{
39667	39741	// copy mutable arguments back from call to reportid
39668		- label = 3336LLU; // continue to roll stack
	39742	+ label = 3345LLU; // continue to roll stack
39669	39743	break;
39670	39744	}
39671		- case 3355LLU: // return from reportid to shadowlock
	39745	+ case 3364LLU: // return from reportid to shadowlock
39672	39746	{
39673	39747	// copy mutable arguments back from call to reportid
39674	39748	fprintf(stderr, "%s", ": ");

		@@ -39676,7 +39750,7 @@
39676	39750	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
39677	39751	if(!newstack)
39678	39752	{
39679		- label = 3336LLU; // throw: begin to unroll stack
	39753	+ label = 3345LLU; // throw: begin to unroll stack
39680	39754	break;
39681	39755	}
39682	39756

		@@ -39683,9 +39757,9 @@
39683	39757	newstack[10LLU] = 9876543210LLU; // overflow-marker
39684	39758	// call reporttype from shadowlock
39685	39759	newstack[0] = (uint64_t)stack; // backup stack location
39686		- newstack[1] = 3356LLU;
	39760	+ newstack[1] = 3365LLU;
39687	39761	newstack[2] = base;
39688		- newstack[3] = 3357LLU;
	39762	+ newstack[3] = 3366LLU;
39689	39763	// arguments for call to reporttype
39690	39764	newstack[4LLU] = stack[base + 13]/listtype/;
39691	39765	stack = newstack;

		@@ -39694,7 +39768,7 @@
39694	39768	label = 330LLU; // reporttype
39695	39769	break;
39696	39770	}
39697		- case 3356LLU: // copy-back deleter (reporttype to shadowlock)
	39771	+ case 3365LLU: // copy-back deleter (reporttype to shadowlock)
39698	39772	{
39699	39773	uint64_t oldstack = (uint64_t )stack[0];
39700	39774	// copy mutable arguments back from call to reporttype

		@@ -39705,10 +39779,10 @@
39705	39779	}
39706	39780	Free(10LLU + 1, sizeof(uint64_t), stack);
39707	39781	stack = oldstack;
39708		- label = 3336LLU; // continue to unroll stack
	39782	+ label = 3345LLU; // continue to unroll stack
39709	39783	break;
39710	39784	}
39711		- case 3357LLU: // return from reporttype to shadowlock
	39785	+ case 3366LLU: // return from reporttype to shadowlock
39712	39786	{
39713	39787	uint64_t oldstack = (uint64_t )stack[0];
39714	39788	// copy mutable arguments back from call to reporttype

		@@ -39721,18 +39795,18 @@
39721	39795	stack = oldstack;
39722	39796	fprintf(stderr, "%s", "\n");
39723	39797	{
39724		- label = 3336LLU; // throw: begin to unroll stack
	39798	+ label = 3345LLU; // throw: begin to unroll stack
39725	39799	break;
39726	39800	}
39727	39801
39728		- label = 3353LLU; // alternative complete
	39802	+ label = 3362LLU; // alternative complete
39729	39803	break;
39730	39804	}
39731		- case 3353LLU: // completed if-then-else
	39805	+ case 3362LLU: // completed if-then-else
39732	39806	{
39733	39807	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
39734	39808	{
39735		- label = 3359LLU; // jump to alternative
	39809	+ label = 3368LLU; // jump to alternative
39736	39810	break;
39737	39811	}
39738	39812

		@@ -39740,15 +39814,15 @@
39740	39814	/letdefs/stack[base + 22] = ((uint64_t *)(stack[base + 3]/scope/))[1][1]/letdefs*/;
39741	39815
39742	39816	// case
39743		- label = 3362LLU; // skip deleter
	39817	+ label = 3371LLU; // skip deleter
39744	39818	break;
39745	39819	}
39746		- case 3361LLU: // deleter
	39820	+ case 3370LLU: // deleter
39747	39821	{
39748	39822	// throw from shadowlock
39749	39823	if(!stack[base + 23])
39750	39824	{
39751		- label = 3360LLU; // skip, variable already deleted/unscoped
	39825	+ label = 3369LLU; // skip, variable already deleted/unscoped
39752	39826	break;
39753	39827	}
39754	39828

		@@ -39757,7 +39831,7 @@
39757	39831	newstack[0] = (uint64_t)stack; // backup stack location
39758	39832	newstack[1] = 1234567890;
39759	39833	newstack[2] = base;
39760		- newstack[3] = 3363LLU;
	39834	+ newstack[3] = 3372LLU;
39761	39835	stack = newstack;
39762	39836	// set stack-base & callee-address
39763	39837	base = 4/deloffset/;

		@@ -39764,21 +39838,21 @@
39764	39838	label = 310LLU; // ~type
39765	39839	break;
39766	39840	}
39767		- case 3363LLU: // return from ~type to shadowlock
	39841	+ case 3372LLU: // return from ~type to shadowlock
39768	39842	{
39769	39843	stack = (uint64_t *)stack[0];
39770	39844	// releasing toplevel container
39771	39845	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
39772	39846
39773		- label = 3360LLU; // continue unrolling stack, delete next variable
	39847	+ label = 3369LLU; // continue unrolling stack, delete next variable
39774	39848	break;
39775	39849	}
39776		- case 3362LLU: // skipped deleter
	39850	+ case 3371LLU: // skipped deleter
39777	39851	{
39778	39852	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
39779	39853	if(!newstack)
39780	39854	{
39781		- label = 3360LLU; // throw: begin to unroll stack
	39855	+ label = 3369LLU; // throw: begin to unroll stack
39782	39856	break;
39783	39857	}
39784	39858

		@@ -39785,9 +39859,9 @@
39785	39859	newstack[15LLU] = 9876543210LLU; // overflow-marker
39786	39860	// call copytype from shadowlock
39787	39861	newstack[0] = (uint64_t)stack; // backup stack location
39788		- newstack[1] = 3364LLU;
	39862	+ newstack[1] = 3373LLU;
39789	39863	newstack[2] = base;
39790		- newstack[3] = 3365LLU;
	39864	+ newstack[3] = 3374LLU;
39791	39865	// arguments for call to copytype
39792	39866	newstack[5LLU] = stack[base + 13]/listtype/;
39793	39867	stack = newstack;

		@@ -39796,7 +39870,7 @@
39796	39870	label = 341LLU; // copytype
39797	39871	break;
39798	39872	}
39799		- case 3364LLU: // copy-back deleter (copytype to shadowlock)
	39873	+ case 3373LLU: // copy-back deleter (copytype to shadowlock)
39800	39874	{
39801	39875	uint64_t oldstack = (uint64_t )stack[0];
39802	39876	// copy mutable arguments back from call to copytype

		@@ -39807,10 +39881,10 @@
39807	39881	}
39808	39882	Free(15LLU + 1, sizeof(uint64_t), stack);
39809	39883	stack = oldstack;
39810		- label = 3360LLU; // continue to unroll stack
	39884	+ label = 3369LLU; // continue to unroll stack
39811	39885	break;
39812	39886	}
39813		- case 3365LLU: // return from copytype to shadowlock
	39887	+ case 3374LLU: // return from copytype to shadowlock
39814	39888	{
39815	39889	uint64_t oldstack = (uint64_t )stack[0];
39816	39890	// copy mutable arguments back from call to copytype

		@@ -39823,49 +39897,49 @@
39823	39897	}
39824	39898	Free(15LLU + 1, sizeof(uint64_t), stack);
39825	39899	stack = oldstack;
39826		- label = 3367LLU; // skip deleter
	39900	+ label = 3376LLU; // skip deleter
39827	39901	break;
39828	39902	}
39829		- case 3366LLU: // deleter
	39903	+ case 3375LLU: // deleter
39830	39904	{
39831	39905	// throw from shadowlock
39832	39906	if(!stack[base + 24])
39833	39907	{
39834		- label = 3361LLU; // skip, variable already deleted/unscoped
	39908	+ label = 3370LLU; // skip, variable already deleted/unscoped
39835	39909	break;
39836	39910	}
39837		- label = 3361LLU; // continue unrolling stack, delete next variable
	39911	+ label = 3370LLU; // continue unrolling stack, delete next variable
39838	39912	break;
39839	39913	}
39840		- case 3367LLU: // skipped deleter
	39914	+ case 3376LLU: // skipped deleter
39841	39915	{
39842	39916	stack[base + 24] = 0;
39843		- label = 3369LLU; // skip deleter
	39917	+ label = 3378LLU; // skip deleter
39844	39918	break;
39845	39919	}
39846		- case 3368LLU: // deleter
	39920	+ case 3377LLU: // deleter
39847	39921	{
39848	39922	// throw from shadowlock
39849	39923	if(!stack[base + 25])
39850	39924	{
39851		- label = 3366LLU; // skip, variable already deleted/unscoped
	39925	+ label = 3375LLU; // skip, variable already deleted/unscoped
39852	39926	break;
39853	39927	}
39854		- label = 3366LLU; // continue unrolling stack, delete next variable
	39928	+ label = 3375LLU; // continue unrolling stack, delete next variable
39855	39929	break;
39856	39930	}
39857		- case 3369LLU: // skipped deleter
	39931	+ case 3378LLU: // skipped deleter
39858	39932	{
39859	39933	stack[base + 25] = 0;
39860		- label = 3371LLU; // skip deleter
	39934	+ label = 3380LLU; // skip deleter
39861	39935	break;
39862	39936	}
39863		- case 3370LLU: // deleter
	39937	+ case 3379LLU: // deleter
39864	39938	{
39865	39939	// throw from shadowlock
39866	39940	if(!stack[base + 26])
39867	39941	{
39868		- label = 3368LLU; // skip, variable already deleted/unscoped
	39942	+ label = 3377LLU; // skip, variable already deleted/unscoped
39869	39943	break;
39870	39944	}
39871	39945

		@@ -39874,7 +39948,7 @@
39874	39948	newstack[0] = (uint64_t)stack; // backup stack location
39875	39949	newstack[1] = 1234567890;
39876	39950	newstack[2] = base;
39877		- newstack[3] = 3372LLU;
	39951	+ newstack[3] = 3381LLU;
39878	39952	stack = newstack;
39879	39953	// set stack-base & callee-address
39880	39954	base = 4/deloffset/;

		@@ -39881,21 +39955,21 @@
39881	39955	label = 486LLU; // ~letdef
39882	39956	break;
39883	39957	}
39884		- case 3372LLU: // return from ~letdef to shadowlock
	39958	+ case 3381LLU: // return from ~letdef to shadowlock
39885	39959	{
39886	39960	stack = (uint64_t *)stack[0];
39887	39961	// releasing toplevel container
39888	39962	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 26] - sizeof(uint64_t) 4));
39889	39963
39890		- label = 3368LLU; // continue unrolling stack, delete next variable
	39964	+ label = 3377LLU; // continue unrolling stack, delete next variable
39891	39965	break;
39892	39966	}
39893		- case 3371LLU: // skipped deleter
	39967	+ case 3380LLU: // skipped deleter
39894	39968	{
39895	39969	// construct letdef.letdef
39896	39970	if(!(stack[base + 26] = construct(5)))
39897	39971	{
39898		- label = 3368LLU; // throw: begin to unroll stack
	39972	+ label = 3377LLU; // throw: begin to unroll stack
39899	39973	break;
39900	39974	}
39901	39975

		@@ -39921,50 +39995,50 @@
39921	39995	}
39922	39996	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22];
39923	39997	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21];
39924		- label = 3358LLU; // case complete
	39998	+ label = 3367LLU; // case complete
39925	39999	break;
39926	40000	}
39927		- case 3360LLU: // copy-back deleter (switch)
	40001	+ case 3369LLU: // copy-back deleter (switch)
39928	40002	{
39929	40003	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 22];
39930	40004	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 21];
39931		- label = 3336LLU; // continue to unroll stack
	40005	+ label = 3345LLU; // continue to unroll stack
39932	40006	break;
39933	40007	}
39934		- case 3359LLU: // try next case
	40008	+ case 3368LLU: // try next case
39935	40009	{
39936	40010	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
39937	40011	exit(-1);
39938	40012	}
39939		- case 3358LLU: // completed switch
	40013	+ case 3367LLU: // completed switch
39940	40014	{
39941		- label = 3374LLU; // skip deleter
	40015	+ label = 3383LLU; // skip deleter
39942	40016	break;
39943	40017	}
39944		- case 3373LLU: // deleter
	40018	+ case 3382LLU: // deleter
39945	40019	{
39946	40020	// throw from shadowlock
39947	40021	if(!stack[base + 20])
39948	40022	{
39949		- label = 3336LLU; // skip, variable already deleted/unscoped
	40023	+ label = 3345LLU; // skip, variable already deleted/unscoped
39950	40024	break;
39951	40025	}
39952		- label = 3336LLU; // continue unrolling stack, delete next variable
	40026	+ label = 3345LLU; // continue unrolling stack, delete next variable
39953	40027	break;
39954	40028	}
39955		- case 3374LLU: // skipped deleter
	40029	+ case 3383LLU: // skipped deleter
39956	40030	{
39957	40031	stack[base + 20] = stack[base + 15]/listindex/;
39958		- label = 3351LLU; // consequent complete
	40032	+ label = 3360LLU; // consequent complete
39959	40033	break;
39960	40034	}
39961		- case 3350LLU: // alternative
	40035	+ case 3359LLU: // alternative
39962	40036	{
39963	40037	printf("%s", "\n flippedassign(");
39964	40038	// call emitvar from shadowlock
39965		- stack[base + 21LLU] = 3375LLU/throw to this address/;
	40039	+ stack[base + 21LLU] = 3384LLU/throw to this address/;
39966	40040	stack[base + 22LLU] = base;
39967		- stack[base + 23LLU] = 3376LLU;
	40041	+ stack[base + 23LLU] = 3385LLU;
39968	40042	// arguments for call to emitvar
39969	40043	stack[base + 24LLU] = stack[base + 1]/fnid/;
39970	40044	stack[base + 25LLU] = stack[base + 14]/listid/;

		@@ -39975,53 +40049,53 @@
39975	40049	label = 749LLU; // emitvar
39976	40050	break;
39977	40051	}
39978		- case 3375LLU: // copy-back deleter (emitvar to shadowlock)
	40052	+ case 3384LLU: // copy-back deleter (emitvar to shadowlock)
39979	40053	{
39980	40054	// copy mutable arguments back from call to emitvar
39981		- label = 3336LLU; // continue to roll stack
	40055	+ label = 3345LLU; // continue to roll stack
39982	40056	break;
39983	40057	}
39984		- case 3376LLU: // return from emitvar to shadowlock
	40058	+ case 3385LLU: // return from emitvar to shadowlock
39985	40059	{
39986	40060	// copy mutable arguments back from call to emitvar
39987	40061	printf("%s", ", &");
39988		- label = 3378LLU; // skip deleter
	40062	+ label = 3387LLU; // skip deleter
39989	40063	break;
39990	40064	}
39991		- case 3377LLU: // deleter
	40065	+ case 3386LLU: // deleter
39992	40066	{
39993	40067	// throw from shadowlock
39994	40068	if(!stack[base + 21])
39995	40069	{
39996		- label = 3336LLU; // skip, variable already deleted/unscoped
	40070	+ label = 3345LLU; // skip, variable already deleted/unscoped
39997	40071	break;
39998	40072	}
39999		- label = 3336LLU; // continue unrolling stack, delete next variable
	40073	+ label = 3345LLU; // continue unrolling stack, delete next variable
40000	40074	break;
40001	40075	}
40002		- case 3378LLU: // skipped deleter
	40076	+ case 3387LLU: // skipped deleter
40003	40077	{
40004	40078	stack[base + 21] = 0;
40005		- label = 3380LLU; // skip deleter
	40079	+ label = 3389LLU; // skip deleter
40006	40080	break;
40007	40081	}
40008		- case 3379LLU: // deleter
	40082	+ case 3388LLU: // deleter
40009	40083	{
40010	40084	// throw from shadowlock
40011	40085	if(!stack[base + 22])
40012	40086	{
40013		- label = 3377LLU; // skip, variable already deleted/unscoped
	40087	+ label = 3386LLU; // skip, variable already deleted/unscoped
40014	40088	break;
40015	40089	}
40016		- label = 3377LLU; // continue unrolling stack, delete next variable
	40090	+ label = 3386LLU; // continue unrolling stack, delete next variable
40017	40091	break;
40018	40092	}
40019		- case 3380LLU: // skipped deleter
	40093	+ case 3389LLU: // skipped deleter
40020	40094	{
40021	40095	// call newvarraw from shadowlock
40022		- stack[base + 23LLU] = 3381LLU/throw to this address/;
	40096	+ stack[base + 23LLU] = 3390LLU/throw to this address/;
40023	40097	stack[base + 24LLU] = base;
40024		- stack[base + 25LLU] = 3382LLU;
	40098	+ stack[base + 25LLU] = 3391LLU;
40025	40099	// arguments for call to newvarraw
40026	40100	stack[base + 27LLU] = stack[base + 13]/listtype/;
40027	40101	stack[base + 28LLU] = stack[base + 14]/listid/;

		@@ -40037,16 +40111,16 @@
40037	40111	label = 759LLU; // newvarraw
40038	40112	break;
40039	40113	}
40040		- case 3381LLU: // copy-back deleter (newvarraw to shadowlock)
	40114	+ case 3390LLU: // copy-back deleter (newvarraw to shadowlock)
40041	40115	{
40042	40116	// copy mutable arguments back from call to newvarraw
40043	40117	stack[base + 3]/scope/ = stack[base + 34LLU];
40044	40118	stack[base + 7]/varcount/ = stack[base + 33LLU];
40045	40119	stack[base + 6]/fnmaxcount/ = stack[base + 32LLU];
40046		- label = 3377LLU; // continue to roll stack
	40120	+ label = 3386LLU; // continue to roll stack
40047	40121	break;
40048	40122	}
40049		- case 3382LLU: // return from newvarraw to shadowlock
	40123	+ case 3391LLU: // return from newvarraw to shadowlock
40050	40124	{
40051	40125	// copy mutable arguments back from call to newvarraw
40052	40126	stack[base + 3]/scope/ = stack[base + 34LLU];

		@@ -40055,9 +40129,9 @@
40055	40129	// copy back results provided by call to newvarraw
40056	40130	stack[base + 22] = stack[base + 26LLU];
40057	40131	// call emitvaridx from shadowlock
40058		- stack[base + 23LLU] = 3383LLU/throw to this address/;
	40132	+ stack[base + 23LLU] = 3392LLU/throw to this address/;
40059	40133	stack[base + 24LLU] = base;
40060		- stack[base + 25LLU] = 3384LLU;
	40134	+ stack[base + 25LLU] = 3393LLU;
40061	40135	// arguments for call to emitvaridx
40062	40136	stack[base + 26LLU] = stack[base + 22]/shadowidx/;
40063	40137	// set stack-base & callee-address

		@@ -40065,58 +40139,58 @@
40065	40139	label = 745LLU; // emitvaridx
40066	40140	break;
40067	40141	}
40068		- case 3383LLU: // copy-back deleter (emitvaridx to shadowlock)
	40142	+ case 3392LLU: // copy-back deleter (emitvaridx to shadowlock)
40069	40143	{
40070	40144	// copy mutable arguments back from call to emitvaridx
40071		- label = 3379LLU; // continue to roll stack
	40145	+ label = 3388LLU; // continue to roll stack
40072	40146	break;
40073	40147	}
40074		- case 3384LLU: // return from emitvaridx to shadowlock
	40148	+ case 3393LLU: // return from emitvaridx to shadowlock
40075	40149	{
40076	40150	// copy mutable arguments back from call to emitvaridx
40077	40151	printf("%s", ");");
40078		- label = 3386LLU; // skip deleter
	40152	+ label = 3395LLU; // skip deleter
40079	40153	break;
40080	40154	}
40081		- case 3385LLU: // deleter
	40155	+ case 3394LLU: // deleter
40082	40156	{
40083	40157	// throw from shadowlock
40084	40158	if(!stack[base + 20])
40085	40159	{
40086		- label = 3379LLU; // skip, variable already deleted/unscoped
	40160	+ label = 3388LLU; // skip, variable already deleted/unscoped
40087	40161	break;
40088	40162	}
40089		- label = 3379LLU; // continue unrolling stack, delete next variable
	40163	+ label = 3388LLU; // continue unrolling stack, delete next variable
40090	40164	break;
40091	40165	}
40092		- case 3386LLU: // skipped deleter
	40166	+ case 3395LLU: // skipped deleter
40093	40167	{
40094	40168	stack[base + 20] = stack[base + 22]/shadowidx/;
40095		- label = 3351LLU; // alternative complete
	40169	+ label = 3360LLU; // alternative complete
40096	40170	break;
40097	40171	}
40098		- case 3351LLU: // completed if-then-else
	40172	+ case 3360LLU: // completed if-then-else
40099	40173	{
40100		- label = 3388LLU; // skip deleter
	40174	+ label = 3397LLU; // skip deleter
40101	40175	break;
40102	40176	}
40103		- case 3387LLU: // deleter
	40177	+ case 3396LLU: // deleter
40104	40178	{
40105	40179	// throw from shadowlock
40106	40180	if(!stack[base + 21])
40107	40181	{
40108		- label = 3348LLU; // skip, variable already deleted/unscoped
	40182	+ label = 3357LLU; // skip, variable already deleted/unscoped
40109	40183	break;
40110	40184	}
40111		- label = 3348LLU; // continue unrolling stack, delete next variable
	40185	+ label = 3357LLU; // continue unrolling stack, delete next variable
40112	40186	break;
40113	40187	}
40114		- case 3388LLU: // skipped deleter
	40188	+ case 3397LLU: // skipped deleter
40115	40189	{
40116	40190	// call newvarraw from shadowlock
40117		- stack[base + 22LLU] = 3389LLU/throw to this address/;
	40191	+ stack[base + 22LLU] = 3398LLU/throw to this address/;
40118	40192	stack[base + 23LLU] = base;
40119		- stack[base + 24LLU] = 3390LLU;
	40193	+ stack[base + 24LLU] = 3399LLU;
40120	40194	// arguments for call to newvarraw
40121	40195	stack[base + 26LLU] = stack[base + 18]/elemtype/;
40122	40196	stack[base + 27LLU] = stack[base + 10]/elemid/;

		@@ -40132,16 +40206,16 @@
40132	40206	label = 759LLU; // newvarraw
40133	40207	break;
40134	40208	}
40135		- case 3389LLU: // copy-back deleter (newvarraw to shadowlock)
	40209	+ case 3398LLU: // copy-back deleter (newvarraw to shadowlock)
40136	40210	{
40137	40211	// copy mutable arguments back from call to newvarraw
40138	40212	stack[base + 3]/scope/ = stack[base + 33LLU];
40139	40213	stack[base + 7]/varcount/ = stack[base + 32LLU];
40140	40214	stack[base + 6]/fnmaxcount/ = stack[base + 31LLU];
40141		- label = 3348LLU; // continue to roll stack
	40215	+ label = 3357LLU; // continue to roll stack
40142	40216	break;
40143	40217	}
40144		- case 3390LLU: // return from newvarraw to shadowlock
	40218	+ case 3399LLU: // return from newvarraw to shadowlock
40145	40219	{
40146	40220	// copy mutable arguments back from call to newvarraw
40147	40221	stack[base + 3]/scope/ = stack[base + 33LLU];

		@@ -40149,15 +40223,15 @@
40149	40223	stack[base + 6]/fnmaxcount/ = stack[base + 31LLU];
40150	40224	// copy back results provided by call to newvarraw
40151	40225	stack[base + 21] = stack[base + 25LLU];
40152		- label = 3392LLU; // skip deleter
	40226	+ label = 3401LLU; // skip deleter
40153	40227	break;
40154	40228	}
40155		- case 3391LLU: // deleter
	40229	+ case 3400LLU: // deleter
40156	40230	{
40157	40231	// throw from shadowlock
40158	40232	if(!stack[base + 22])
40159	40233	{
40160		- label = 3387LLU; // skip, variable already deleted/unscoped
	40234	+ label = 3396LLU; // skip, variable already deleted/unscoped
40161	40235	break;
40162	40236	}
40163	40237

		@@ -40166,40 +40240,40 @@
40166	40240	newstack[0] = (uint64_t)stack; // backup stack location
40167	40241	newstack[1] = 1234567890;
40168	40242	newstack[2] = base;
40169		- newstack[3] = 3393LLU;
	40243	+ newstack[3] = 3402LLU;
40170	40244	stack = newstack;
40171	40245	// set stack-base & callee-address
40172	40246	base = 4/deloffset/;
40173		- label = 3307LLU; // ~popnext
	40247	+ label = 3316LLU; // ~popnext
40174	40248	break;
40175	40249	}
40176		- case 3393LLU: // return from ~popnext to shadowlock
	40250	+ case 3402LLU: // return from ~popnext to shadowlock
40177	40251	{
40178	40252	stack = (uint64_t *)stack[0];
40179	40253	// releasing toplevel container
40180	40254	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 22] - sizeof(uint64_t) 4));
40181	40255
40182		- label = 3387LLU; // continue unrolling stack, delete next variable
	40256	+ label = 3396LLU; // continue unrolling stack, delete next variable
40183	40257	break;
40184	40258	}
40185		- case 3392LLU: // skipped deleter
	40259	+ case 3401LLU: // skipped deleter
40186	40260	{
40187	40261	if(!stack[base + 11]/consume/)
40188	40262	{
40189		- label = 3394LLU; // jump to alternative
	40263	+ label = 3403LLU; // jump to alternative
40190	40264	break;
40191	40265	}
40192	40266
40193	40267	// consequent
40194		- label = 3397LLU; // skip deleter
	40268	+ label = 3406LLU; // skip deleter
40195	40269	break;
40196	40270	}
40197		- case 3396LLU: // deleter
	40271	+ case 3405LLU: // deleter
40198	40272	{
40199	40273	// throw from shadowlock
40200	40274	if(!stack[base + 22])
40201	40275	{
40202		- label = 3387LLU; // skip, variable already deleted/unscoped
	40276	+ label = 3396LLU; // skip, variable already deleted/unscoped
40203	40277	break;
40204	40278	}
40205	40279

		@@ -40208,58 +40282,58 @@
40208	40282	newstack[0] = (uint64_t)stack; // backup stack location
40209	40283	newstack[1] = 1234567890;
40210	40284	newstack[2] = base;
40211		- newstack[3] = 3398LLU;
	40285	+ newstack[3] = 3407LLU;
40212	40286	stack = newstack;
40213	40287	// set stack-base & callee-address
40214	40288	base = 4/deloffset/;
40215		- label = 3307LLU; // ~popnext
	40289	+ label = 3316LLU; // ~popnext
40216	40290	break;
40217	40291	}
40218		- case 3398LLU: // return from ~popnext to shadowlock
	40292	+ case 3407LLU: // return from ~popnext to shadowlock
40219	40293	{
40220	40294	stack = (uint64_t *)stack[0];
40221	40295	// releasing toplevel container
40222	40296	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 22] - sizeof(uint64_t) 4));
40223	40297
40224		- label = 3387LLU; // continue unrolling stack, delete next variable
	40298	+ label = 3396LLU; // continue unrolling stack, delete next variable
40225	40299	break;
40226	40300	}
40227		- case 3397LLU: // skipped deleter
	40301	+ case 3406LLU: // skipped deleter
40228	40302	{
40229	40303	// construct popnext.pop
40230	40304	if(!(stack[base + 22] = construct(0)))
40231	40305	{
40232		- label = 3387LLU; // throw: begin to unroll stack
	40306	+ label = 3396LLU; // throw: begin to unroll stack
40233	40307	break;
40234	40308	}
40235	40309
40236	40310	// consequent
40237	40311	((uint64_t *)stack[base + 22])[0] = 0;
40238		- label = 3395LLU; // consequent complete
	40312	+ label = 3404LLU; // consequent complete
40239	40313	break;
40240	40314	}
40241		- case 3394LLU: // alternative
	40315	+ case 3403LLU: // alternative
40242	40316	{
40243		- label = 3400LLU; // skip deleter
	40317	+ label = 3409LLU; // skip deleter
40244	40318	break;
40245	40319	}
40246		- case 3399LLU: // deleter
	40320	+ case 3408LLU: // deleter
40247	40321	{
40248	40322	// throw from shadowlock
40249	40323	if(!stack[base + 23])
40250	40324	{
40251		- label = 3387LLU; // skip, variable already deleted/unscoped
	40325	+ label = 3396LLU; // skip, variable already deleted/unscoped
40252	40326	break;
40253	40327	}
40254		- label = 3387LLU; // continue unrolling stack, delete next variable
	40328	+ label = 3396LLU; // continue unrolling stack, delete next variable
40255	40329	break;
40256	40330	}
40257		- case 3400LLU: // skipped deleter
	40331	+ case 3409LLU: // skipped deleter
40258	40332	{
40259	40333	// call newvarraw from shadowlock
40260		- stack[base + 24LLU] = 3401LLU/throw to this address/;
	40334	+ stack[base + 24LLU] = 3410LLU/throw to this address/;
40261	40335	stack[base + 25LLU] = base;
40262		- stack[base + 26LLU] = 3402LLU;
	40336	+ stack[base + 26LLU] = 3411LLU;
40263	40337	// arguments for call to newvarraw
40264	40338	stack[base + 28LLU] = stack[base + 13]/listtype/;
40265	40339	stack[base + 29LLU] = 0LLU;

		@@ -40275,16 +40349,16 @@
40275	40349	label = 759LLU; // newvarraw
40276	40350	break;
40277	40351	}
40278		- case 3401LLU: // copy-back deleter (newvarraw to shadowlock)
	40352	+ case 3410LLU: // copy-back deleter (newvarraw to shadowlock)
40279	40353	{
40280	40354	// copy mutable arguments back from call to newvarraw
40281	40355	stack[base + 3]/scope/ = stack[base + 35LLU];
40282	40356	stack[base + 7]/varcount/ = stack[base + 34LLU];
40283	40357	stack[base + 6]/fnmaxcount/ = stack[base + 33LLU];
40284		- label = 3387LLU; // continue to roll stack
	40358	+ label = 3396LLU; // continue to roll stack
40285	40359	break;
40286	40360	}
40287		- case 3402LLU: // return from newvarraw to shadowlock
	40361	+ case 3411LLU: // return from newvarraw to shadowlock
40288	40362	{
40289	40363	// copy mutable arguments back from call to newvarraw
40290	40364	stack[base + 3]/scope/ = stack[base + 35LLU];

		@@ -40292,15 +40366,15 @@
40292	40366	stack[base + 6]/fnmaxcount/ = stack[base + 33LLU];
40293	40367	// copy back results provided by call to newvarraw
40294	40368	stack[base + 23] = stack[base + 27LLU];
40295		- label = 3404LLU; // skip deleter
	40369	+ label = 3413LLU; // skip deleter
40296	40370	break;
40297	40371	}
40298		- case 3403LLU: // deleter
	40372	+ case 3412LLU: // deleter
40299	40373	{
40300	40374	// throw from shadowlock
40301	40375	if(!stack[base + 22])
40302	40376	{
40303		- label = 3399LLU; // skip, variable already deleted/unscoped
	40377	+ label = 3408LLU; // skip, variable already deleted/unscoped
40304	40378	break;
40305	40379	}
40306	40380

		@@ -40309,28 +40383,28 @@
40309	40383	newstack[0] = (uint64_t)stack; // backup stack location
40310	40384	newstack[1] = 1234567890;
40311	40385	newstack[2] = base;
40312		- newstack[3] = 3405LLU;
	40386	+ newstack[3] = 3414LLU;
40313	40387	stack = newstack;
40314	40388	// set stack-base & callee-address
40315	40389	base = 4/deloffset/;
40316		- label = 3307LLU; // ~popnext
	40390	+ label = 3316LLU; // ~popnext
40317	40391	break;
40318	40392	}
40319		- case 3405LLU: // return from ~popnext to shadowlock
	40393	+ case 3414LLU: // return from ~popnext to shadowlock
40320	40394	{
40321	40395	stack = (uint64_t *)stack[0];
40322	40396	// releasing toplevel container
40323	40397	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 22] - sizeof(uint64_t) 4));
40324	40398
40325		- label = 3399LLU; // continue unrolling stack, delete next variable
	40399	+ label = 3408LLU; // continue unrolling stack, delete next variable
40326	40400	break;
40327	40401	}
40328		- case 3404LLU: // skipped deleter
	40402	+ case 3413LLU: // skipped deleter
40329	40403	{
40330	40404	// construct popnext.next
40331	40405	if(!(stack[base + 22] = construct(1)))
40332	40406	{
40333		- label = 3399LLU; // throw: begin to unroll stack
	40407	+ label = 3408LLU; // throw: begin to unroll stack
40334	40408	break;
40335	40409	}
40336	40410

		@@ -40337,20 +40411,20 @@
40337	40411	// consequent
40338	40412	((uint64_t *)stack[base + 22])[0] = 1;
40339	40413	(((uint64_t *)(stack[base + 22]))[1][0]) = stack[base + 23]/previdx*/;
40340		- label = 3395LLU; // alternative complete
	40414	+ label = 3404LLU; // alternative complete
40341	40415	break;
40342	40416	}
40343		- case 3395LLU: // completed if-then-else
	40417	+ case 3404LLU: // completed if-then-else
40344	40418	{
40345		- label = 3407LLU; // skip deleter
	40419	+ label = 3416LLU; // skip deleter
40346	40420	break;
40347	40421	}
40348		- case 3406LLU: // deleter
	40422	+ case 3415LLU: // deleter
40349	40423	{
40350	40424	// throw from shadowlock
40351	40425	if(!stack[base + 0])
40352	40426	{
40353		- label = 3391LLU; // skip, variable already deleted/unscoped
	40427	+ label = 3400LLU; // skip, variable already deleted/unscoped
40354	40428	break;
40355	40429	}
40356	40430

		@@ -40359,28 +40433,28 @@
40359	40433	newstack[0] = (uint64_t)stack; // backup stack location
40360	40434	newstack[1] = 1234567890;
40361	40435	newstack[2] = base;
40362		- newstack[3] = 3408LLU;
	40436	+ newstack[3] = 3417LLU;
40363	40437	stack = newstack;
40364	40438	// set stack-base & callee-address
40365	40439	base = 4/deloffset/;
40366		- label = 3310LLU; // ~listtoelem
	40440	+ label = 3319LLU; // ~listtoelem
40367	40441	break;
40368	40442	}
40369		- case 3408LLU: // return from ~listtoelem to shadowlock
	40443	+ case 3417LLU: // return from ~listtoelem to shadowlock
40370	40444	{
40371	40445	stack = (uint64_t *)stack[0];
40372	40446	// releasing toplevel container
40373	40447	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
40374	40448
40375		- label = 3391LLU; // continue unrolling stack, delete next variable
	40449	+ label = 3400LLU; // continue unrolling stack, delete next variable
40376	40450	break;
40377	40451	}
40378		- case 3407LLU: // skipped deleter
	40452	+ case 3416LLU: // skipped deleter
40379	40453	{
40380	40454	// construct listtoelem.listtoelem
40381	40455	if(!(stack[base + 0] = construct(4)))
40382	40456	{
40383		- label = 3391LLU; // throw: begin to unroll stack
	40457	+ label = 3400LLU; // throw: begin to unroll stack
40384	40458	break;
40385	40459	}
40386	40460

		@@ -40395,10 +40469,10 @@
40395	40469	((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15];
40396	40470	((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14];
40397	40471	((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13];
40398		- label = 3321LLU; // case complete
	40472	+ label = 3330LLU; // case complete
40399	40473	break;
40400	40474	}
40401		- case 3323LLU: // copy-back deleter (switch)
	40475	+ case 3332LLU: // copy-back deleter (switch)
40402	40476	{
40403	40477	((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 17];
40404	40478	((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 16];

		@@ -40405,15 +40479,15 @@
40405	40479	((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 15];
40406	40480	((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 14];
40407	40481	((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 13];
40408		- label = 3316LLU; // continue to unroll stack
	40482	+ label = 3325LLU; // continue to unroll stack
40409	40483	break;
40410	40484	}
40411		- case 3322LLU: // try next case
	40485	+ case 3331LLU: // try next case
40412	40486	{
40413	40487	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
40414	40488	exit(-1);
40415	40489	}
40416		- case 3321LLU: // completed switch
	40490	+ case 3330LLU: // completed switch
40417	40491	{
40418	40492
40419	40493	uint64_t newstack = (uint64_t )(stack[base + 12] - sizeof(uint64_t) * 4);

		@@ -40421,7 +40495,7 @@
40421	40495	newstack[0] = (uint64_t)stack; // backup stack location
40422	40496	newstack[1] = 1234567890;
40423	40497	newstack[2] = base;
40424		- newstack[3] = 3409LLU;
	40498	+ newstack[3] = 3418LLU;
40425	40499	stack = newstack;
40426	40500	// set stack-base & callee-address
40427	40501	base = 4/deloffset/;

		@@ -40428,7 +40502,7 @@
40428	40502	label = 486LLU; // ~letdef
40429	40503	break;
40430	40504	}
40431		- case 3409LLU: // return from ~letdef to shadowlock
	40505	+ case 3418LLU: // return from ~letdef to shadowlock
40432	40506	{
40433	40507	stack = (uint64_t *)stack[0];
40434	40508	// releasing toplevel container

		@@ -40439,13 +40513,13 @@
40439	40513	base = stack[base - 2];
40440	40514	break;
40441	40515	}
40442		- case 3411LLU: // function popnextdel failed
	40516	+ case 3420LLU: // function popnextdel failed
40443	40517	{
40444	40518	label = stack[base - 3];
40445	40519	base = stack[base - 2];
40446	40520	break;
40447	40521	}
40448		- case 3410LLU: // popnextdel
	40522	+ case 3419LLU: // popnextdel
40449	40523	{
40450	40524	//#define arg0 0
40451	40525	//#define arg1 1

		@@ -40452,14 +40526,14 @@
40452	40526	//#define arg2 2
40453	40527	//#define arg3 3
40454	40528	flippedassign(stack[base + 2]/states/, &stack[base + 4]);
40455		- label = 3412LLU; // start to repeat
	40529	+ label = 3421LLU; // start to repeat
40456	40530	break;
40457	40531	}
40458		- case 3412LLU: // repeat from here
	40532	+ case 3421LLU: // repeat from here
40459	40533	{
40460	40534	if(!stack[base + 4])
40461	40535	{
40462		- label = 3413LLU; // break loop
	40536	+ label = 3422LLU; // break loop
40463	40537	break;
40464	40538	}
40465	40539

		@@ -40469,7 +40543,7 @@
40469	40543	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
40470	40544	if(/listtoelem/0 != ((uint64_t )(stack[base + 5]/state*/))[0])
40471	40545	{
40472		- label = 3416LLU; // jump to alternative
	40546	+ label = 3425LLU; // jump to alternative
40473	40547	break;
40474	40548	}
40475	40549

		@@ -40481,7 +40555,7 @@
40481	40555	// case
40482	40556	if(/pop/0 != ((uint64_t )(stack[base + 8]/popnext*/))[0])
40483	40557	{
40484		- label = 3419LLU; // jump to alternative
	40558	+ label = 3428LLU; // jump to alternative
40485	40559	break;
40486	40560	}
40487	40561

		@@ -40490,7 +40564,7 @@
40490	40564	uint64_t newstack = (uint64_t )Calloc(75LLU + 1, sizeof(uint64_t));
40491	40565	if(!newstack)
40492	40566	{
40493		- label = 3420LLU; // throw: begin to unroll stack
	40567	+ label = 3429LLU; // throw: begin to unroll stack
40494	40568	break;
40495	40569	}
40496	40570

		@@ -40497,9 +40571,9 @@
40497	40571	newstack[75LLU] = 9876543210LLU; // overflow-marker
40498	40572	// call calldestr from popnextdel
40499	40573	newstack[0] = (uint64_t)stack; // backup stack location
40500		- newstack[1] = 3421LLU;
	40574	+ newstack[1] = 3430LLU;
40501	40575	newstack[2] = base;
40502		- newstack[3] = 3422LLU;
	40576	+ newstack[3] = 3431LLU;
40503	40577	// arguments for call to calldestr
40504	40578	newstack[4LLU] = stack[base + 0]/fnid/;
40505	40579	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -40513,7 +40587,7 @@
40513	40587	label = 1150LLU; // calldestr
40514	40588	break;
40515	40589	}
40516		- case 3421LLU: // copy-back deleter (calldestr to popnextdel)
	40590	+ case 3430LLU: // copy-back deleter (calldestr to popnextdel)
40517	40591	{
40518	40592	uint64_t oldstack = (uint64_t )stack[0];
40519	40593	// copy mutable arguments back from call to calldestr

		@@ -40525,10 +40599,10 @@
40525	40599	}
40526	40600	Free(75LLU + 1, sizeof(uint64_t), stack);
40527	40601	stack = oldstack;
40528		- label = 3420LLU; // continue to unroll stack
	40602	+ label = 3429LLU; // continue to unroll stack
40529	40603	break;
40530	40604	}
40531		- case 3422LLU: // return from calldestr to popnextdel
	40605	+ case 3431LLU: // return from calldestr to popnextdel
40532	40606	{
40533	40607	uint64_t oldstack = (uint64_t )stack[0];
40534	40608	// copy mutable arguments back from call to calldestr

		@@ -40540,19 +40614,19 @@
40540	40614	}
40541	40615	Free(75LLU + 1, sizeof(uint64_t), stack);
40542	40616	stack = oldstack;
40543		- label = 3418LLU; // case complete
	40617	+ label = 3427LLU; // case complete
40544	40618	break;
40545	40619	}
40546		- case 3420LLU: // copy-back deleter (switch)
	40620	+ case 3429LLU: // copy-back deleter (switch)
40547	40621	{
40548		- label = 3417LLU; // continue to unroll stack
	40622	+ label = 3426LLU; // continue to unroll stack
40549	40623	break;
40550	40624	}
40551		- case 3419LLU: // try next case
	40625	+ case 3428LLU: // try next case
40552	40626	{
40553	40627	if(/next/1 != ((uint64_t )(stack[base + 8]/popnext*/))[0])
40554	40628	{
40555		- label = 3423LLU; // jump to alternative
	40629	+ label = 3432LLU; // jump to alternative
40556	40630	break;
40557	40631	}
40558	40632

		@@ -40561,9 +40635,9 @@
40561	40635	// case
40562	40636	printf("%s", "\n ((struct listnode *)(");
40563	40637	// call emitvaridx from popnextdel
40564		- stack[base + 12LLU] = 3425LLU/throw to this address/;
	40638	+ stack[base + 12LLU] = 3434LLU/throw to this address/;
40565	40639	stack[base + 13LLU] = base;
40566		- stack[base + 14LLU] = 3426LLU;
	40640	+ stack[base + 14LLU] = 3435LLU;
40567	40641	// arguments for call to emitvaridx
40568	40642	stack[base + 15LLU] = stack[base + 11]/previdx/;
40569	40643	// set stack-base & callee-address

		@@ -40571,20 +40645,20 @@
40571	40645	label = 745LLU; // emitvaridx
40572	40646	break;
40573	40647	}
40574		- case 3425LLU: // copy-back deleter (emitvaridx to popnextdel)
	40648	+ case 3434LLU: // copy-back deleter (emitvaridx to popnextdel)
40575	40649	{
40576	40650	// copy mutable arguments back from call to emitvaridx
40577		- label = 3424LLU; // continue to roll stack
	40651	+ label = 3433LLU; // continue to roll stack
40578	40652	break;
40579	40653	}
40580		- case 3426LLU: // return from emitvaridx to popnextdel
	40654	+ case 3435LLU: // return from emitvaridx to popnextdel
40581	40655	{
40582	40656	// copy mutable arguments back from call to emitvaridx
40583	40657	printf("%s", "/previous/))->data = ");
40584	40658	// call emitvaridx from popnextdel
40585		- stack[base + 12LLU] = 3427LLU/throw to this address/;
	40659	+ stack[base + 12LLU] = 3436LLU/throw to this address/;
40586	40660	stack[base + 13LLU] = base;
40587		- stack[base + 14LLU] = 3428LLU;
	40661	+ stack[base + 14LLU] = 3437LLU;
40588	40662	// arguments for call to emitvaridx
40589	40663	stack[base + 15LLU] = stack[base + 10]/elemindex/;
40590	40664	// set stack-base & callee-address

		@@ -40592,67 +40666,67 @@
40592	40666	label = 745LLU; // emitvaridx
40593	40667	break;
40594	40668	}
40595		- case 3427LLU: // copy-back deleter (emitvaridx to popnextdel)
	40669	+ case 3436LLU: // copy-back deleter (emitvaridx to popnextdel)
40596	40670	{
40597	40671	// copy mutable arguments back from call to emitvaridx
40598		- label = 3424LLU; // continue to roll stack
	40672	+ label = 3433LLU; // continue to roll stack
40599	40673	break;
40600	40674	}
40601		- case 3428LLU: // return from emitvaridx to popnextdel
	40675	+ case 3437LLU: // return from emitvaridx to popnextdel
40602	40676	{
40603	40677	// copy mutable arguments back from call to emitvaridx
40604	40678	printf("%s", ";");
40605	40679	((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
40606		- label = 3418LLU; // case complete
	40680	+ label = 3427LLU; // case complete
40607	40681	break;
40608	40682	}
40609		- case 3424LLU: // copy-back deleter (switch)
	40683	+ case 3433LLU: // copy-back deleter (switch)
40610	40684	{
40611	40685	((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
40612		- label = 3417LLU; // continue to unroll stack
	40686	+ label = 3426LLU; // continue to unroll stack
40613	40687	break;
40614	40688	}
40615		- case 3423LLU: // try next case
	40689	+ case 3432LLU: // try next case
40616	40690	{
40617	40691	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
40618	40692	exit(-1);
40619	40693	}
40620		- case 3418LLU: // completed switch
	40694	+ case 3427LLU: // completed switch
40621	40695	{
40622	40696	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
40623	40697	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
40624	40698	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
40625	40699	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
40626		- label = 3415LLU; // case complete
	40700	+ label = 3424LLU; // case complete
40627	40701	break;
40628	40702	}
40629		- case 3417LLU: // copy-back deleter (switch)
	40703	+ case 3426LLU: // copy-back deleter (switch)
40630	40704	{
40631	40705	((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
40632	40706	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
40633	40707	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
40634	40708	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
40635		- label = 3414LLU; // continue to unroll stack
	40709	+ label = 3423LLU; // continue to unroll stack
40636	40710	break;
40637	40711	}
40638		- case 3416LLU: // try next case
	40712	+ case 3425LLU: // try next case
40639	40713	{
40640	40714	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
40641	40715	exit(-1);
40642	40716	}
40643		- case 3415LLU: // completed switch
	40717	+ case 3424LLU: // completed switch
40644	40718	{
40645	40719	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
40646		- label = 3412LLU; // repeat
	40720	+ label = 3421LLU; // repeat
40647	40721	break;
40648	40722	}
40649		- case 3414LLU: // copy-back deleter for while next
	40723	+ case 3423LLU: // copy-back deleter for while next
40650	40724	{
40651	40725	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
40652		- label = 3411LLU; // continue to unroll stack
	40726	+ label = 3420LLU; // continue to unroll stack
40653	40727	break;
40654	40728	}
40655		- case 3413LLU: // loop finished
	40729	+ case 3422LLU: // loop finished
40656	40730	{
40657	40731	// return from popnextdel
40658	40732	label = stack[base - 1];

		@@ -40659,13 +40733,13 @@
40659	40733	base = stack[base - 2];
40660	40734	break;
40661	40735	}
40662		- case 3430LLU: // function procblock failed
	40736	+ case 3439LLU: // function procblock failed
40663	40737	{
40664	40738	label = stack[base - 3];
40665	40739	base = stack[base - 2];
40666	40740	break;
40667	40741	}
40668		- case 3429LLU: // procblock
	40742	+ case 3438LLU: // procblock
40669	40743	{
40670	40744	//#define arg0 0
40671	40745	//#define arg1 1

		@@ -40685,49 +40759,49 @@
40685	40759	//#define arg15 15
40686	40760	//#define arg16 16
40687	40761	//#define arg17 17
40688		- label = 3432LLU; // skip deleter
	40762	+ label = 3441LLU; // skip deleter
40689	40763	break;
40690	40764	}
40691		- case 3431LLU: // deleter
	40765	+ case 3440LLU: // deleter
40692	40766	{
40693	40767	// throw from procblock
40694	40768	if(!stack[base + 18])
40695	40769	{
40696		- label = 3430LLU; // skip, variable already deleted/unscoped
	40770	+ label = 3439LLU; // skip, variable already deleted/unscoped
40697	40771	break;
40698	40772	}
40699		- label = 3430LLU; // continue unrolling stack, delete next variable
	40773	+ label = 3439LLU; // continue unrolling stack, delete next variable
40700	40774	break;
40701	40775	}
40702		- case 3432LLU: // skipped deleter
	40776	+ case 3441LLU: // skipped deleter
40703	40777	{
40704	40778	stack[base + 18] = stack[base + 13]/varcount/;
40705		- label = 3434LLU; // skip deleter
	40779	+ label = 3443LLU; // skip deleter
40706	40780	break;
40707	40781	}
40708		- case 3433LLU: // deleter
	40782	+ case 3442LLU: // deleter
40709	40783	{
40710	40784	// throw from procblock
40711	40785	if(!stack[base + 19])
40712	40786	{
40713		- label = 3431LLU; // skip, variable already deleted/unscoped
	40787	+ label = 3440LLU; // skip, variable already deleted/unscoped
40714	40788	break;
40715	40789	}
40716		- label = 3431LLU; // continue unrolling stack, delete next variable
	40790	+ label = 3440LLU; // continue unrolling stack, delete next variable
40717	40791	break;
40718	40792	}
40719		- case 3434LLU: // skipped deleter
	40793	+ case 3443LLU: // skipped deleter
40720	40794	{
40721	40795	stack[base + 19] = stack[base + 14]/lookahead/;
40722		- label = 3436LLU; // skip deleter
	40796	+ label = 3445LLU; // skip deleter
40723	40797	break;
40724	40798	}
40725		- case 3435LLU: // deleter
	40799	+ case 3444LLU: // deleter
40726	40800	{
40727	40801	// throw from procblock
40728	40802	if(!stack[base + 20])
40729	40803	{
40730		- label = 3433LLU; // skip, variable already deleted/unscoped
	40804	+ label = 3442LLU; // skip, variable already deleted/unscoped
40731	40805	break;
40732	40806	}
40733	40807

		@@ -40736,7 +40810,7 @@
40736	40810	newstack[0] = (uint64_t)stack; // backup stack location
40737	40811	newstack[1] = 1234567890;
40738	40812	newstack[2] = base;
40739		- newstack[3] = 3437LLU;
	40813	+ newstack[3] = 3446LLU;
40740	40814	stack = newstack;
40741	40815	// set stack-base & callee-address
40742	40816	base = 4/deloffset/;

		@@ -40743,21 +40817,21 @@
40743	40817	label = 562LLU; // ~scope
40744	40818	break;
40745	40819	}
40746		- case 3437LLU: // return from ~scope to procblock
	40820	+ case 3446LLU: // return from ~scope to procblock
40747	40821	{
40748	40822	stack = (uint64_t *)stack[0];
40749	40823	// releasing toplevel container
40750	40824	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 20] - sizeof(uint64_t) 4));
40751	40825
40752		- label = 3433LLU; // continue unrolling stack, delete next variable
	40826	+ label = 3442LLU; // continue unrolling stack, delete next variable
40753	40827	break;
40754	40828	}
40755		- case 3436LLU: // skipped deleter
	40829	+ case 3445LLU: // skipped deleter
40756	40830	{
40757	40831	// call linkscope from procblock
40758		- stack[base + 21LLU] = 3438LLU/throw to this address/;
	40832	+ stack[base + 21LLU] = 3447LLU/throw to this address/;
40759	40833	stack[base + 22LLU] = base;
40760		- stack[base + 23LLU] = 3439LLU;
	40834	+ stack[base + 23LLU] = 3448LLU;
40761	40835	// arguments for call to linkscope
40762	40836	stack[base + 25LLU] = stack[base + 3]/scope/;
40763	40837	// set stack-base & callee-address

		@@ -40765,13 +40839,13 @@
40765	40839	label = 589LLU; // linkscope
40766	40840	break;
40767	40841	}
40768		- case 3438LLU: // copy-back deleter (linkscope to procblock)
	40842	+ case 3447LLU: // copy-back deleter (linkscope to procblock)
40769	40843	{
40770	40844	// copy mutable arguments back from call to linkscope
40771		- label = 3433LLU; // continue to roll stack
	40845	+ label = 3442LLU; // continue to roll stack
40772	40846	break;
40773	40847	}
40774		- case 3439LLU: // return from linkscope to procblock
	40848	+ case 3448LLU: // return from linkscope to procblock
40775	40849	{
40776	40850	// copy mutable arguments back from call to linkscope
40777	40851	// copy back results provided by call to linkscope

		@@ -40790,22 +40864,22 @@
40790	40864	/scopes/stack[base + 2] = (uint64_t)list;
40791	40865	MOVE(&list->data, &stack[base + 20]/newscope/);
40792	40866	}
40793		- label = 3440LLU; // start to repeat
	40867	+ label = 3449LLU; // start to repeat
40794	40868	break;
40795	40869	}
40796		- case 3440LLU: // repeat from here
	40870	+ case 3449LLU: // repeat from here
40797	40871	{
40798	40872	if(stack[base + 19]/lookahead/ > 0xFF)
40799	40873	{
40800		- label = 3441LLU; // break loop
	40874	+ label = 3450LLU; // break loop
40801	40875	break;
40802	40876	}
40803	40877
40804	40878	// loop body
40805	40879	// call skipwscmnt from procblock
40806		- stack[base + 20LLU] = 3442LLU/throw to this address/;
	40880	+ stack[base + 20LLU] = 3451LLU/throw to this address/;
40807	40881	stack[base + 21LLU] = base;
40808		- stack[base + 22LLU] = 3443LLU;
	40882	+ stack[base + 22LLU] = 3452LLU;
40809	40883	// arguments for call to skipwscmnt
40810	40884	stack[base + 24LLU] = stack[base + 19]/lookahead/;
40811	40885	// set stack-base & callee-address

		@@ -40813,38 +40887,38 @@
40813	40887	label = 18446744073709551580LLU; // skipwscmnt
40814	40888	break;
40815	40889	}
40816		- case 3442LLU: // copy-back deleter (skipwscmnt to procblock)
	40890	+ case 3451LLU: // copy-back deleter (skipwscmnt to procblock)
40817	40891	{
40818	40892	// copy mutable arguments back from call to skipwscmnt
40819		- label = 3433LLU; // continue to roll stack
	40893	+ label = 3442LLU; // continue to roll stack
40820	40894	break;
40821	40895	}
40822		- case 3443LLU: // return from skipwscmnt to procblock
	40896	+ case 3452LLU: // return from skipwscmnt to procblock
40823	40897	{
40824	40898	// copy mutable arguments back from call to skipwscmnt
40825	40899	// copy back results provided by call to skipwscmnt
40826	40900	stack[base + 19] = stack[base + 23LLU];
40827		- label = 3445LLU; // skip deleter
	40901	+ label = 3454LLU; // skip deleter
40828	40902	break;
40829	40903	}
40830		- case 3444LLU: // deleter
	40904	+ case 3453LLU: // deleter
40831	40905	{
40832	40906	// throw from procblock
40833	40907	if(!stack[base + 20])
40834	40908	{
40835		- label = 3433LLU; // skip, variable already deleted/unscoped
	40909	+ label = 3442LLU; // skip, variable already deleted/unscoped
40836	40910	break;
40837	40911	}
40838		- label = 3433LLU; // continue unrolling stack, delete next variable
	40912	+ label = 3442LLU; // continue unrolling stack, delete next variable
40839	40913	break;
40840	40914	}
40841		- case 3445LLU: // skipped deleter
	40915	+ case 3454LLU: // skipped deleter
40842	40916	{
40843	40917	stack[base + 20] = 0;
40844	40918	// call equ from procblock
40845		- stack[base + 21LLU] = 3446LLU/throw to this address/;
	40919	+ stack[base + 21LLU] = 3455LLU/throw to this address/;
40846	40920	stack[base + 22LLU] = base;
40847		- stack[base + 23LLU] = 3447LLU;
	40921	+ stack[base + 23LLU] = 3456LLU;
40848	40922	// arguments for call to equ
40849	40923	stack[base + 25LLU] = stack[base + 19]/lookahead/;
40850	40924	stack[base + 26LLU] = 125LLU;

		@@ -40853,13 +40927,13 @@
40853	40927	label = 18446744073709551600LLU; // equ
40854	40928	break;
40855	40929	}
40856		- case 3446LLU: // copy-back deleter (equ to procblock)
	40930	+ case 3455LLU: // copy-back deleter (equ to procblock)
40857	40931	{
40858	40932	// copy mutable arguments back from call to equ
40859		- label = 3444LLU; // continue to roll stack
	40933	+ label = 3453LLU; // continue to roll stack
40860	40934	break;
40861	40935	}
40862		- case 3447LLU: // return from equ to procblock
	40936	+ case 3456LLU: // return from equ to procblock
40863	40937	{
40864	40938	// copy mutable arguments back from call to equ
40865	40939	// copy back results provided by call to equ

		@@ -40866,7 +40940,7 @@
40866	40940	stack[base + 20] = stack[base + 24LLU];
40867	40941	if(!stack[base + 20]/isequal/)
40868	40942	{
40869		- label = 3448LLU; // jump to alternative
	40943	+ label = 3457LLU; // jump to alternative
40870	40944	break;
40871	40945	}
40872	40946

		@@ -40873,7 +40947,7 @@
40873	40947	// consequent
40874	40948	if(!stack[base + 4]/blkresults/)
40875	40949	{
40876		- label = 3450LLU; // jump to alternative
	40950	+ label = 3459LLU; // jump to alternative
40877	40951	break;
40878	40952	}
40879	40953

		@@ -40880,9 +40954,9 @@
40880	40954	// consequent
40881	40955	fprintf(stderr, "%s", "in function ");
40882	40956	// call reportid from procblock
40883		- stack[base + 21LLU] = 3452LLU/throw to this address/;
	40957	+ stack[base + 21LLU] = 3461LLU/throw to this address/;
40884	40958	stack[base + 22LLU] = base;
40885		- stack[base + 23LLU] = 3453LLU;
	40959	+ stack[base + 23LLU] = 3462LLU;
40886	40960	// arguments for call to reportid
40887	40961	stack[base + 24LLU] = stack[base + 8]/fnid/;
40888	40962	// set stack-base & callee-address

		@@ -40890,35 +40964,35 @@
40890	40964	label = 18446744073709551586LLU; // reportid
40891	40965	break;
40892	40966	}
40893		- case 3452LLU: // copy-back deleter (reportid to procblock)
	40967	+ case 3461LLU: // copy-back deleter (reportid to procblock)
40894	40968	{
40895	40969	// copy mutable arguments back from call to reportid
40896		- label = 3444LLU; // continue to roll stack
	40970	+ label = 3453LLU; // continue to roll stack
40897	40971	break;
40898	40972	}
40899		- case 3453LLU: // return from reportid to procblock
	40973	+ case 3462LLU: // return from reportid to procblock
40900	40974	{
40901	40975	// copy mutable arguments back from call to reportid
40902	40976	fprintf(stderr, "%s", ": missing return\n");
40903	40977	{
40904		- label = 3444LLU; // throw: begin to unroll stack
	40978	+ label = 3453LLU; // throw: begin to unroll stack
40905	40979	break;
40906	40980	}
40907	40981
40908		- label = 3451LLU; // consequent complete
	40982	+ label = 3460LLU; // consequent complete
40909	40983	break;
40910	40984	}
40911		- case 3450LLU: // alternative
	40985	+ case 3459LLU: // alternative
40912	40986	{
40913		- label = 3451LLU; // alternative complete
	40987	+ label = 3460LLU; // alternative complete
40914	40988	break;
40915	40989	}
40916		- case 3451LLU: // completed if-then-else
	40990	+ case 3460LLU: // completed if-then-else
40917	40991	{
40918	40992	// call EOSbyte from procblock
40919		- stack[base + 21LLU] = 3454LLU/throw to this address/;
	40993	+ stack[base + 21LLU] = 3463LLU/throw to this address/;
40920	40994	stack[base + 22LLU] = base;
40921		- stack[base + 23LLU] = 3455LLU;
	40995	+ stack[base + 23LLU] = 3464LLU;
40922	40996	// arguments for call to EOSbyte
40923	40997	// set stack-base & callee-address
40924	40998	base += 24LLU;

		@@ -40925,26 +40999,26 @@
40925	40999	label = 77LLU; // EOSbyte
40926	41000	break;
40927	41001	}
40928		- case 3454LLU: // copy-back deleter (EOSbyte to procblock)
	41002	+ case 3463LLU: // copy-back deleter (EOSbyte to procblock)
40929	41003	{
40930	41004	// copy mutable arguments back from call to EOSbyte
40931		- label = 3444LLU; // continue to roll stack
	41005	+ label = 3453LLU; // continue to roll stack
40932	41006	break;
40933	41007	}
40934		- case 3455LLU: // return from EOSbyte to procblock
	41008	+ case 3464LLU: // return from EOSbyte to procblock
40935	41009	{
40936	41010	// copy mutable arguments back from call to EOSbyte
40937	41011	// copy back results provided by call to EOSbyte
40938	41012	stack[base + 19] = stack[base + 24LLU];
40939		- label = 3449LLU; // consequent complete
	41013	+ label = 3458LLU; // consequent complete
40940	41014	break;
40941	41015	}
40942		- case 3448LLU: // alternative
	41016	+ case 3457LLU: // alternative
40943	41017	{
40944	41018	// call ParseToken from procblock
40945		- stack[base + 21LLU] = 3456LLU/throw to this address/;
	41019	+ stack[base + 21LLU] = 3465LLU/throw to this address/;
40946	41020	stack[base + 22LLU] = base;
40947		- stack[base + 23LLU] = 3457LLU;
	41021	+ stack[base + 23LLU] = 3466LLU;
40948	41022	// arguments for call to ParseToken
40949	41023	stack[base + 26LLU] = stack[base + 19]/lookahead/;
40950	41024	// set stack-base & callee-address

		@@ -40952,14 +41026,14 @@
40952	41026	label = 3LLU; // ParseToken
40953	41027	break;
40954	41028	}
40955		- case 3456LLU: // copy-back deleter (ParseToken to procblock)
	41029	+ case 3465LLU: // copy-back deleter (ParseToken to procblock)
40956	41030	{
40957	41031	// copy mutable arguments back from call to ParseToken
40958	41032	stack[base + 19]/lookahead/ = stack[base + 26LLU];
40959		- label = 3444LLU; // continue to roll stack
	41033	+ label = 3453LLU; // continue to roll stack
40960	41034	break;
40961	41035	}
40962		- case 3457LLU: // return from ParseToken to procblock
	41036	+ case 3466LLU: // return from ParseToken to procblock
40963	41037	{
40964	41038	// copy mutable arguments back from call to ParseToken
40965	41039	stack[base + 19]/lookahead/ = stack[base + 26LLU];

		@@ -40967,9 +41041,9 @@
40967	41041	stack[base + 15] = stack[base + 24LLU];
40968	41042	stack[base + 16] = stack[base + 25LLU];
40969	41043	// call equ from procblock
40970		- stack[base + 21LLU] = 3458LLU/throw to this address/;
	41044	+ stack[base + 21LLU] = 3467LLU/throw to this address/;
40971	41045	stack[base + 22LLU] = base;
40972		- stack[base + 23LLU] = 3459LLU;
	41046	+ stack[base + 23LLU] = 3468LLU;
40973	41047	// arguments for call to equ
40974	41048	stack[base + 25LLU] = stack[base + 15]/variant/;
40975	41049	stack[base + 26LLU] = 0LLU;

		@@ -40978,13 +41052,13 @@
40978	41052	label = 18446744073709551600LLU; // equ
40979	41053	break;
40980	41054	}
40981		- case 3458LLU: // copy-back deleter (equ to procblock)
	41055	+ case 3467LLU: // copy-back deleter (equ to procblock)
40982	41056	{
40983	41057	// copy mutable arguments back from call to equ
40984		- label = 3444LLU; // continue to roll stack
	41058	+ label = 3453LLU; // continue to roll stack
40985	41059	break;
40986	41060	}
40987		- case 3459LLU: // return from equ to procblock
	41061	+ case 3468LLU: // return from equ to procblock
40988	41062	{
40989	41063	// copy mutable arguments back from call to equ
40990	41064	// copy back results provided by call to equ

		@@ -40991,15 +41065,15 @@
40991	41065	stack[base + 20] = stack[base + 24LLU];
40992	41066	if(!stack[base + 20]/isequal/)
40993	41067	{
40994		- label = 3460LLU; // jump to alternative
	41068	+ label = 3469LLU; // jump to alternative
40995	41069	break;
40996	41070	}
40997	41071
40998	41072	// consequent
40999	41073	// call equ from procblock
41000		- stack[base + 21LLU] = 3462LLU/throw to this address/;
	41074	+ stack[base + 21LLU] = 3471LLU/throw to this address/;
41001	41075	stack[base + 22LLU] = base;
41002		- stack[base + 23LLU] = 3463LLU;
	41076	+ stack[base + 23LLU] = 3472LLU;
41003	41077	// arguments for call to equ
41004	41078	stack[base + 25LLU] = stack[base + 16]/content/;
41005	41079	stack[base + 26LLU] = 123LLU;

		@@ -41008,13 +41082,13 @@
41008	41082	label = 18446744073709551600LLU; // equ
41009	41083	break;
41010	41084	}
41011		- case 3462LLU: // copy-back deleter (equ to procblock)
	41085	+ case 3471LLU: // copy-back deleter (equ to procblock)
41012	41086	{
41013	41087	// copy mutable arguments back from call to equ
41014		- label = 3444LLU; // continue to roll stack
	41088	+ label = 3453LLU; // continue to roll stack
41015	41089	break;
41016	41090	}
41017		- case 3463LLU: // return from equ to procblock
	41091	+ case 3472LLU: // return from equ to procblock
41018	41092	{
41019	41093	// copy mutable arguments back from call to equ
41020	41094	// copy back results provided by call to equ

		@@ -41021,31 +41095,31 @@
41021	41095	stack[base + 20] = stack[base + 24LLU];
41022	41096	if(!stack[base + 20]/isequal/)
41023	41097	{
41024		- label = 3464LLU; // jump to alternative
	41098	+ label = 3473LLU; // jump to alternative
41025	41099	break;
41026	41100	}
41027	41101
41028	41102	// consequent
41029		- label = 3467LLU; // skip deleter
	41103	+ label = 3476LLU; // skip deleter
41030	41104	break;
41031	41105	}
41032		- case 3466LLU: // deleter
	41106	+ case 3475LLU: // deleter
41033	41107	{
41034	41108	// throw from procblock
41035	41109	if(!stack[base + 21])
41036	41110	{
41037		- label = 3444LLU; // skip, variable already deleted/unscoped
	41111	+ label = 3453LLU; // skip, variable already deleted/unscoped
41038	41112	break;
41039	41113	}
41040	41114	// delete list
41041		- label = 3468LLU; // start to repeat
	41115	+ label = 3477LLU; // start to repeat
41042	41116	break;
41043	41117	}
41044		- case 3468LLU: // repeat from here
	41118	+ case 3477LLU: // repeat from here
41045	41119	{
41046	41120	if(!stack[base + 21])
41047	41121	{
41048		- label = 3469LLU; // break loop
	41122	+ label = 3478LLU; // break loop
41049	41123	break;
41050	41124	}
41051	41125

		@@ -41056,7 +41130,7 @@
41056	41130	newstack[0] = (uint64_t)stack; // backup stack location
41057	41131	newstack[1] = 1234567890;
41058	41132	newstack[2] = base;
41059		- newstack[3] = 3470LLU;
	41133	+ newstack[3] = 3479LLU;
41060	41134	stack = newstack;
41061	41135	// set stack-base & callee-address
41062	41136	base = 4/deloffset/;

		@@ -41063,7 +41137,7 @@
41063	41137	label = 399LLU; // ~typeidx
41064	41138	break;
41065	41139	}
41066		- case 3470LLU: // return from ~typeidx to procblock
	41140	+ case 3479LLU: // return from ~typeidx to procblock
41067	41141	{
41068	41142	stack = (uint64_t *)stack[0];
41069	41143	// releasing toplevel container

		@@ -41074,21 +41148,21 @@
41074	41148	stack[base + 21] = (uint64_t)list->next;
41075	41149	Free(1, sizeof(struct listnode), list);
41076	41150	}
41077		- label = 3468LLU; // repeat
	41151	+ label = 3477LLU; // repeat
41078	41152	break;
41079	41153	}
41080		- case 3469LLU: // loop finished
	41154	+ case 3478LLU: // loop finished
41081	41155	{
41082		- label = 3444LLU; // continue unrolling stack, delete next variable
	41156	+ label = 3453LLU; // continue unrolling stack, delete next variable
41083	41157	break;
41084	41158	}
41085		- case 3467LLU: // skipped deleter
	41159	+ case 3476LLU: // skipped deleter
41086	41160	{
41087	41161	stack[base + 21] = 0;
41088	41162	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
41089	41163	if(!newstack)
41090	41164	{
41091		- label = 3466LLU; // throw: begin to unroll stack
	41165	+ label = 3475LLU; // throw: begin to unroll stack
41092	41166	break;
41093	41167	}
41094	41168

		@@ -41095,9 +41169,9 @@
41095	41169	newstack[160LLU] = 9876543210LLU; // overflow-marker
41096	41170	// call procblock from procblock
41097	41171	newstack[0] = (uint64_t)stack; // backup stack location
41098		- newstack[1] = 3471LLU;
	41172	+ newstack[1] = 3480LLU;
41099	41173	newstack[2] = base;
41100		- newstack[3] = 3472LLU;
	41174	+ newstack[3] = 3481LLU;
41101	41175	// arguments for call to procblock
41102	41176	newstack[4LLU] = stack[base + 0]/fndefs/;
41103	41177	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -41120,10 +41194,10 @@
41120	41194	stack = newstack;
41121	41195	// set stack-base & callee-address
41122	41196	base = 4/deloffset/;
41123		- label = 3429LLU; // procblock
	41197	+ label = 3438LLU; // procblock
41124	41198	break;
41125	41199	}
41126		- case 3471LLU: // copy-back deleter (procblock to procblock)
	41200	+ case 3480LLU: // copy-back deleter (procblock to procblock)
41127	41201	{
41128	41202	uint64_t oldstack = (uint64_t )stack[0];
41129	41203	// copy mutable arguments back from call to procblock

		@@ -41140,10 +41214,10 @@
41140	41214	}
41141	41215	Free(160LLU + 1, sizeof(uint64_t), stack);
41142	41216	stack = oldstack;
41143		- label = 3466LLU; // continue to unroll stack
	41217	+ label = 3475LLU; // continue to unroll stack
41144	41218	break;
41145	41219	}
41146		- case 3472LLU: // return from procblock to procblock
	41220	+ case 3481LLU: // return from procblock to procblock
41147	41221	{
41148	41222	uint64_t oldstack = (uint64_t )stack[0];
41149	41223	// copy mutable arguments back from call to procblock

		@@ -41161,14 +41235,14 @@
41161	41235	Free(160LLU + 1, sizeof(uint64_t), stack);
41162	41236	stack = oldstack;
41163	41237	// delete list
41164		- label = 3473LLU; // start to repeat
	41238	+ label = 3482LLU; // start to repeat
41165	41239	break;
41166	41240	}
41167		- case 3473LLU: // repeat from here
	41241	+ case 3482LLU: // repeat from here
41168	41242	{
41169	41243	if(!stack[base + 21])
41170	41244	{
41171		- label = 3474LLU; // break loop
	41245	+ label = 3483LLU; // break loop
41172	41246	break;
41173	41247	}
41174	41248

		@@ -41179,7 +41253,7 @@
41179	41253	newstack[0] = (uint64_t)stack; // backup stack location
41180	41254	newstack[1] = 1234567890;
41181	41255	newstack[2] = base;
41182		- newstack[3] = 3475LLU;
	41256	+ newstack[3] = 3484LLU;
41183	41257	stack = newstack;
41184	41258	// set stack-base & callee-address
41185	41259	base = 4/deloffset/;

		@@ -41186,7 +41260,7 @@
41186	41260	label = 399LLU; // ~typeidx
41187	41261	break;
41188	41262	}
41189		- case 3475LLU: // return from ~typeidx to procblock
	41263	+ case 3484LLU: // return from ~typeidx to procblock
41190	41264	{
41191	41265	stack = (uint64_t *)stack[0];
41192	41266	// releasing toplevel container

		@@ -41197,20 +41271,20 @@
41197	41271	stack[base + 21] = (uint64_t)list->next;
41198	41272	Free(1, sizeof(struct listnode), list);
41199	41273	}
41200		- label = 3473LLU; // repeat
	41274	+ label = 3482LLU; // repeat
41201	41275	break;
41202	41276	}
41203		- case 3474LLU: // loop finished
	41277	+ case 3483LLU: // loop finished
41204	41278	{
41205		- label = 3465LLU; // consequent complete
	41279	+ label = 3474LLU; // consequent complete
41206	41280	break;
41207	41281	}
41208		- case 3464LLU: // alternative
	41282	+ case 3473LLU: // alternative
41209	41283	{
41210	41284	// call equ from procblock
41211		- stack[base + 21LLU] = 3476LLU/throw to this address/;
	41285	+ stack[base + 21LLU] = 3485LLU/throw to this address/;
41212	41286	stack[base + 22LLU] = base;
41213		- stack[base + 23LLU] = 3477LLU;
	41287	+ stack[base + 23LLU] = 3486LLU;
41214	41288	// arguments for call to equ
41215	41289	stack[base + 25LLU] = stack[base + 16]/content/;
41216	41290	stack[base + 26LLU] = 96LLU;

		@@ -41219,13 +41293,13 @@
41219	41293	label = 18446744073709551600LLU; // equ
41220	41294	break;
41221	41295	}
41222		- case 3476LLU: // copy-back deleter (equ to procblock)
	41296	+ case 3485LLU: // copy-back deleter (equ to procblock)
41223	41297	{
41224	41298	// copy mutable arguments back from call to equ
41225		- label = 3444LLU; // continue to roll stack
	41299	+ label = 3453LLU; // continue to roll stack
41226	41300	break;
41227	41301	}
41228		- case 3477LLU: // return from equ to procblock
	41302	+ case 3486LLU: // return from equ to procblock
41229	41303	{
41230	41304	// copy mutable arguments back from call to equ
41231	41305	// copy back results provided by call to equ

		@@ -41232,15 +41306,15 @@
41232	41306	stack[base + 20] = stack[base + 24LLU];
41233	41307	if(!stack[base + 20]/isequal/)
41234	41308	{
41235		- label = 3478LLU; // jump to alternative
	41309	+ label = 3487LLU; // jump to alternative
41236	41310	break;
41237	41311	}
41238	41312
41239	41313	// consequent
41240	41314	// call verbatim from procblock
41241		- stack[base + 21LLU] = 3480LLU/throw to this address/;
	41315	+ stack[base + 21LLU] = 3489LLU/throw to this address/;
41242	41316	stack[base + 22LLU] = base;
41243		- stack[base + 23LLU] = 3481LLU;
	41317	+ stack[base + 23LLU] = 3490LLU;
41244	41318	// arguments for call to verbatim
41245	41319	stack[base + 24LLU] = stack[base + 2]/scopes/;
41246	41320	stack[base + 25LLU] = stack[base + 3]/scope/;

		@@ -41247,29 +41321,29 @@
41247	41321	stack[base + 26LLU] = stack[base + 19]/lookahead/;
41248	41322	// set stack-base & callee-address
41249	41323	base += 24LLU;
41250		- label = 3245LLU; // verbatim
	41324	+ label = 3254LLU; // verbatim
41251	41325	break;
41252	41326	}
41253		- case 3480LLU: // copy-back deleter (verbatim to procblock)
	41327	+ case 3489LLU: // copy-back deleter (verbatim to procblock)
41254	41328	{
41255	41329	// copy mutable arguments back from call to verbatim
41256	41330	stack[base + 19]/lookahead/ = stack[base + 26LLU];
41257		- label = 3444LLU; // continue to roll stack
	41331	+ label = 3453LLU; // continue to roll stack
41258	41332	break;
41259	41333	}
41260		- case 3481LLU: // return from verbatim to procblock
	41334	+ case 3490LLU: // return from verbatim to procblock
41261	41335	{
41262	41336	// copy mutable arguments back from call to verbatim
41263	41337	stack[base + 19]/lookahead/ = stack[base + 26LLU];
41264		- label = 3479LLU; // consequent complete
	41338	+ label = 3488LLU; // consequent complete
41265	41339	break;
41266	41340	}
41267		- case 3478LLU: // alternative
	41341	+ case 3487LLU: // alternative
41268	41342	{
41269	41343	// call equ from procblock
41270		- stack[base + 21LLU] = 3482LLU/throw to this address/;
	41344	+ stack[base + 21LLU] = 3491LLU/throw to this address/;
41271	41345	stack[base + 22LLU] = base;
41272		- stack[base + 23LLU] = 3483LLU;
	41346	+ stack[base + 23LLU] = 3492LLU;
41273	41347	// arguments for call to equ
41274	41348	stack[base + 25LLU] = stack[base + 16]/content/;
41275	41349	stack[base + 26LLU] = 40LLU;

		@@ -41278,13 +41352,13 @@
41278	41352	label = 18446744073709551600LLU; // equ
41279	41353	break;
41280	41354	}
41281		- case 3482LLU: // copy-back deleter (equ to procblock)
	41355	+ case 3491LLU: // copy-back deleter (equ to procblock)
41282	41356	{
41283	41357	// copy mutable arguments back from call to equ
41284		- label = 3444LLU; // continue to roll stack
	41358	+ label = 3453LLU; // continue to roll stack
41285	41359	break;
41286	41360	}
41287		- case 3483LLU: // return from equ to procblock
	41361	+ case 3492LLU: // return from equ to procblock
41288	41362	{
41289	41363	// copy mutable arguments back from call to equ
41290	41364	// copy back results provided by call to equ

		@@ -41291,15 +41365,15 @@
41291	41365	stack[base + 20] = stack[base + 24LLU];
41292	41366	if(!stack[base + 20]/isequal/)
41293	41367	{
41294		- label = 3484LLU; // jump to alternative
	41368	+ label = 3493LLU; // jump to alternative
41295	41369	break;
41296	41370	}
41297	41371
41298	41372	// consequent
41299	41373	// call PROCCALL from procblock
41300		- stack[base + 21LLU] = 3486LLU/throw to this address/;
	41374	+ stack[base + 21LLU] = 3495LLU/throw to this address/;
41301	41375	stack[base + 22LLU] = base;
41302		- stack[base + 23LLU] = 3487LLU;
	41376	+ stack[base + 23LLU] = 3496LLU;
41303	41377	// arguments for call to PROCCALL
41304	41378	stack[base + 24LLU] = stack[base + 0]/fndefs/;
41305	41379	stack[base + 25LLU] = stack[base + 2]/scopes/;

		@@ -41322,7 +41396,7 @@
41322	41396	label = 2930LLU; // PROCCALL
41323	41397	break;
41324	41398	}
41325		- case 3486LLU: // copy-back deleter (PROCCALL to procblock)
	41399	+ case 3495LLU: // copy-back deleter (PROCCALL to procblock)
41326	41400	{
41327	41401	// copy mutable arguments back from call to PROCCALL
41328	41402	stack[base + 17]/label/ = stack[base + 39LLU];

		@@ -41330,10 +41404,10 @@
41330	41404	stack[base + 15]/variant/ = stack[base + 37LLU];
41331	41405	stack[base + 19]/lookahead/ = stack[base + 36LLU];
41332	41406	stack[base + 12]/fnmaxcount/ = stack[base + 35LLU];
41333		- label = 3444LLU; // continue to roll stack
	41407	+ label = 3453LLU; // continue to roll stack
41334	41408	break;
41335	41409	}
41336		- case 3487LLU: // return from PROCCALL to procblock
	41410	+ case 3496LLU: // return from PROCCALL to procblock
41337	41411	{
41338	41412	// copy mutable arguments back from call to PROCCALL
41339	41413	stack[base + 17]/label/ = stack[base + 39LLU];

		@@ -41342,9 +41416,9 @@
41342	41416	stack[base + 19]/lookahead/ = stack[base + 36LLU];
41343	41417	stack[base + 12]/fnmaxcount/ = stack[base + 35LLU];
41344	41418	// call DELIMITER from procblock
41345		- stack[base + 21LLU] = 3488LLU/throw to this address/;
	41419	+ stack[base + 21LLU] = 3497LLU/throw to this address/;
41346	41420	stack[base + 22LLU] = base;
41347		- stack[base + 23LLU] = 3489LLU;
	41421	+ stack[base + 23LLU] = 3498LLU;
41348	41422	// arguments for call to DELIMITER
41349	41423	stack[base + 24LLU] = stack[base + 8]/fnid/;
41350	41424	stack[base + 25LLU] = stack[base + 19]/lookahead/;

		@@ -41353,27 +41427,27 @@
41353	41427	label = 17LLU; // DELIMITER
41354	41428	break;
41355	41429	}
41356		- case 3488LLU: // copy-back deleter (DELIMITER to procblock)
	41430	+ case 3497LLU: // copy-back deleter (DELIMITER to procblock)
41357	41431	{
41358	41432	// copy mutable arguments back from call to DELIMITER
41359	41433	stack[base + 19]/lookahead/ = stack[base + 25LLU];
41360		- label = 3444LLU; // continue to roll stack
	41434	+ label = 3453LLU; // continue to roll stack
41361	41435	break;
41362	41436	}
41363		- case 3489LLU: // return from DELIMITER to procblock
	41437	+ case 3498LLU: // return from DELIMITER to procblock
41364	41438	{
41365	41439	// copy mutable arguments back from call to DELIMITER
41366	41440	stack[base + 19]/lookahead/ = stack[base + 25LLU];
41367		- label = 3485LLU; // consequent complete
	41441	+ label = 3494LLU; // consequent complete
41368	41442	break;
41369	41443	}
41370		- case 3484LLU: // alternative
	41444	+ case 3493LLU: // alternative
41371	41445	{
41372	41446	fprintf(stderr, "%s", "parsing block unexpected token ");
41373	41447	// call reporttok from procblock
41374		- stack[base + 21LLU] = 3490LLU/throw to this address/;
	41448	+ stack[base + 21LLU] = 3499LLU/throw to this address/;
41375	41449	stack[base + 22LLU] = base;
41376		- stack[base + 23LLU] = 3491LLU;
	41450	+ stack[base + 23LLU] = 3500LLU;
41377	41451	// arguments for call to reporttok
41378	41452	stack[base + 24LLU] = stack[base + 15]/variant/;
41379	41453	stack[base + 25LLU] = stack[base + 16]/content/;

		@@ -41382,45 +41456,45 @@
41382	41456	label = 18446744073709551582LLU; // reporttok
41383	41457	break;
41384	41458	}
41385		- case 3490LLU: // copy-back deleter (reporttok to procblock)
	41459	+ case 3499LLU: // copy-back deleter (reporttok to procblock)
41386	41460	{
41387	41461	// copy mutable arguments back from call to reporttok
41388		- label = 3444LLU; // continue to roll stack
	41462	+ label = 3453LLU; // continue to roll stack
41389	41463	break;
41390	41464	}
41391		- case 3491LLU: // return from reporttok to procblock
	41465	+ case 3500LLU: // return from reporttok to procblock
41392	41466	{
41393	41467	// copy mutable arguments back from call to reporttok
41394	41468	fprintf(stderr, "%s", "\n");
41395	41469	{
41396		- label = 3444LLU; // throw: begin to unroll stack
	41470	+ label = 3453LLU; // throw: begin to unroll stack
41397	41471	break;
41398	41472	}
41399	41473
41400		- label = 3485LLU; // alternative complete
	41474	+ label = 3494LLU; // alternative complete
41401	41475	break;
41402	41476	}
41403		- case 3485LLU: // completed if-then-else
	41477	+ case 3494LLU: // completed if-then-else
41404	41478	{
41405		- label = 3479LLU; // alternative complete
	41479	+ label = 3488LLU; // alternative complete
41406	41480	break;
41407	41481	}
41408		- case 3479LLU: // completed if-then-else
	41482	+ case 3488LLU: // completed if-then-else
41409	41483	{
41410		- label = 3465LLU; // alternative complete
	41484	+ label = 3474LLU; // alternative complete
41411	41485	break;
41412	41486	}
41413		- case 3465LLU: // completed if-then-else
	41487	+ case 3474LLU: // completed if-then-else
41414	41488	{
41415		- label = 3461LLU; // consequent complete
	41489	+ label = 3470LLU; // consequent complete
41416	41490	break;
41417	41491	}
41418		- case 3460LLU: // alternative
	41492	+ case 3469LLU: // alternative
41419	41493	{
41420	41494	// call equ from procblock
41421		- stack[base + 21LLU] = 3492LLU/throw to this address/;
	41495	+ stack[base + 21LLU] = 3501LLU/throw to this address/;
41422	41496	stack[base + 22LLU] = base;
41423		- stack[base + 23LLU] = 3493LLU;
	41497	+ stack[base + 23LLU] = 3502LLU;
41424	41498	// arguments for call to equ
41425	41499	stack[base + 25LLU] = stack[base + 15]/variant/;
41426	41500	stack[base + 26LLU] = 4LLU;

		@@ -41429,13 +41503,13 @@
41429	41503	label = 18446744073709551600LLU; // equ
41430	41504	break;
41431	41505	}
41432		- case 3492LLU: // copy-back deleter (equ to procblock)
	41506	+ case 3501LLU: // copy-back deleter (equ to procblock)
41433	41507	{
41434	41508	// copy mutable arguments back from call to equ
41435		- label = 3444LLU; // continue to roll stack
	41509	+ label = 3453LLU; // continue to roll stack
41436	41510	break;
41437	41511	}
41438		- case 3493LLU: // return from equ to procblock
	41512	+ case 3502LLU: // return from equ to procblock
41439	41513	{
41440	41514	// copy mutable arguments back from call to equ
41441	41515	// copy back results provided by call to equ

		@@ -41442,31 +41516,31 @@
41442	41516	stack[base + 20] = stack[base + 24LLU];
41443	41517	if(!stack[base + 20]/isequal/)
41444	41518	{
41445		- label = 3494LLU; // jump to alternative
	41519	+ label = 3503LLU; // jump to alternative
41446	41520	break;
41447	41521	}
41448	41522
41449	41523	// consequent
41450		- label = 3497LLU; // skip deleter
	41524	+ label = 3506LLU; // skip deleter
41451	41525	break;
41452	41526	}
41453		- case 3496LLU: // deleter
	41527	+ case 3505LLU: // deleter
41454	41528	{
41455	41529	// throw from procblock
41456	41530	if(!stack[base + 21])
41457	41531	{
41458		- label = 3444LLU; // skip, variable already deleted/unscoped
	41532	+ label = 3453LLU; // skip, variable already deleted/unscoped
41459	41533	break;
41460	41534	}
41461		- label = 3444LLU; // continue unrolling stack, delete next variable
	41535	+ label = 3453LLU; // continue unrolling stack, delete next variable
41462	41536	break;
41463	41537	}
41464		- case 3497LLU: // skipped deleter
	41538	+ case 3506LLU: // skipped deleter
41465	41539	{
41466	41540	// call equ from procblock
41467		- stack[base + 22LLU] = 3498LLU/throw to this address/;
	41541	+ stack[base + 22LLU] = 3507LLU/throw to this address/;
41468	41542	stack[base + 23LLU] = base;
41469		- stack[base + 24LLU] = 3499LLU;
	41543	+ stack[base + 24LLU] = 3508LLU;
41470	41544	// arguments for call to equ
41471	41545	stack[base + 26LLU] = stack[base + 16]/content/;
41472	41546	stack[base + 27LLU] = 819865187908583424LLU;

		@@ -41475,13 +41549,13 @@
41475	41549	label = 18446744073709551600LLU; // equ
41476	41550	break;
41477	41551	}
41478		- case 3498LLU: // copy-back deleter (equ to procblock)
	41552	+ case 3507LLU: // copy-back deleter (equ to procblock)
41479	41553	{
41480	41554	// copy mutable arguments back from call to equ
41481		- label = 3444LLU; // continue to roll stack
	41555	+ label = 3453LLU; // continue to roll stack
41482	41556	break;
41483	41557	}
41484		- case 3499LLU: // return from equ to procblock
	41558	+ case 3508LLU: // return from equ to procblock
41485	41559	{
41486	41560	// copy mutable arguments back from call to equ
41487	41561	// copy back results provided by call to equ

		@@ -41488,15 +41562,15 @@
41488	41562	stack[base + 21] = stack[base + 25LLU];
41489	41563	if(!stack[base + 21]/returnflag/)
41490	41564	{
41491		- label = 3500LLU; // jump to alternative
	41565	+ label = 3509LLU; // jump to alternative
41492	41566	break;
41493	41567	}
41494	41568
41495	41569	// consequent
41496	41570	// call ParseToken from procblock
41497		- stack[base + 22LLU] = 3502LLU/throw to this address/;
	41571	+ stack[base + 22LLU] = 3511LLU/throw to this address/;
41498	41572	stack[base + 23LLU] = base;
41499		- stack[base + 24LLU] = 3503LLU;
	41573	+ stack[base + 24LLU] = 3512LLU;
41500	41574	// arguments for call to ParseToken
41501	41575	stack[base + 27LLU] = stack[base + 19]/lookahead/;
41502	41576	// set stack-base & callee-address

		@@ -41504,14 +41578,14 @@
41504	41578	label = 3LLU; // ParseToken
41505	41579	break;
41506	41580	}
41507		- case 3502LLU: // copy-back deleter (ParseToken to procblock)
	41581	+ case 3511LLU: // copy-back deleter (ParseToken to procblock)
41508	41582	{
41509	41583	// copy mutable arguments back from call to ParseToken
41510	41584	stack[base + 19]/lookahead/ = stack[base + 27LLU];
41511		- label = 3496LLU; // continue to roll stack
	41585	+ label = 3505LLU; // continue to roll stack
41512	41586	break;
41513	41587	}
41514		- case 3503LLU: // return from ParseToken to procblock
	41588	+ case 3512LLU: // return from ParseToken to procblock
41515	41589	{
41516	41590	// copy mutable arguments back from call to ParseToken
41517	41591	stack[base + 19]/lookahead/ = stack[base + 27LLU];

		@@ -41519,9 +41593,9 @@
41519	41593	stack[base + 15] = stack[base + 25LLU];
41520	41594	stack[base + 16] = stack[base + 26LLU];
41521	41595	// call neq from procblock
41522		- stack[base + 22LLU] = 3504LLU/throw to this address/;
	41596	+ stack[base + 22LLU] = 3513LLU/throw to this address/;
41523	41597	stack[base + 23LLU] = base;
41524		- stack[base + 24LLU] = 3505LLU;
	41598	+ stack[base + 24LLU] = 3514LLU;
41525	41599	// arguments for call to neq
41526	41600	stack[base + 26LLU] = stack[base + 16]/content/;
41527	41601	stack[base + 27LLU] = 657807020572803072LLU;

		@@ -41530,13 +41604,13 @@
41530	41604	label = 18446744073709551599LLU; // neq
41531	41605	break;
41532	41606	}
41533		- case 3504LLU: // copy-back deleter (neq to procblock)
	41607	+ case 3513LLU: // copy-back deleter (neq to procblock)
41534	41608	{
41535	41609	// copy mutable arguments back from call to neq
41536		- label = 3496LLU; // continue to roll stack
	41610	+ label = 3505LLU; // continue to roll stack
41537	41611	break;
41538	41612	}
41539		- case 3505LLU: // return from neq to procblock
	41613	+ case 3514LLU: // return from neq to procblock
41540	41614	{
41541	41615	// copy mutable arguments back from call to neq
41542	41616	// copy back results provided by call to neq

		@@ -41543,15 +41617,15 @@
41543	41617	stack[base + 20] = stack[base + 25LLU];
41544	41618	if(!stack[base + 20]/isequal/)
41545	41619	{
41546		- label = 3506LLU; // jump to alternative
	41620	+ label = 3515LLU; // jump to alternative
41547	41621	break;
41548	41622	}
41549	41623
41550	41624	// consequent
41551	41625	// call neq from procblock
41552		- stack[base + 22LLU] = 3508LLU/throw to this address/;
	41626	+ stack[base + 22LLU] = 3517LLU/throw to this address/;
41553	41627	stack[base + 23LLU] = base;
41554		- stack[base + 24LLU] = 3509LLU;
	41628	+ stack[base + 24LLU] = 3518LLU;
41555	41629	// arguments for call to neq
41556	41630	stack[base + 26LLU] = stack[base + 16]/content/;
41557	41631	stack[base + 27LLU] = 842897672560967680LLU;

		@@ -41560,13 +41634,13 @@
41560	41634	label = 18446744073709551599LLU; // neq
41561	41635	break;
41562	41636	}
41563		- case 3508LLU: // copy-back deleter (neq to procblock)
	41637	+ case 3517LLU: // copy-back deleter (neq to procblock)
41564	41638	{
41565	41639	// copy mutable arguments back from call to neq
41566		- label = 3496LLU; // continue to roll stack
	41640	+ label = 3505LLU; // continue to roll stack
41567	41641	break;
41568	41642	}
41569		- case 3509LLU: // return from neq to procblock
	41643	+ case 3518LLU: // return from neq to procblock
41570	41644	{
41571	41645	// copy mutable arguments back from call to neq
41572	41646	// copy back results provided by call to neq

		@@ -41573,15 +41647,15 @@
41573	41647	stack[base + 20] = stack[base + 25LLU];
41574	41648	if(!stack[base + 20]/isequal/)
41575	41649	{
41576		- label = 3510LLU; // jump to alternative
	41650	+ label = 3519LLU; // jump to alternative
41577	41651	break;
41578	41652	}
41579	41653
41580	41654	// consequent
41581	41655	// call neq from procblock
41582		- stack[base + 22LLU] = 3512LLU/throw to this address/;
	41656	+ stack[base + 22LLU] = 3521LLU/throw to this address/;
41583	41657	stack[base + 23LLU] = base;
41584		- stack[base + 24LLU] = 3513LLU;
	41658	+ stack[base + 24LLU] = 3522LLU;
41585	41659	// arguments for call to neq
41586	41660	stack[base + 26LLU] = stack[base + 16]/content/;
41587	41661	stack[base + 27LLU] = 859571802316210176LLU;

		@@ -41590,59 +41664,59 @@
41590	41664	label = 18446744073709551599LLU; // neq
41591	41665	break;
41592	41666	}
41593		- case 3512LLU: // copy-back deleter (neq to procblock)
	41667	+ case 3521LLU: // copy-back deleter (neq to procblock)
41594	41668	{
41595	41669	// copy mutable arguments back from call to neq
41596		- label = 3496LLU; // continue to roll stack
	41670	+ label = 3505LLU; // continue to roll stack
41597	41671	break;
41598	41672	}
41599		- case 3513LLU: // return from neq to procblock
	41673	+ case 3522LLU: // return from neq to procblock
41600	41674	{
41601	41675	// copy mutable arguments back from call to neq
41602	41676	// copy back results provided by call to neq
41603	41677	stack[base + 20] = stack[base + 25LLU];
41604		- label = 3511LLU; // consequent complete
	41678	+ label = 3520LLU; // consequent complete
41605	41679	break;
41606	41680	}
41607		- case 3510LLU: // alternative
	41681	+ case 3519LLU: // alternative
41608	41682	{
41609		- label = 3511LLU; // alternative complete
	41683	+ label = 3520LLU; // alternative complete
41610	41684	break;
41611	41685	}
41612		- case 3511LLU: // completed if-then-else
	41686	+ case 3520LLU: // completed if-then-else
41613	41687	{
41614		- label = 3507LLU; // consequent complete
	41688	+ label = 3516LLU; // consequent complete
41615	41689	break;
41616	41690	}
41617		- case 3506LLU: // alternative
	41691	+ case 3515LLU: // alternative
41618	41692	{
41619		- label = 3507LLU; // alternative complete
	41693	+ label = 3516LLU; // alternative complete
41620	41694	break;
41621	41695	}
41622		- case 3507LLU: // completed if-then-else
	41696	+ case 3516LLU: // completed if-then-else
41623	41697	{
41624		- label = 3501LLU; // consequent complete
	41698	+ label = 3510LLU; // consequent complete
41625	41699	break;
41626	41700	}
41627		- case 3500LLU: // alternative
	41701	+ case 3509LLU: // alternative
41628	41702	{
41629	41703	stack[base + 20]/isequal/ = 0;
41630		- label = 3501LLU; // alternative complete
	41704	+ label = 3510LLU; // alternative complete
41631	41705	break;
41632	41706	}
41633		- case 3501LLU: // completed if-then-else
	41707	+ case 3510LLU: // completed if-then-else
41634	41708	{
41635	41709	if(!stack[base + 20]/isequal/)
41636	41710	{
41637		- label = 3514LLU; // jump to alternative
	41711	+ label = 3523LLU; // jump to alternative
41638	41712	break;
41639	41713	}
41640	41714
41641	41715	// consequent
41642	41716	// call issimple from procblock
41643		- stack[base + 22LLU] = 3516LLU/throw to this address/;
	41717	+ stack[base + 22LLU] = 3525LLU/throw to this address/;
41644	41718	stack[base + 23LLU] = base;
41645		- stack[base + 24LLU] = 3517LLU;
	41719	+ stack[base + 24LLU] = 3526LLU;
41646	41720	// arguments for call to issimple
41647	41721	stack[base + 26LLU] = stack[base + 15]/variant/;
41648	41722	stack[base + 27LLU] = stack[base + 16]/content/;

		@@ -41652,13 +41726,13 @@
41652	41726	label = 166LLU; // issimple
41653	41727	break;
41654	41728	}
41655		- case 3516LLU: // copy-back deleter (issimple to procblock)
	41729	+ case 3525LLU: // copy-back deleter (issimple to procblock)
41656	41730	{
41657	41731	// copy mutable arguments back from call to issimple
41658		- label = 3496LLU; // continue to roll stack
	41732	+ label = 3505LLU; // continue to roll stack
41659	41733	break;
41660	41734	}
41661		- case 3517LLU: // return from issimple to procblock
	41735	+ case 3526LLU: // return from issimple to procblock
41662	41736	{
41663	41737	// copy mutable arguments back from call to issimple
41664	41738	// copy back results provided by call to issimple

		@@ -41665,15 +41739,15 @@
41665	41739	stack[base + 20] = stack[base + 25LLU];
41666	41740	if(!stack[base + 20]/isequal/)
41667	41741	{
41668		- label = 3518LLU; // jump to alternative
	41742	+ label = 3527LLU; // jump to alternative
41669	41743	break;
41670	41744	}
41671	41745
41672	41746	// consequent
41673	41747	// call verbatim from procblock
41674		- stack[base + 22LLU] = 3520LLU/throw to this address/;
	41748	+ stack[base + 22LLU] = 3529LLU/throw to this address/;
41675	41749	stack[base + 23LLU] = base;
41676		- stack[base + 24LLU] = 3521LLU;
	41750	+ stack[base + 24LLU] = 3530LLU;
41677	41751	// arguments for call to verbatim
41678	41752	stack[base + 25LLU] = stack[base + 2]/scopes/;
41679	41753	stack[base + 26LLU] = stack[base + 3]/scope/;

		@@ -41680,29 +41754,29 @@
41680	41754	stack[base + 27LLU] = stack[base + 19]/lookahead/;
41681	41755	// set stack-base & callee-address
41682	41756	base += 25LLU;
41683		- label = 3245LLU; // verbatim
	41757	+ label = 3254LLU; // verbatim
41684	41758	break;
41685	41759	}
41686		- case 3520LLU: // copy-back deleter (verbatim to procblock)
	41760	+ case 3529LLU: // copy-back deleter (verbatim to procblock)
41687	41761	{
41688	41762	// copy mutable arguments back from call to verbatim
41689	41763	stack[base + 19]/lookahead/ = stack[base + 27LLU];
41690		- label = 3496LLU; // continue to roll stack
	41764	+ label = 3505LLU; // continue to roll stack
41691	41765	break;
41692	41766	}
41693		- case 3521LLU: // return from verbatim to procblock
	41767	+ case 3530LLU: // return from verbatim to procblock
41694	41768	{
41695	41769	// copy mutable arguments back from call to verbatim
41696	41770	stack[base + 19]/lookahead/ = stack[base + 27LLU];
41697		- label = 3519LLU; // consequent complete
	41771	+ label = 3528LLU; // consequent complete
41698	41772	break;
41699	41773	}
41700		- case 3518LLU: // alternative
	41774	+ case 3527LLU: // alternative
41701	41775	{
41702	41776	// call PROCRETURN from procblock
41703		- stack[base + 22LLU] = 3522LLU/throw to this address/;
	41777	+ stack[base + 22LLU] = 3531LLU/throw to this address/;
41704	41778	stack[base + 23LLU] = base;
41705		- stack[base + 24LLU] = 3523LLU;
	41779	+ stack[base + 24LLU] = 3532LLU;
41706	41780	// arguments for call to PROCRETURN
41707	41781	stack[base + 25LLU] = stack[base + 0]/fndefs/;
41708	41782	stack[base + 26LLU] = stack[base + 1]/datadefs/;

		@@ -41727,7 +41801,7 @@
41727	41801	label = 2812LLU; // PROCRETURN
41728	41802	break;
41729	41803	}
41730		- case 3522LLU: // copy-back deleter (PROCRETURN to procblock)
	41804	+ case 3531LLU: // copy-back deleter (PROCRETURN to procblock)
41731	41805	{
41732	41806	// copy mutable arguments back from call to PROCRETURN
41733	41807	stack[base + 17]/label/ = stack[base + 42LLU];

		@@ -41736,10 +41810,10 @@
41736	41810	stack[base + 19]/lookahead/ = stack[base + 39LLU];
41737	41811	stack[base + 12]/fnmaxcount/ = stack[base + 38LLU];
41738	41812	stack[base + 3]/scope/ = stack[base + 28LLU];
41739		- label = 3496LLU; // continue to roll stack
	41813	+ label = 3505LLU; // continue to roll stack
41740	41814	break;
41741	41815	}
41742		- case 3523LLU: // return from PROCRETURN to procblock
	41816	+ case 3532LLU: // return from PROCRETURN to procblock
41743	41817	{
41744	41818	// copy mutable arguments back from call to PROCRETURN
41745	41819	stack[base + 17]/label/ = stack[base + 42LLU];

		@@ -41748,15 +41822,15 @@
41748	41822	stack[base + 19]/lookahead/ = stack[base + 39LLU];
41749	41823	stack[base + 12]/fnmaxcount/ = stack[base + 38LLU];
41750	41824	stack[base + 3]/scope/ = stack[base + 28LLU];
41751		- label = 3519LLU; // alternative complete
	41825	+ label = 3528LLU; // alternative complete
41752	41826	break;
41753	41827	}
41754		- case 3519LLU: // completed if-then-else
	41828	+ case 3528LLU: // completed if-then-else
41755	41829	{
41756	41830	// call MATCHPEEK from procblock
41757		- stack[base + 22LLU] = 3524LLU/throw to this address/;
	41831	+ stack[base + 22LLU] = 3533LLU/throw to this address/;
41758	41832	stack[base + 23LLU] = base;
41759		- stack[base + 24LLU] = 3525LLU;
	41833	+ stack[base + 24LLU] = 3534LLU;
41760	41834	// arguments for call to MATCHPEEK
41761	41835	stack[base + 25LLU] = stack[base + 8]/fnid/;
41762	41836	stack[base + 26LLU] = 125LLU;

		@@ -41766,21 +41840,21 @@
41766	41840	label = 206LLU; // MATCHPEEK
41767	41841	break;
41768	41842	}
41769		- case 3524LLU: // copy-back deleter (MATCHPEEK to procblock)
	41843	+ case 3533LLU: // copy-back deleter (MATCHPEEK to procblock)
41770	41844	{
41771	41845	// copy mutable arguments back from call to MATCHPEEK
41772	41846	stack[base + 19]/lookahead/ = stack[base + 27LLU];
41773		- label = 3496LLU; // continue to roll stack
	41847	+ label = 3505LLU; // continue to roll stack
41774	41848	break;
41775	41849	}
41776		- case 3525LLU: // return from MATCHPEEK to procblock
	41850	+ case 3534LLU: // return from MATCHPEEK to procblock
41777	41851	{
41778	41852	// copy mutable arguments back from call to MATCHPEEK
41779	41853	stack[base + 19]/lookahead/ = stack[base + 27LLU];
41780	41854	// call EOSbyte from procblock
41781		- stack[base + 22LLU] = 3526LLU/throw to this address/;
	41855	+ stack[base + 22LLU] = 3535LLU/throw to this address/;
41782	41856	stack[base + 23LLU] = base;
41783		- stack[base + 24LLU] = 3527LLU;
	41857	+ stack[base + 24LLU] = 3536LLU;
41784	41858	// arguments for call to EOSbyte
41785	41859	// set stack-base & callee-address
41786	41860	base += 25LLU;

		@@ -41787,42 +41861,42 @@
41787	41861	label = 77LLU; // EOSbyte
41788	41862	break;
41789	41863	}
41790		- case 3526LLU: // copy-back deleter (EOSbyte to procblock)
	41864	+ case 3535LLU: // copy-back deleter (EOSbyte to procblock)
41791	41865	{
41792	41866	// copy mutable arguments back from call to EOSbyte
41793		- label = 3496LLU; // continue to roll stack
	41867	+ label = 3505LLU; // continue to roll stack
41794	41868	break;
41795	41869	}
41796		- case 3527LLU: // return from EOSbyte to procblock
	41870	+ case 3536LLU: // return from EOSbyte to procblock
41797	41871	{
41798	41872	// copy mutable arguments back from call to EOSbyte
41799	41873	// copy back results provided by call to EOSbyte
41800	41874	stack[base + 19] = stack[base + 25LLU];
41801		- label = 3515LLU; // consequent complete
	41875	+ label = 3524LLU; // consequent complete
41802	41876	break;
41803	41877	}
41804		- case 3514LLU: // alternative
	41878	+ case 3523LLU: // alternative
41805	41879	{
41806		- label = 3529LLU; // skip deleter
	41880	+ label = 3538LLU; // skip deleter
41807	41881	break;
41808	41882	}
41809		- case 3528LLU: // deleter
	41883	+ case 3537LLU: // deleter
41810	41884	{
41811	41885	// throw from procblock
41812	41886	if(!stack[base + 22])
41813	41887	{
41814		- label = 3496LLU; // skip, variable already deleted/unscoped
	41888	+ label = 3505LLU; // skip, variable already deleted/unscoped
41815	41889	break;
41816	41890	}
41817		- label = 3496LLU; // continue unrolling stack, delete next variable
	41891	+ label = 3505LLU; // continue unrolling stack, delete next variable
41818	41892	break;
41819	41893	}
41820		- case 3529LLU: // skipped deleter
	41894	+ case 3538LLU: // skipped deleter
41821	41895	{
41822	41896	// call equ from procblock
41823		- stack[base + 23LLU] = 3530LLU/throw to this address/;
	41897	+ stack[base + 23LLU] = 3539LLU/throw to this address/;
41824	41898	stack[base + 24LLU] = base;
41825		- stack[base + 25LLU] = 3531LLU;
	41899	+ stack[base + 25LLU] = 3540LLU;
41826	41900	// arguments for call to equ
41827	41901	stack[base + 27LLU] = stack[base + 16]/content/;
41828	41902	stack[base + 28LLU] = 910715104645873664LLU;

		@@ -41831,13 +41905,13 @@
41831	41905	label = 18446744073709551600LLU; // equ
41832	41906	break;
41833	41907	}
41834		- case 3530LLU: // copy-back deleter (equ to procblock)
	41908	+ case 3539LLU: // copy-back deleter (equ to procblock)
41835	41909	{
41836	41910	// copy mutable arguments back from call to equ
41837		- label = 3496LLU; // continue to roll stack
	41911	+ label = 3505LLU; // continue to roll stack
41838	41912	break;
41839	41913	}
41840		- case 3531LLU: // return from equ to procblock
	41914	+ case 3540LLU: // return from equ to procblock
41841	41915	{
41842	41916	// copy mutable arguments back from call to equ
41843	41917	// copy back results provided by call to equ

		@@ -41844,21 +41918,21 @@
41844	41918	stack[base + 22] = stack[base + 26LLU];
41845	41919	if(!stack[base + 22]/when/)
41846	41920	{
41847		- label = 3532LLU; // jump to alternative
	41921	+ label = 3541LLU; // jump to alternative
41848	41922	break;
41849	41923	}
41850	41924
41851	41925	// consequent
41852	41926	stack[base + 20]/isequal/ = 1;
41853		- label = 3533LLU; // consequent complete
	41927	+ label = 3542LLU; // consequent complete
41854	41928	break;
41855	41929	}
41856		- case 3532LLU: // alternative
	41930	+ case 3541LLU: // alternative
41857	41931	{
41858	41932	// call equ from procblock
41859		- stack[base + 23LLU] = 3534LLU/throw to this address/;
	41933	+ stack[base + 23LLU] = 3543LLU/throw to this address/;
41860	41934	stack[base + 24LLU] = base;
41861		- stack[base + 25LLU] = 3535LLU;
	41935	+ stack[base + 25LLU] = 3544LLU;
41862	41936	// arguments for call to equ
41863	41937	stack[base + 27LLU] = stack[base + 16]/content/;
41864	41938	stack[base + 28LLU] = 657807020572803072LLU;

		@@ -41867,33 +41941,33 @@
41867	41941	label = 18446744073709551600LLU; // equ
41868	41942	break;
41869	41943	}
41870		- case 3534LLU: // copy-back deleter (equ to procblock)
	41944	+ case 3543LLU: // copy-back deleter (equ to procblock)
41871	41945	{
41872	41946	// copy mutable arguments back from call to equ
41873		- label = 3528LLU; // continue to roll stack
	41947	+ label = 3537LLU; // continue to roll stack
41874	41948	break;
41875	41949	}
41876		- case 3535LLU: // return from equ to procblock
	41950	+ case 3544LLU: // return from equ to procblock
41877	41951	{
41878	41952	// copy mutable arguments back from call to equ
41879	41953	// copy back results provided by call to equ
41880	41954	stack[base + 20] = stack[base + 26LLU];
41881		- label = 3533LLU; // alternative complete
	41955	+ label = 3542LLU; // alternative complete
41882	41956	break;
41883	41957	}
41884		- case 3533LLU: // completed if-then-else
	41958	+ case 3542LLU: // completed if-then-else
41885	41959	{
41886	41960	if(!stack[base + 20]/isequal/)
41887	41961	{
41888		- label = 3536LLU; // jump to alternative
	41962	+ label = 3545LLU; // jump to alternative
41889	41963	break;
41890	41964	}
41891	41965
41892	41966	// consequent
41893	41967	// call add from procblock
41894		- stack[base + 23LLU] = 3538LLU/throw to this address/;
	41968	+ stack[base + 23LLU] = 3547LLU/throw to this address/;
41895	41969	stack[base + 24LLU] = base;
41896		- stack[base + 25LLU] = 3539LLU;
	41970	+ stack[base + 25LLU] = 3548LLU;
41897	41971	// arguments for call to add
41898	41972	stack[base + 27LLU] = 1LLU;
41899	41973	stack[base + 28LLU] = stack[base + 17]/label/;

		@@ -41902,38 +41976,38 @@
41902	41976	label = 18446744073709551605LLU; // add
41903	41977	break;
41904	41978	}
41905		- case 3538LLU: // copy-back deleter (add to procblock)
	41979	+ case 3547LLU: // copy-back deleter (add to procblock)
41906	41980	{
41907	41981	// copy mutable arguments back from call to add
41908		- label = 3528LLU; // continue to roll stack
	41982	+ label = 3537LLU; // continue to roll stack
41909	41983	break;
41910	41984	}
41911		- case 3539LLU: // return from add to procblock
	41985	+ case 3548LLU: // return from add to procblock
41912	41986	{
41913	41987	// copy mutable arguments back from call to add
41914	41988	// copy back results provided by call to add
41915	41989	stack[base + 17] = stack[base + 26LLU];
41916		- label = 3541LLU; // skip deleter
	41990	+ label = 3550LLU; // skip deleter
41917	41991	break;
41918	41992	}
41919		- case 3540LLU: // deleter
	41993	+ case 3549LLU: // deleter
41920	41994	{
41921	41995	// throw from procblock
41922	41996	if(!stack[base + 23])
41923	41997	{
41924		- label = 3528LLU; // skip, variable already deleted/unscoped
	41998	+ label = 3537LLU; // skip, variable already deleted/unscoped
41925	41999	break;
41926	42000	}
41927		- label = 3528LLU; // continue unrolling stack, delete next variable
	42001	+ label = 3537LLU; // continue unrolling stack, delete next variable
41928	42002	break;
41929	42003	}
41930		- case 3541LLU: // skipped deleter
	42004	+ case 3550LLU: // skipped deleter
41931	42005	{
41932	42006	stack[base + 23] = stack[base + 17]/label/;
41933	42007	// call add from procblock
41934		- stack[base + 24LLU] = 3542LLU/throw to this address/;
	42008	+ stack[base + 24LLU] = 3551LLU/throw to this address/;
41935	42009	stack[base + 25LLU] = base;
41936		- stack[base + 26LLU] = 3543LLU;
	42010	+ stack[base + 26LLU] = 3552LLU;
41937	42011	// arguments for call to add
41938	42012	stack[base + 28LLU] = 1LLU;
41939	42013	stack[base + 29LLU] = stack[base + 17]/label/;

		@@ -41942,38 +42016,38 @@
41942	42016	label = 18446744073709551605LLU; // add
41943	42017	break;
41944	42018	}
41945		- case 3542LLU: // copy-back deleter (add to procblock)
	42019	+ case 3551LLU: // copy-back deleter (add to procblock)
41946	42020	{
41947	42021	// copy mutable arguments back from call to add
41948		- label = 3540LLU; // continue to roll stack
	42022	+ label = 3549LLU; // continue to roll stack
41949	42023	break;
41950	42024	}
41951		- case 3543LLU: // return from add to procblock
	42025	+ case 3552LLU: // return from add to procblock
41952	42026	{
41953	42027	// copy mutable arguments back from call to add
41954	42028	// copy back results provided by call to add
41955	42029	stack[base + 17] = stack[base + 27LLU];
41956		- label = 3545LLU; // skip deleter
	42030	+ label = 3554LLU; // skip deleter
41957	42031	break;
41958	42032	}
41959		- case 3544LLU: // deleter
	42033	+ case 3553LLU: // deleter
41960	42034	{
41961	42035	// throw from procblock
41962	42036	if(!stack[base + 24])
41963	42037	{
41964		- label = 3540LLU; // skip, variable already deleted/unscoped
	42038	+ label = 3549LLU; // skip, variable already deleted/unscoped
41965	42039	break;
41966	42040	}
41967		- label = 3540LLU; // continue unrolling stack, delete next variable
	42041	+ label = 3549LLU; // continue unrolling stack, delete next variable
41968	42042	break;
41969	42043	}
41970		- case 3545LLU: // skipped deleter
	42044	+ case 3554LLU: // skipped deleter
41971	42045	{
41972	42046	stack[base + 24] = stack[base + 17]/label/;
41973	42047	// call ParseToken from procblock
41974		- stack[base + 25LLU] = 3546LLU/throw to this address/;
	42048	+ stack[base + 25LLU] = 3555LLU/throw to this address/;
41975	42049	stack[base + 26LLU] = base;
41976		- stack[base + 27LLU] = 3547LLU;
	42050	+ stack[base + 27LLU] = 3556LLU;
41977	42051	// arguments for call to ParseToken
41978	42052	stack[base + 30LLU] = stack[base + 19]/lookahead/;
41979	42053	// set stack-base & callee-address

		@@ -41981,14 +42055,14 @@
41981	42055	label = 3LLU; // ParseToken
41982	42056	break;
41983	42057	}
41984		- case 3546LLU: // copy-back deleter (ParseToken to procblock)
	42058	+ case 3555LLU: // copy-back deleter (ParseToken to procblock)
41985	42059	{
41986	42060	// copy mutable arguments back from call to ParseToken
41987	42061	stack[base + 19]/lookahead/ = stack[base + 30LLU];
41988		- label = 3544LLU; // continue to roll stack
	42062	+ label = 3553LLU; // continue to roll stack
41989	42063	break;
41990	42064	}
41991		- case 3547LLU: // return from ParseToken to procblock
	42065	+ case 3556LLU: // return from ParseToken to procblock
41992	42066	{
41993	42067	// copy mutable arguments back from call to ParseToken
41994	42068	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -41996,9 +42070,9 @@
41996	42070	stack[base + 15] = stack[base + 28LLU];
41997	42071	stack[base + 16] = stack[base + 29LLU];
41998	42072	// call issimple from procblock
41999		- stack[base + 25LLU] = 3548LLU/throw to this address/;
	42073	+ stack[base + 25LLU] = 3557LLU/throw to this address/;
42000	42074	stack[base + 26LLU] = base;
42001		- stack[base + 27LLU] = 3549LLU;
	42075	+ stack[base + 27LLU] = 3558LLU;
42002	42076	// arguments for call to issimple
42003	42077	stack[base + 29LLU] = stack[base + 15]/variant/;
42004	42078	stack[base + 30LLU] = stack[base + 16]/content/;

		@@ -42008,13 +42082,13 @@
42008	42082	label = 166LLU; // issimple
42009	42083	break;
42010	42084	}
42011		- case 3548LLU: // copy-back deleter (issimple to procblock)
	42085	+ case 3557LLU: // copy-back deleter (issimple to procblock)
42012	42086	{
42013	42087	// copy mutable arguments back from call to issimple
42014		- label = 3544LLU; // continue to roll stack
	42088	+ label = 3553LLU; // continue to roll stack
42015	42089	break;
42016	42090	}
42017		- case 3549LLU: // return from issimple to procblock
	42091	+ case 3558LLU: // return from issimple to procblock
42018	42092	{
42019	42093	// copy mutable arguments back from call to issimple
42020	42094	// copy back results provided by call to issimple

		@@ -42021,7 +42095,7 @@
42021	42095	stack[base + 20] = stack[base + 28LLU];
42022	42096	if(!stack[base + 20]/isequal/)
42023	42097	{
42024		- label = 3550LLU; // jump to alternative
	42098	+ label = 3559LLU; // jump to alternative
42025	42099	break;
42026	42100	}
42027	42101

		@@ -42028,9 +42102,9 @@
42028	42102	// consequent
42029	42103	printf("%s", "\n if(!");
42030	42104	// call ParseToken from procblock
42031		- stack[base + 25LLU] = 3552LLU/throw to this address/;
	42105	+ stack[base + 25LLU] = 3561LLU/throw to this address/;
42032	42106	stack[base + 26LLU] = base;
42033		- stack[base + 27LLU] = 3553LLU;
	42107	+ stack[base + 27LLU] = 3562LLU;
42034	42108	// arguments for call to ParseToken
42035	42109	stack[base + 30LLU] = stack[base + 19]/lookahead/;
42036	42110	// set stack-base & callee-address

		@@ -42038,14 +42112,14 @@
42038	42112	label = 3LLU; // ParseToken
42039	42113	break;
42040	42114	}
42041		- case 3552LLU: // copy-back deleter (ParseToken to procblock)
	42115	+ case 3561LLU: // copy-back deleter (ParseToken to procblock)
42042	42116	{
42043	42117	// copy mutable arguments back from call to ParseToken
42044	42118	stack[base + 19]/lookahead/ = stack[base + 30LLU];
42045		- label = 3544LLU; // continue to roll stack
	42119	+ label = 3553LLU; // continue to roll stack
42046	42120	break;
42047	42121	}
42048		- case 3553LLU: // return from ParseToken to procblock
	42122	+ case 3562LLU: // return from ParseToken to procblock
42049	42123	{
42050	42124	// copy mutable arguments back from call to ParseToken
42051	42125	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -42053,9 +42127,9 @@
42053	42127	stack[base + 15] = stack[base + 28LLU];
42054	42128	stack[base + 16] = stack[base + 29LLU];
42055	42129	// call equ from procblock
42056		- stack[base + 25LLU] = 3554LLU/throw to this address/;
	42130	+ stack[base + 25LLU] = 3563LLU/throw to this address/;
42057	42131	stack[base + 26LLU] = base;
42058		- stack[base + 27LLU] = 3555LLU;
	42132	+ stack[base + 27LLU] = 3564LLU;
42059	42133	// arguments for call to equ
42060	42134	stack[base + 29LLU] = stack[base + 15]/variant/;
42061	42135	stack[base + 30LLU] = 1LLU;

		@@ -42064,13 +42138,13 @@
42064	42138	label = 18446744073709551600LLU; // equ
42065	42139	break;
42066	42140	}
42067		- case 3554LLU: // copy-back deleter (equ to procblock)
	42141	+ case 3563LLU: // copy-back deleter (equ to procblock)
42068	42142	{
42069	42143	// copy mutable arguments back from call to equ
42070		- label = 3544LLU; // continue to roll stack
	42144	+ label = 3553LLU; // continue to roll stack
42071	42145	break;
42072	42146	}
42073		- case 3555LLU: // return from equ to procblock
	42147	+ case 3564LLU: // return from equ to procblock
42074	42148	{
42075	42149	// copy mutable arguments back from call to equ
42076	42150	// copy back results provided by call to equ

		@@ -42077,15 +42151,15 @@
42077	42151	stack[base + 20] = stack[base + 28LLU];
42078	42152	if(!stack[base + 20]/isequal/)
42079	42153	{
42080		- label = 3556LLU; // jump to alternative
	42154	+ label = 3565LLU; // jump to alternative
42081	42155	break;
42082	42156	}
42083	42157
42084	42158	// consequent
42085	42159	// call printnr from procblock
42086		- stack[base + 25LLU] = 3558LLU/throw to this address/;
	42160	+ stack[base + 25LLU] = 3567LLU/throw to this address/;
42087	42161	stack[base + 26LLU] = base;
42088		- stack[base + 27LLU] = 3559LLU;
	42162	+ stack[base + 27LLU] = 3568LLU;
42089	42163	// arguments for call to printnr
42090	42164	stack[base + 28LLU] = stack[base + 16]/content/;
42091	42165	// set stack-base & callee-address

		@@ -42093,24 +42167,24 @@
42093	42167	label = 18446744073709551590LLU; // printnr
42094	42168	break;
42095	42169	}
42096		- case 3558LLU: // copy-back deleter (printnr to procblock)
	42170	+ case 3567LLU: // copy-back deleter (printnr to procblock)
42097	42171	{
42098	42172	// copy mutable arguments back from call to printnr
42099		- label = 3544LLU; // continue to roll stack
	42173	+ label = 3553LLU; // continue to roll stack
42100	42174	break;
42101	42175	}
42102		- case 3559LLU: // return from printnr to procblock
	42176	+ case 3568LLU: // return from printnr to procblock
42103	42177	{
42104	42178	// copy mutable arguments back from call to printnr
42105		- label = 3557LLU; // consequent complete
	42179	+ label = 3566LLU; // consequent complete
42106	42180	break;
42107	42181	}
42108		- case 3556LLU: // alternative
	42182	+ case 3565LLU: // alternative
42109	42183	{
42110	42184	// call equ from procblock
42111		- stack[base + 25LLU] = 3560LLU/throw to this address/;
	42185	+ stack[base + 25LLU] = 3569LLU/throw to this address/;
42112	42186	stack[base + 26LLU] = base;
42113		- stack[base + 27LLU] = 3561LLU;
	42187	+ stack[base + 27LLU] = 3570LLU;
42114	42188	// arguments for call to equ
42115	42189	stack[base + 29LLU] = stack[base + 15]/variant/;
42116	42190	stack[base + 30LLU] = 4LLU;

		@@ -42119,13 +42193,13 @@
42119	42193	label = 18446744073709551600LLU; // equ
42120	42194	break;
42121	42195	}
42122		- case 3560LLU: // copy-back deleter (equ to procblock)
	42196	+ case 3569LLU: // copy-back deleter (equ to procblock)
42123	42197	{
42124	42198	// copy mutable arguments back from call to equ
42125		- label = 3544LLU; // continue to roll stack
	42199	+ label = 3553LLU; // continue to roll stack
42126	42200	break;
42127	42201	}
42128		- case 3561LLU: // return from equ to procblock
	42202	+ case 3570LLU: // return from equ to procblock
42129	42203	{
42130	42204	// copy mutable arguments back from call to equ
42131	42205	// copy back results provided by call to equ

		@@ -42132,15 +42206,15 @@
42132	42206	stack[base + 20] = stack[base + 28LLU];
42133	42207	if(!stack[base + 20]/isequal/)
42134	42208	{
42135		- label = 3562LLU; // jump to alternative
	42209	+ label = 3571LLU; // jump to alternative
42136	42210	break;
42137	42211	}
42138	42212
42139	42213	// consequent
42140	42214	// call emitvar from procblock
42141		- stack[base + 25LLU] = 3564LLU/throw to this address/;
	42215	+ stack[base + 25LLU] = 3573LLU/throw to this address/;
42142	42216	stack[base + 26LLU] = base;
42143		- stack[base + 27LLU] = 3565LLU;
	42217	+ stack[base + 27LLU] = 3574LLU;
42144	42218	// arguments for call to emitvar
42145	42219	stack[base + 28LLU] = stack[base + 8]/fnid/;
42146	42220	stack[base + 29LLU] = stack[base + 16]/content/;

		@@ -42151,25 +42225,25 @@
42151	42225	label = 749LLU; // emitvar
42152	42226	break;
42153	42227	}
42154		- case 3564LLU: // copy-back deleter (emitvar to procblock)
	42228	+ case 3573LLU: // copy-back deleter (emitvar to procblock)
42155	42229	{
42156	42230	// copy mutable arguments back from call to emitvar
42157		- label = 3544LLU; // continue to roll stack
	42231	+ label = 3553LLU; // continue to roll stack
42158	42232	break;
42159	42233	}
42160		- case 3565LLU: // return from emitvar to procblock
	42234	+ case 3574LLU: // return from emitvar to procblock
42161	42235	{
42162	42236	// copy mutable arguments back from call to emitvar
42163		- label = 3563LLU; // consequent complete
	42237	+ label = 3572LLU; // consequent complete
42164	42238	break;
42165	42239	}
42166		- case 3562LLU: // alternative
	42240	+ case 3571LLU: // alternative
42167	42241	{
42168	42242	fprintf(stderr, "%s", "expected identifier in if-then-else but found ");
42169	42243	// call reporttok from procblock
42170		- stack[base + 25LLU] = 3566LLU/throw to this address/;
	42244	+ stack[base + 25LLU] = 3575LLU/throw to this address/;
42171	42245	stack[base + 26LLU] = base;
42172		- stack[base + 27LLU] = 3567LLU;
	42246	+ stack[base + 27LLU] = 3576LLU;
42173	42247	// arguments for call to reporttok
42174	42248	stack[base + 28LLU] = stack[base + 15]/variant/;
42175	42249	stack[base + 29LLU] = stack[base + 16]/content/;

		@@ -42178,35 +42252,35 @@
42178	42252	label = 18446744073709551582LLU; // reporttok
42179	42253	break;
42180	42254	}
42181		- case 3566LLU: // copy-back deleter (reporttok to procblock)
	42255	+ case 3575LLU: // copy-back deleter (reporttok to procblock)
42182	42256	{
42183	42257	// copy mutable arguments back from call to reporttok
42184		- label = 3544LLU; // continue to roll stack
	42258	+ label = 3553LLU; // continue to roll stack
42185	42259	break;
42186	42260	}
42187		- case 3567LLU: // return from reporttok to procblock
	42261	+ case 3576LLU: // return from reporttok to procblock
42188	42262	{
42189	42263	// copy mutable arguments back from call to reporttok
42190	42264	fprintf(stderr, "%s", "\n");
42191	42265	{
42192		- label = 3544LLU; // throw: begin to unroll stack
	42266	+ label = 3553LLU; // throw: begin to unroll stack
42193	42267	break;
42194	42268	}
42195	42269
42196		- label = 3563LLU; // alternative complete
	42270	+ label = 3572LLU; // alternative complete
42197	42271	break;
42198	42272	}
42199		- case 3563LLU: // completed if-then-else
	42273	+ case 3572LLU: // completed if-then-else
42200	42274	{
42201		- label = 3557LLU; // alternative complete
	42275	+ label = 3566LLU; // alternative complete
42202	42276	break;
42203	42277	}
42204		- case 3557LLU: // completed if-then-else
	42278	+ case 3566LLU: // completed if-then-else
42205	42279	{
42206	42280	// call matchsym from procblock
42207		- stack[base + 25LLU] = 3568LLU/throw to this address/;
	42281	+ stack[base + 25LLU] = 3577LLU/throw to this address/;
42208	42282	stack[base + 26LLU] = base;
42209		- stack[base + 27LLU] = 3569LLU;
	42283	+ stack[base + 27LLU] = 3578LLU;
42210	42284	// arguments for call to matchsym
42211	42285	stack[base + 28LLU] = stack[base + 8]/fnid/;
42212	42286	stack[base + 29LLU] = 41LLU;

		@@ -42216,14 +42290,14 @@
42216	42290	label = 246LLU; // matchsym
42217	42291	break;
42218	42292	}
42219		- case 3568LLU: // copy-back deleter (matchsym to procblock)
	42293	+ case 3577LLU: // copy-back deleter (matchsym to procblock)
42220	42294	{
42221	42295	// copy mutable arguments back from call to matchsym
42222	42296	stack[base + 19]/lookahead/ = stack[base + 30LLU];
42223		- label = 3544LLU; // continue to roll stack
	42297	+ label = 3553LLU; // continue to roll stack
42224	42298	break;
42225	42299	}
42226		- case 3569LLU: // return from matchsym to procblock
	42300	+ case 3578LLU: // return from matchsym to procblock
42227	42301	{
42228	42302	// copy mutable arguments back from call to matchsym
42229	42303	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -42231,9 +42305,9 @@
42231	42305	printf("%s", "\n {");
42232	42306	printf("%s", "\n label = ");
42233	42307	// call printnr from procblock
42234		- stack[base + 25LLU] = 3570LLU/throw to this address/;
	42308	+ stack[base + 25LLU] = 3579LLU/throw to this address/;
42235	42309	stack[base + 26LLU] = base;
42236		- stack[base + 27LLU] = 3571LLU;
	42310	+ stack[base + 27LLU] = 3580LLU;
42237	42311	// arguments for call to printnr
42238	42312	stack[base + 28LLU] = stack[base + 23]/labelalt/;
42239	42313	// set stack-base & callee-address

		@@ -42241,13 +42315,13 @@
42241	42315	label = 18446744073709551590LLU; // printnr
42242	42316	break;
42243	42317	}
42244		- case 3570LLU: // copy-back deleter (printnr to procblock)
	42318	+ case 3579LLU: // copy-back deleter (printnr to procblock)
42245	42319	{
42246	42320	// copy mutable arguments back from call to printnr
42247		- label = 3544LLU; // continue to roll stack
	42321	+ label = 3553LLU; // continue to roll stack
42248	42322	break;
42249	42323	}
42250		- case 3571LLU: // return from printnr to procblock
	42324	+ case 3580LLU: // return from printnr to procblock
42251	42325	{
42252	42326	// copy mutable arguments back from call to printnr
42253	42327	printf("%s", "LLU; // jump to alternative");

		@@ -42256,9 +42330,9 @@
42256	42330	printf("%s", "\n");
42257	42331	printf("%s", "\n // consequent");
42258	42332	// call matchsym from procblock
42259		- stack[base + 25LLU] = 3572LLU/throw to this address/;
	42333	+ stack[base + 25LLU] = 3581LLU/throw to this address/;
42260	42334	stack[base + 26LLU] = base;
42261		- stack[base + 27LLU] = 3573LLU;
	42335	+ stack[base + 27LLU] = 3582LLU;
42262	42336	// arguments for call to matchsym
42263	42337	stack[base + 28LLU] = stack[base + 8]/fnid/;
42264	42338	stack[base + 29LLU] = 123LLU;

		@@ -42268,20 +42342,20 @@
42268	42342	label = 246LLU; // matchsym
42269	42343	break;
42270	42344	}
42271		- case 3572LLU: // copy-back deleter (matchsym to procblock)
	42345	+ case 3581LLU: // copy-back deleter (matchsym to procblock)
42272	42346	{
42273	42347	// copy mutable arguments back from call to matchsym
42274	42348	stack[base + 19]/lookahead/ = stack[base + 30LLU];
42275		- label = 3544LLU; // continue to roll stack
	42349	+ label = 3553LLU; // continue to roll stack
42276	42350	break;
42277	42351	}
42278		- case 3573LLU: // return from matchsym to procblock
	42352	+ case 3582LLU: // return from matchsym to procblock
42279	42353	{
42280	42354	// copy mutable arguments back from call to matchsym
42281	42355	stack[base + 19]/lookahead/ = stack[base + 30LLU];
42282	42356	if(!stack[base + 21]/returnflag/)
42283	42357	{
42284		- label = 3574LLU; // jump to alternative
	42358	+ label = 3583LLU; // jump to alternative
42285	42359	break;
42286	42360	}
42287	42361

		@@ -42289,7 +42363,7 @@
42289	42363	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
42290	42364	if(!newstack)
42291	42365	{
42292		- label = 3544LLU; // throw: begin to unroll stack
	42366	+ label = 3553LLU; // throw: begin to unroll stack
42293	42367	break;
42294	42368	}
42295	42369

		@@ -42296,9 +42370,9 @@
42296	42370	newstack[160LLU] = 9876543210LLU; // overflow-marker
42297	42371	// call procblock from procblock
42298	42372	newstack[0] = (uint64_t)stack; // backup stack location
42299		- newstack[1] = 3576LLU;
	42373	+ newstack[1] = 3585LLU;
42300	42374	newstack[2] = base;
42301		- newstack[3] = 3577LLU;
	42375	+ newstack[3] = 3586LLU;
42302	42376	// arguments for call to procblock
42303	42377	newstack[4LLU] = stack[base + 0]/fndefs/;
42304	42378	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -42321,10 +42395,10 @@
42321	42395	stack = newstack;
42322	42396	// set stack-base & callee-address
42323	42397	base = 4/deloffset/;
42324		- label = 3429LLU; // procblock
	42398	+ label = 3438LLU; // procblock
42325	42399	break;
42326	42400	}
42327		- case 3576LLU: // copy-back deleter (procblock to procblock)
	42401	+ case 3585LLU: // copy-back deleter (procblock to procblock)
42328	42402	{
42329	42403	uint64_t oldstack = (uint64_t )stack[0];
42330	42404	// copy mutable arguments back from call to procblock

		@@ -42341,10 +42415,10 @@
42341	42415	}
42342	42416	Free(160LLU + 1, sizeof(uint64_t), stack);
42343	42417	stack = oldstack;
42344		- label = 3544LLU; // continue to unroll stack
	42418	+ label = 3553LLU; // continue to unroll stack
42345	42419	break;
42346	42420	}
42347		- case 3577LLU: // return from procblock to procblock
	42421	+ case 3586LLU: // return from procblock to procblock
42348	42422	{
42349	42423	uint64_t oldstack = (uint64_t )stack[0];
42350	42424	// copy mutable arguments back from call to procblock

		@@ -42361,31 +42435,31 @@
42361	42435	}
42362	42436	Free(160LLU + 1, sizeof(uint64_t), stack);
42363	42437	stack = oldstack;
42364		- label = 3575LLU; // consequent complete
	42438	+ label = 3584LLU; // consequent complete
42365	42439	break;
42366	42440	}
42367		- case 3574LLU: // alternative
	42441	+ case 3583LLU: // alternative
42368	42442	{
42369		- label = 3579LLU; // skip deleter
	42443	+ label = 3588LLU; // skip deleter
42370	42444	break;
42371	42445	}
42372		- case 3578LLU: // deleter
	42446	+ case 3587LLU: // deleter
42373	42447	{
42374	42448	// throw from procblock
42375	42449	if(!stack[base + 25])
42376	42450	{
42377		- label = 3544LLU; // skip, variable already deleted/unscoped
	42451	+ label = 3553LLU; // skip, variable already deleted/unscoped
42378	42452	break;
42379	42453	}
42380	42454	// delete list
42381		- label = 3580LLU; // start to repeat
	42455	+ label = 3589LLU; // start to repeat
42382	42456	break;
42383	42457	}
42384		- case 3580LLU: // repeat from here
	42458	+ case 3589LLU: // repeat from here
42385	42459	{
42386	42460	if(!stack[base + 25])
42387	42461	{
42388		- label = 3581LLU; // break loop
	42462	+ label = 3590LLU; // break loop
42389	42463	break;
42390	42464	}
42391	42465

		@@ -42396,7 +42470,7 @@
42396	42470	newstack[0] = (uint64_t)stack; // backup stack location
42397	42471	newstack[1] = 1234567890;
42398	42472	newstack[2] = base;
42399		- newstack[3] = 3582LLU;
	42473	+ newstack[3] = 3591LLU;
42400	42474	stack = newstack;
42401	42475	// set stack-base & callee-address
42402	42476	base = 4/deloffset/;

		@@ -42403,7 +42477,7 @@
42403	42477	label = 399LLU; // ~typeidx
42404	42478	break;
42405	42479	}
42406		- case 3582LLU: // return from ~typeidx to procblock
	42480	+ case 3591LLU: // return from ~typeidx to procblock
42407	42481	{
42408	42482	stack = (uint64_t *)stack[0];
42409	42483	// releasing toplevel container

		@@ -42414,21 +42488,21 @@
42414	42488	stack[base + 25] = (uint64_t)list->next;
42415	42489	Free(1, sizeof(struct listnode), list);
42416	42490	}
42417		- label = 3580LLU; // repeat
	42491	+ label = 3589LLU; // repeat
42418	42492	break;
42419	42493	}
42420		- case 3581LLU: // loop finished
	42494	+ case 3590LLU: // loop finished
42421	42495	{
42422		- label = 3544LLU; // continue unrolling stack, delete next variable
	42496	+ label = 3553LLU; // continue unrolling stack, delete next variable
42423	42497	break;
42424	42498	}
42425		- case 3579LLU: // skipped deleter
	42499	+ case 3588LLU: // skipped deleter
42426	42500	{
42427	42501	stack[base + 25] = 0;
42428	42502	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
42429	42503	if(!newstack)
42430	42504	{
42431		- label = 3578LLU; // throw: begin to unroll stack
	42505	+ label = 3587LLU; // throw: begin to unroll stack
42432	42506	break;
42433	42507	}
42434	42508

		@@ -42435,9 +42509,9 @@
42435	42509	newstack[160LLU] = 9876543210LLU; // overflow-marker
42436	42510	// call procblock from procblock
42437	42511	newstack[0] = (uint64_t)stack; // backup stack location
42438		- newstack[1] = 3583LLU;
	42512	+ newstack[1] = 3592LLU;
42439	42513	newstack[2] = base;
42440		- newstack[3] = 3584LLU;
	42514	+ newstack[3] = 3593LLU;
42441	42515	// arguments for call to procblock
42442	42516	newstack[4LLU] = stack[base + 0]/fndefs/;
42443	42517	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -42460,10 +42534,10 @@
42460	42534	stack = newstack;
42461	42535	// set stack-base & callee-address
42462	42536	base = 4/deloffset/;
42463		- label = 3429LLU; // procblock
	42537	+ label = 3438LLU; // procblock
42464	42538	break;
42465	42539	}
42466		- case 3583LLU: // copy-back deleter (procblock to procblock)
	42540	+ case 3592LLU: // copy-back deleter (procblock to procblock)
42467	42541	{
42468	42542	uint64_t oldstack = (uint64_t )stack[0];
42469	42543	// copy mutable arguments back from call to procblock

		@@ -42480,10 +42554,10 @@
42480	42554	}
42481	42555	Free(160LLU + 1, sizeof(uint64_t), stack);
42482	42556	stack = oldstack;
42483		- label = 3578LLU; // continue to unroll stack
	42557	+ label = 3587LLU; // continue to unroll stack
42484	42558	break;
42485	42559	}
42486		- case 3584LLU: // return from procblock to procblock
	42560	+ case 3593LLU: // return from procblock to procblock
42487	42561	{
42488	42562	uint64_t oldstack = (uint64_t )stack[0];
42489	42563	// copy mutable arguments back from call to procblock

		@@ -42501,14 +42575,14 @@
42501	42575	Free(160LLU + 1, sizeof(uint64_t), stack);
42502	42576	stack = oldstack;
42503	42577	// delete list
42504		- label = 3585LLU; // start to repeat
	42578	+ label = 3594LLU; // start to repeat
42505	42579	break;
42506	42580	}
42507		- case 3585LLU: // repeat from here
	42581	+ case 3594LLU: // repeat from here
42508	42582	{
42509	42583	if(!stack[base + 25])
42510	42584	{
42511		- label = 3586LLU; // break loop
	42585	+ label = 3595LLU; // break loop
42512	42586	break;
42513	42587	}
42514	42588

		@@ -42519,7 +42593,7 @@
42519	42593	newstack[0] = (uint64_t)stack; // backup stack location
42520	42594	newstack[1] = 1234567890;
42521	42595	newstack[2] = base;
42522		- newstack[3] = 3587LLU;
	42596	+ newstack[3] = 3596LLU;
42523	42597	stack = newstack;
42524	42598	// set stack-base & callee-address
42525	42599	base = 4/deloffset/;

		@@ -42526,7 +42600,7 @@
42526	42600	label = 399LLU; // ~typeidx
42527	42601	break;
42528	42602	}
42529		- case 3587LLU: // return from ~typeidx to procblock
	42603	+ case 3596LLU: // return from ~typeidx to procblock
42530	42604	{
42531	42605	stack = (uint64_t *)stack[0];
42532	42606	// releasing toplevel container

		@@ -42537,21 +42611,21 @@
42537	42611	stack[base + 25] = (uint64_t)list->next;
42538	42612	Free(1, sizeof(struct listnode), list);
42539	42613	}
42540		- label = 3585LLU; // repeat
	42614	+ label = 3594LLU; // repeat
42541	42615	break;
42542	42616	}
42543		- case 3586LLU: // loop finished
	42617	+ case 3595LLU: // loop finished
42544	42618	{
42545		- label = 3575LLU; // alternative complete
	42619	+ label = 3584LLU; // alternative complete
42546	42620	break;
42547	42621	}
42548		- case 3575LLU: // completed if-then-else
	42622	+ case 3584LLU: // completed if-then-else
42549	42623	{
42550	42624	printf("%s", "\n label = ");
42551	42625	// call printnr from procblock
42552		- stack[base + 25LLU] = 3588LLU/throw to this address/;
	42626	+ stack[base + 25LLU] = 3597LLU/throw to this address/;
42553	42627	stack[base + 26LLU] = base;
42554		- stack[base + 27LLU] = 3589LLU;
	42628	+ stack[base + 27LLU] = 3598LLU;
42555	42629	// arguments for call to printnr
42556	42630	stack[base + 28LLU] = stack[base + 24]/labelskip/;
42557	42631	// set stack-base & callee-address

		@@ -42559,13 +42633,13 @@
42559	42633	label = 18446744073709551590LLU; // printnr
42560	42634	break;
42561	42635	}
42562		- case 3588LLU: // copy-back deleter (printnr to procblock)
	42636	+ case 3597LLU: // copy-back deleter (printnr to procblock)
42563	42637	{
42564	42638	// copy mutable arguments back from call to printnr
42565		- label = 3544LLU; // continue to roll stack
	42639	+ label = 3553LLU; // continue to roll stack
42566	42640	break;
42567	42641	}
42568		- case 3589LLU: // return from printnr to procblock
	42642	+ case 3598LLU: // return from printnr to procblock
42569	42643	{
42570	42644	// copy mutable arguments back from call to printnr
42571	42645	printf("%s", "LLU; // consequent complete");

		@@ -42573,9 +42647,9 @@
42573	42647	printf("%s", "\n }");
42574	42648	printf("%s", "\n case ");
42575	42649	// call printnr from procblock
42576		- stack[base + 25LLU] = 3590LLU/throw to this address/;
	42650	+ stack[base + 25LLU] = 3599LLU/throw to this address/;
42577	42651	stack[base + 26LLU] = base;
42578		- stack[base + 27LLU] = 3591LLU;
	42652	+ stack[base + 27LLU] = 3600LLU;
42579	42653	// arguments for call to printnr
42580	42654	stack[base + 28LLU] = stack[base + 23]/labelalt/;
42581	42655	// set stack-base & callee-address

		@@ -42583,42 +42657,42 @@
42583	42657	label = 18446744073709551590LLU; // printnr
42584	42658	break;
42585	42659	}
42586		- case 3590LLU: // copy-back deleter (printnr to procblock)
	42660	+ case 3599LLU: // copy-back deleter (printnr to procblock)
42587	42661	{
42588	42662	// copy mutable arguments back from call to printnr
42589		- label = 3544LLU; // continue to roll stack
	42663	+ label = 3553LLU; // continue to roll stack
42590	42664	break;
42591	42665	}
42592		- case 3591LLU: // return from printnr to procblock
	42666	+ case 3600LLU: // return from printnr to procblock
42593	42667	{
42594	42668	// copy mutable arguments back from call to printnr
42595	42669	printf("%s", "LLU: // alternative");
42596	42670	printf("%s", "\n {");
42597		- label = 3551LLU; // consequent complete
	42671	+ label = 3560LLU; // consequent complete
42598	42672	break;
42599	42673	}
42600		- case 3550LLU: // alternative
	42674	+ case 3559LLU: // alternative
42601	42675	{
42602		- label = 3593LLU; // skip deleter
	42676	+ label = 3602LLU; // skip deleter
42603	42677	break;
42604	42678	}
42605		- case 3592LLU: // deleter
	42679	+ case 3601LLU: // deleter
42606	42680	{
42607	42681	// throw from procblock
42608	42682	if(!stack[base + 25])
42609	42683	{
42610		- label = 3544LLU; // skip, variable already deleted/unscoped
	42684	+ label = 3553LLU; // skip, variable already deleted/unscoped
42611	42685	break;
42612	42686	}
42613		- label = 3544LLU; // continue unrolling stack, delete next variable
	42687	+ label = 3553LLU; // continue unrolling stack, delete next variable
42614	42688	break;
42615	42689	}
42616		- case 3593LLU: // skipped deleter
	42690	+ case 3602LLU: // skipped deleter
42617	42691	{
42618	42692	// call equ from procblock
42619		- stack[base + 26LLU] = 3594LLU/throw to this address/;
	42693	+ stack[base + 26LLU] = 3603LLU/throw to this address/;
42620	42694	stack[base + 27LLU] = base;
42621		- stack[base + 28LLU] = 3595LLU;
	42695	+ stack[base + 28LLU] = 3604LLU;
42622	42696	// arguments for call to equ
42623	42697	stack[base + 30LLU] = stack[base + 16]/content/;
42624	42698	stack[base + 31LLU] = 747825068330975232LLU;

		@@ -42627,13 +42701,13 @@
42627	42701	label = 18446744073709551600LLU; // equ
42628	42702	break;
42629	42703	}
42630		- case 3594LLU: // copy-back deleter (equ to procblock)
	42704	+ case 3603LLU: // copy-back deleter (equ to procblock)
42631	42705	{
42632	42706	// copy mutable arguments back from call to equ
42633		- label = 3544LLU; // continue to roll stack
	42707	+ label = 3553LLU; // continue to roll stack
42634	42708	break;
42635	42709	}
42636		- case 3595LLU: // return from equ to procblock
	42710	+ case 3604LLU: // return from equ to procblock
42637	42711	{
42638	42712	// copy mutable arguments back from call to equ
42639	42713	// copy back results provided by call to equ

		@@ -42640,37 +42714,37 @@
42640	42714	stack[base + 20] = stack[base + 29LLU];
42641	42715	if(!stack[base + 20]/isequal/)
42642	42716	{
42643		- label = 3596LLU; // jump to alternative
	42717	+ label = 3605LLU; // jump to alternative
42644	42718	break;
42645	42719	}
42646	42720
42647	42721	// consequent
42648		- label = 3599LLU; // skip deleter
	42722	+ label = 3608LLU; // skip deleter
42649	42723	break;
42650	42724	}
42651		- case 3598LLU: // deleter
	42725	+ case 3607LLU: // deleter
42652	42726	{
42653	42727	// throw from procblock
42654	42728	if(!stack[base + 25])
42655	42729	{
42656		- label = 3544LLU; // skip, variable already deleted/unscoped
	42730	+ label = 3553LLU; // skip, variable already deleted/unscoped
42657	42731	break;
42658	42732	}
42659		- label = 3544LLU; // continue unrolling stack, delete next variable
	42733	+ label = 3553LLU; // continue unrolling stack, delete next variable
42660	42734	break;
42661	42735	}
42662		- case 3599LLU: // skipped deleter
	42736	+ case 3608LLU: // skipped deleter
42663	42737	{
42664	42738	stack[base + 25] = 0;
42665		- label = 3597LLU; // consequent complete
	42739	+ label = 3606LLU; // consequent complete
42666	42740	break;
42667	42741	}
42668		- case 3596LLU: // alternative
	42742	+ case 3605LLU: // alternative
42669	42743	{
42670	42744	// call equ from procblock
42671		- stack[base + 26LLU] = 3600LLU/throw to this address/;
	42745	+ stack[base + 26LLU] = 3609LLU/throw to this address/;
42672	42746	stack[base + 27LLU] = base;
42673		- stack[base + 28LLU] = 3601LLU;
	42747	+ stack[base + 28LLU] = 3610LLU;
42674	42748	// arguments for call to equ
42675	42749	stack[base + 30LLU] = stack[base + 16]/content/;
42676	42750	stack[base + 31LLU] = 786630200929550336LLU;

		@@ -42679,13 +42753,13 @@
42679	42753	label = 18446744073709551600LLU; // equ
42680	42754	break;
42681	42755	}
42682		- case 3600LLU: // copy-back deleter (equ to procblock)
	42756	+ case 3609LLU: // copy-back deleter (equ to procblock)
42683	42757	{
42684	42758	// copy mutable arguments back from call to equ
42685		- label = 3544LLU; // continue to roll stack
	42759	+ label = 3553LLU; // continue to roll stack
42686	42760	break;
42687	42761	}
42688		- case 3601LLU: // return from equ to procblock
	42762	+ case 3610LLU: // return from equ to procblock
42689	42763	{
42690	42764	// copy mutable arguments back from call to equ
42691	42765	// copy back results provided by call to equ

		@@ -42692,38 +42766,38 @@
42692	42766	stack[base + 20] = stack[base + 29LLU];
42693	42767	if(!stack[base + 20]/isequal/)
42694	42768	{
42695		- label = 3602LLU; // jump to alternative
	42769	+ label = 3611LLU; // jump to alternative
42696	42770	break;
42697	42771	}
42698	42772
42699	42773	// consequent
42700		- label = 3605LLU; // skip deleter
	42774	+ label = 3614LLU; // skip deleter
42701	42775	break;
42702	42776	}
42703		- case 3604LLU: // deleter
	42777	+ case 3613LLU: // deleter
42704	42778	{
42705	42779	// throw from procblock
42706	42780	if(!stack[base + 25])
42707	42781	{
42708		- label = 3544LLU; // skip, variable already deleted/unscoped
	42782	+ label = 3553LLU; // skip, variable already deleted/unscoped
42709	42783	break;
42710	42784	}
42711		- label = 3544LLU; // continue unrolling stack, delete next variable
	42785	+ label = 3553LLU; // continue unrolling stack, delete next variable
42712	42786	break;
42713	42787	}
42714		- case 3605LLU: // skipped deleter
	42788	+ case 3614LLU: // skipped deleter
42715	42789	{
42716	42790	stack[base + 25] = 1;
42717		- label = 3603LLU; // consequent complete
	42791	+ label = 3612LLU; // consequent complete
42718	42792	break;
42719	42793	}
42720		- case 3602LLU: // alternative
	42794	+ case 3611LLU: // alternative
42721	42795	{
42722	42796	fprintf(stderr, "%s", "expected '(' but found token ");
42723	42797	// call reporttok from procblock
42724		- stack[base + 26LLU] = 3606LLU/throw to this address/;
	42798	+ stack[base + 26LLU] = 3615LLU/throw to this address/;
42725	42799	stack[base + 27LLU] = base;
42726		- stack[base + 28LLU] = 3607LLU;
	42800	+ stack[base + 28LLU] = 3616LLU;
42727	42801	// arguments for call to reporttok
42728	42802	stack[base + 29LLU] = stack[base + 15]/variant/;
42729	42803	stack[base + 30LLU] = stack[base + 16]/content/;

		@@ -42732,83 +42806,83 @@
42732	42806	label = 18446744073709551582LLU; // reporttok
42733	42807	break;
42734	42808	}
42735		- case 3606LLU: // copy-back deleter (reporttok to procblock)
	42809	+ case 3615LLU: // copy-back deleter (reporttok to procblock)
42736	42810	{
42737	42811	// copy mutable arguments back from call to reporttok
42738		- label = 3544LLU; // continue to roll stack
	42812	+ label = 3553LLU; // continue to roll stack
42739	42813	break;
42740	42814	}
42741		- case 3607LLU: // return from reporttok to procblock
	42815	+ case 3616LLU: // return from reporttok to procblock
42742	42816	{
42743	42817	// copy mutable arguments back from call to reporttok
42744	42818	fprintf(stderr, "%s", "\n");
42745	42819	{
42746		- label = 3544LLU; // throw: begin to unroll stack
	42820	+ label = 3553LLU; // throw: begin to unroll stack
42747	42821	break;
42748	42822	}
42749	42823
42750		- label = 3603LLU; // alternative complete
	42824	+ label = 3612LLU; // alternative complete
42751	42825	break;
42752	42826	}
42753		- case 3603LLU: // completed if-then-else
	42827	+ case 3612LLU: // completed if-then-else
42754	42828	{
42755		- label = 3597LLU; // alternative complete
	42829	+ label = 3606LLU; // alternative complete
42756	42830	break;
42757	42831	}
42758		- case 3597LLU: // completed if-then-else
	42832	+ case 3606LLU: // completed if-then-else
42759	42833	{
42760		- label = 3609LLU; // skip deleter
	42834	+ label = 3618LLU; // skip deleter
42761	42835	break;
42762	42836	}
42763		- case 3608LLU: // deleter
	42837	+ case 3617LLU: // deleter
42764	42838	{
42765	42839	// throw from procblock
42766	42840	if(!stack[base + 26])
42767	42841	{
42768		- label = 3592LLU; // skip, variable already deleted/unscoped
	42842	+ label = 3601LLU; // skip, variable already deleted/unscoped
42769	42843	break;
42770	42844	}
42771		- label = 3592LLU; // continue unrolling stack, delete next variable
	42845	+ label = 3601LLU; // continue unrolling stack, delete next variable
42772	42846	break;
42773	42847	}
42774		- case 3609LLU: // skipped deleter
	42848	+ case 3618LLU: // skipped deleter
42775	42849	{
42776		- label = 3611LLU; // skip deleter
	42850	+ label = 3620LLU; // skip deleter
42777	42851	break;
42778	42852	}
42779		- case 3610LLU: // deleter
	42853	+ case 3619LLU: // deleter
42780	42854	{
42781	42855	// throw from procblock
42782	42856	if(!stack[base + 27])
42783	42857	{
42784		- label = 3608LLU; // skip, variable already deleted/unscoped
	42858	+ label = 3617LLU; // skip, variable already deleted/unscoped
42785	42859	break;
42786	42860	}
42787		- label = 3608LLU; // continue unrolling stack, delete next variable
	42861	+ label = 3617LLU; // continue unrolling stack, delete next variable
42788	42862	break;
42789	42863	}
42790		- case 3611LLU: // skipped deleter
	42864	+ case 3620LLU: // skipped deleter
42791	42865	{
42792	42866	// call listtoelem from procblock
42793		- stack[base + 28LLU] = 3612LLU/throw to this address/;
	42867	+ stack[base + 28LLU] = 3621LLU/throw to this address/;
42794	42868	stack[base + 29LLU] = base;
42795		- stack[base + 30LLU] = 3613LLU;
	42869	+ stack[base + 30LLU] = 3622LLU;
42796	42870	// arguments for call to listtoelem
42797	42871	stack[base + 33LLU] = stack[base + 8]/fnid/;
42798	42872	stack[base + 34LLU] = stack[base + 19]/lookahead/;
42799	42873	// set stack-base & callee-address
42800	42874	base += 31LLU;
42801		- label = 3263LLU; // listtoelem
	42875	+ label = 3272LLU; // listtoelem
42802	42876	break;
42803	42877	}
42804		- case 3612LLU: // copy-back deleter (listtoelem to procblock)
	42878	+ case 3621LLU: // copy-back deleter (listtoelem to procblock)
42805	42879	{
42806	42880	// copy mutable arguments back from call to listtoelem
42807	42881	stack[base + 19]/lookahead/ = stack[base + 34LLU];
42808		- label = 3592LLU; // continue to roll stack
	42882	+ label = 3601LLU; // continue to roll stack
42809	42883	break;
42810	42884	}
42811		- case 3613LLU: // return from listtoelem to procblock
	42885	+ case 3622LLU: // return from listtoelem to procblock
42812	42886	{
42813	42887	// copy mutable arguments back from call to listtoelem
42814	42888	stack[base + 19]/lookahead/ = stack[base + 34LLU];

		@@ -42815,15 +42889,15 @@
42815	42889	// copy back results provided by call to listtoelem
42816	42890	stack[base + 26] = stack[base + 31LLU];
42817	42891	stack[base + 27] = stack[base + 32LLU];
42818		- label = 3615LLU; // skip deleter
	42892	+ label = 3624LLU; // skip deleter
42819	42893	break;
42820	42894	}
42821		- case 3614LLU: // deleter
	42895	+ case 3623LLU: // deleter
42822	42896	{
42823	42897	// throw from procblock
42824	42898	if(!stack[base + 28])
42825	42899	{
42826		- label = 3610LLU; // skip, variable already deleted/unscoped
	42900	+ label = 3619LLU; // skip, variable already deleted/unscoped
42827	42901	break;
42828	42902	}
42829	42903

		@@ -42832,7 +42906,7 @@
42832	42906	newstack[0] = (uint64_t)stack; // backup stack location
42833	42907	newstack[1] = 1234567890;
42834	42908	newstack[2] = base;
42835		- newstack[3] = 3616LLU;
	42909	+ newstack[3] = 3625LLU;
42836	42910	stack = newstack;
42837	42911	// set stack-base & callee-address
42838	42912	base = 4/deloffset/;

		@@ -42839,21 +42913,21 @@
42839	42913	label = 486LLU; // ~letdef
42840	42914	break;
42841	42915	}
42842		- case 3616LLU: // return from ~letdef to procblock
	42916	+ case 3625LLU: // return from ~letdef to procblock
42843	42917	{
42844	42918	stack = (uint64_t *)stack[0];
42845	42919	// releasing toplevel container
42846	42920	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
42847	42921
42848		- label = 3610LLU; // continue unrolling stack, delete next variable
	42922	+ label = 3619LLU; // continue unrolling stack, delete next variable
42849	42923	break;
42850	42924	}
42851		- case 3615LLU: // skipped deleter
	42925	+ case 3624LLU: // skipped deleter
42852	42926	{
42853	42927	// call FindLet from procblock
42854		- stack[base + 29LLU] = 3617LLU/throw to this address/;
	42928	+ stack[base + 29LLU] = 3626LLU/throw to this address/;
42855	42929	stack[base + 30LLU] = base;
42856		- stack[base + 31LLU] = 3618LLU;
	42930	+ stack[base + 31LLU] = 3627LLU;
42857	42931	// arguments for call to FindLet
42858	42932	stack[base + 33LLU] = stack[base + 8]/fnid/;
42859	42933	stack[base + 34LLU] = stack[base + 26]/listid/;

		@@ -42864,13 +42938,13 @@
42864	42938	label = 619LLU; // FindLet
42865	42939	break;
42866	42940	}
42867		- case 3617LLU: // copy-back deleter (FindLet to procblock)
	42941	+ case 3626LLU: // copy-back deleter (FindLet to procblock)
42868	42942	{
42869	42943	// copy mutable arguments back from call to FindLet
42870		- label = 3610LLU; // continue to roll stack
	42944	+ label = 3619LLU; // continue to roll stack
42871	42945	break;
42872	42946	}
42873		- case 3618LLU: // return from FindLet to procblock
	42947	+ case 3627LLU: // return from FindLet to procblock
42874	42948	{
42875	42949	// copy mutable arguments back from call to FindLet
42876	42950	// copy back results provided by call to FindLet

		@@ -42877,7 +42951,7 @@
42877	42951	stack[base + 28] = stack[base + 32LLU];
42878	42952	if(/letdef/0 != ((uint64_t )(stack[base + 28]/letdef*/))[0])
42879	42953	{
42880		- label = 3620LLU; // jump to alternative
	42954	+ label = 3629LLU; // jump to alternative
42881	42955	break;
42882	42956	}
42883	42957

		@@ -42891,28 +42965,28 @@
42891	42965	printf("%s", "\n { // if ");
42892	42966	if(!stack[base + 25]/consume/)
42893	42967	{
42894		- label = 3622LLU; // jump to alternative
	42968	+ label = 3631LLU; // jump to alternative
42895	42969	break;
42896	42970	}
42897	42971
42898	42972	// consequent
42899	42973	printf("%s", "pop");
42900		- label = 3623LLU; // consequent complete
	42974	+ label = 3632LLU; // consequent complete
42901	42975	break;
42902	42976	}
42903		- case 3622LLU: // alternative
	42977	+ case 3631LLU: // alternative
42904	42978	{
42905	42979	printf("%s", "next");
42906		- label = 3623LLU; // alternative complete
	42980	+ label = 3632LLU; // alternative complete
42907	42981	break;
42908	42982	}
42909		- case 3623LLU: // completed if-then-else
	42983	+ case 3632LLU: // completed if-then-else
42910	42984	{
42911	42985	printf("%s", "\n struct listnode list = (struct listnode )");
42912	42986	// call emitvaridx from procblock
42913		- stack[base + 34LLU] = 3624LLU/throw to this address/;
	42987	+ stack[base + 34LLU] = 3633LLU/throw to this address/;
42914	42988	stack[base + 35LLU] = base;
42915		- stack[base + 36LLU] = 3625LLU;
	42989	+ stack[base + 36LLU] = 3634LLU;
42916	42990	// arguments for call to emitvaridx
42917	42991	stack[base + 37LLU] = stack[base + 31]/listindex/;
42918	42992	// set stack-base & callee-address

		@@ -42920,20 +42994,20 @@
42920	42994	label = 745LLU; // emitvaridx
42921	42995	break;
42922	42996	}
42923		- case 3624LLU: // copy-back deleter (emitvaridx to procblock)
	42997	+ case 3633LLU: // copy-back deleter (emitvaridx to procblock)
42924	42998	{
42925	42999	// copy mutable arguments back from call to emitvaridx
42926		- label = 3621LLU; // continue to roll stack
	43000	+ label = 3630LLU; // continue to roll stack
42927	43001	break;
42928	43002	}
42929		- case 3625LLU: // return from emitvaridx to procblock
	43003	+ case 3634LLU: // return from emitvaridx to procblock
42930	43004	{
42931	43005	// copy mutable arguments back from call to emitvaridx
42932	43006	printf("%s", "/*");
42933	43007	// call printid from procblock
42934		- stack[base + 34LLU] = 3626LLU/throw to this address/;
	43008	+ stack[base + 34LLU] = 3635LLU/throw to this address/;
42935	43009	stack[base + 35LLU] = base;
42936		- stack[base + 36LLU] = 3627LLU;
	43010	+ stack[base + 36LLU] = 3636LLU;
42937	43011	// arguments for call to printid
42938	43012	stack[base + 37LLU] = stack[base + 30]/listname/;
42939	43013	// set stack-base & callee-address

		@@ -42941,26 +43015,26 @@
42941	43015	label = 18446744073709551587LLU; // printid
42942	43016	break;
42943	43017	}
42944		- case 3626LLU: // copy-back deleter (printid to procblock)
	43018	+ case 3635LLU: // copy-back deleter (printid to procblock)
42945	43019	{
42946	43020	// copy mutable arguments back from call to printid
42947		- label = 3621LLU; // continue to roll stack
	43021	+ label = 3630LLU; // continue to roll stack
42948	43022	break;
42949	43023	}
42950		- case 3627LLU: // return from printid to procblock
	43024	+ case 3636LLU: // return from printid to procblock
42951	43025	{
42952	43026	// copy mutable arguments back from call to printid
42953	43027	printf("%s", "*/;");
42954	43028	printf("%s", "\n if(!list)");
42955		- label = 3629LLU; // skip deleter
	43029	+ label = 3638LLU; // skip deleter
42956	43030	break;
42957	43031	}
42958		- case 3628LLU: // deleter
	43032	+ case 3637LLU: // deleter
42959	43033	{
42960	43034	// throw from procblock
42961	43035	if(!stack[base + 34])
42962	43036	{
42963		- label = 3621LLU; // skip, variable already deleted/unscoped
	43037	+ label = 3630LLU; // skip, variable already deleted/unscoped
42964	43038	break;
42965	43039	}
42966	43040

		@@ -42969,7 +43043,7 @@
42969	43043	newstack[0] = (uint64_t)stack; // backup stack location
42970	43044	newstack[1] = 1234567890;
42971	43045	newstack[2] = base;
42972		- newstack[3] = 3630LLU;
	43046	+ newstack[3] = 3639LLU;
42973	43047	stack = newstack;
42974	43048	// set stack-base & callee-address
42975	43049	base = 4/deloffset/;

		@@ -42976,21 +43050,21 @@
42976	43050	label = 562LLU; // ~scope
42977	43051	break;
42978	43052	}
42979		- case 3630LLU: // return from ~scope to procblock
	43053	+ case 3639LLU: // return from ~scope to procblock
42980	43054	{
42981	43055	stack = (uint64_t *)stack[0];
42982	43056	// releasing toplevel container
42983	43057	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 34] - sizeof(uint64_t) 4));
42984	43058
42985		- label = 3621LLU; // continue unrolling stack, delete next variable
	43059	+ label = 3630LLU; // continue unrolling stack, delete next variable
42986	43060	break;
42987	43061	}
42988		- case 3629LLU: // skipped deleter
	43062	+ case 3638LLU: // skipped deleter
42989	43063	{
42990	43064	// call linkscope from procblock
42991		- stack[base + 35LLU] = 3631LLU/throw to this address/;
	43065	+ stack[base + 35LLU] = 3640LLU/throw to this address/;
42992	43066	stack[base + 36LLU] = base;
42993		- stack[base + 37LLU] = 3632LLU;
	43067	+ stack[base + 37LLU] = 3641LLU;
42994	43068	// arguments for call to linkscope
42995	43069	stack[base + 39LLU] = stack[base + 3]/scope/;
42996	43070	// set stack-base & callee-address

		@@ -42998,13 +43072,13 @@
42998	43072	label = 589LLU; // linkscope
42999	43073	break;
43000	43074	}
43001		- case 3631LLU: // copy-back deleter (linkscope to procblock)
	43075	+ case 3640LLU: // copy-back deleter (linkscope to procblock)
43002	43076	{
43003	43077	// copy mutable arguments back from call to linkscope
43004		- label = 3621LLU; // continue to roll stack
	43078	+ label = 3630LLU; // continue to roll stack
43005	43079	break;
43006	43080	}
43007		- case 3632LLU: // return from linkscope to procblock
	43081	+ case 3641LLU: // return from linkscope to procblock
43008	43082	{
43009	43083	// copy mutable arguments back from call to linkscope
43010	43084	// copy back results provided by call to linkscope

		@@ -43023,26 +43097,26 @@
43023	43097	/scopes/stack[base + 2] = (uint64_t)list;
43024	43098	MOVE(&list->data, &stack[base + 34]/newscope/);
43025	43099	}
43026		- label = 3634LLU; // skip deleter
	43100	+ label = 3643LLU; // skip deleter
43027	43101	break;
43028	43102	}
43029		- case 3633LLU: // deleter
	43103	+ case 3642LLU: // deleter
43030	43104	{
43031	43105	// throw from procblock
43032	43106	if(!stack[base + 34])
43033	43107	{
43034		- label = 3621LLU; // skip, variable already deleted/unscoped
	43108	+ label = 3630LLU; // skip, variable already deleted/unscoped
43035	43109	break;
43036	43110	}
43037		- label = 3621LLU; // continue unrolling stack, delete next variable
	43111	+ label = 3630LLU; // continue unrolling stack, delete next variable
43038	43112	break;
43039	43113	}
43040		- case 3634LLU: // skipped deleter
	43114	+ case 3643LLU: // skipped deleter
43041	43115	{
43042	43116	// call getdeladdr from procblock
43043		- stack[base + 35LLU] = 3635LLU/throw to this address/;
	43117	+ stack[base + 35LLU] = 3644LLU/throw to this address/;
43044	43118	stack[base + 36LLU] = base;
43045		- stack[base + 37LLU] = 3636LLU;
	43119	+ stack[base + 37LLU] = 3645LLU;
43046	43120	// arguments for call to getdeladdr
43047	43121	stack[base + 39LLU] = stack[base + 3]/scope/;
43048	43122	// set stack-base & callee-address

		@@ -43050,21 +43124,21 @@
43050	43124	label = 596LLU; // getdeladdr
43051	43125	break;
43052	43126	}
43053		- case 3635LLU: // copy-back deleter (getdeladdr to procblock)
	43127	+ case 3644LLU: // copy-back deleter (getdeladdr to procblock)
43054	43128	{
43055	43129	// copy mutable arguments back from call to getdeladdr
43056		- label = 3621LLU; // continue to roll stack
	43130	+ label = 3630LLU; // continue to roll stack
43057	43131	break;
43058	43132	}
43059		- case 3636LLU: // return from getdeladdr to procblock
	43133	+ case 3645LLU: // return from getdeladdr to procblock
43060	43134	{
43061	43135	// copy mutable arguments back from call to getdeladdr
43062	43136	// copy back results provided by call to getdeladdr
43063	43137	stack[base + 34] = stack[base + 38LLU];
43064	43138	// call add from procblock
43065		- stack[base + 35LLU] = 3637LLU/throw to this address/;
	43139	+ stack[base + 35LLU] = 3646LLU/throw to this address/;
43066	43140	stack[base + 36LLU] = base;
43067		- stack[base + 37LLU] = 3638LLU;
	43141	+ stack[base + 37LLU] = 3647LLU;
43068	43142	// arguments for call to add
43069	43143	stack[base + 39LLU] = 1LLU;
43070	43144	stack[base + 40LLU] = stack[base + 17]/label/;

		@@ -43073,43 +43147,43 @@
43073	43147	label = 18446744073709551605LLU; // add
43074	43148	break;
43075	43149	}
43076		- case 3637LLU: // copy-back deleter (add to procblock)
	43150	+ case 3646LLU: // copy-back deleter (add to procblock)
43077	43151	{
43078	43152	// copy mutable arguments back from call to add
43079		- label = 3633LLU; // continue to roll stack
	43153	+ label = 3642LLU; // continue to roll stack
43080	43154	break;
43081	43155	}
43082		- case 3638LLU: // return from add to procblock
	43156	+ case 3647LLU: // return from add to procblock
43083	43157	{
43084	43158	// copy mutable arguments back from call to add
43085	43159	// copy back results provided by call to add
43086	43160	stack[base + 17] = stack[base + 38LLU];
43087		- label = 3640LLU; // skip deleter
	43161	+ label = 3649LLU; // skip deleter
43088	43162	break;
43089	43163	}
43090		- case 3639LLU: // deleter
	43164	+ case 3648LLU: // deleter
43091	43165	{
43092	43166	// throw from procblock
43093	43167	if(!stack[base + 35])
43094	43168	{
43095		- label = 3633LLU; // skip, variable already deleted/unscoped
	43169	+ label = 3642LLU; // skip, variable already deleted/unscoped
43096	43170	break;
43097	43171	}
43098		- label = 3633LLU; // continue unrolling stack, delete next variable
	43172	+ label = 3642LLU; // continue unrolling stack, delete next variable
43099	43173	break;
43100	43174	}
43101		- case 3640LLU: // skipped deleter
	43175	+ case 3649LLU: // skipped deleter
43102	43176	{
43103	43177	stack[base + 35] = stack[base + 17]/label/;
43104		- label = 3642LLU; // skip deleter
	43178	+ label = 3651LLU; // skip deleter
43105	43179	break;
43106	43180	}
43107		- case 3641LLU: // deleter
	43181	+ case 3650LLU: // deleter
43108	43182	{
43109	43183	// throw from procblock
43110	43184	if(!stack[base + 36])
43111	43185	{
43112		- label = 3639LLU; // skip, variable already deleted/unscoped
	43186	+ label = 3648LLU; // skip, variable already deleted/unscoped
43113	43187	break;
43114	43188	}
43115	43189

		@@ -43118,7 +43192,7 @@
43118	43192	newstack[0] = (uint64_t)stack; // backup stack location
43119	43193	newstack[1] = 1234567890;
43120	43194	newstack[2] = base;
43121		- newstack[3] = 3643LLU;
	43195	+ newstack[3] = 3652LLU;
43122	43196	stack = newstack;
43123	43197	// set stack-base & callee-address
43124	43198	base = 4/deloffset/;

		@@ -43125,21 +43199,21 @@
43125	43199	label = 562LLU; // ~scope
43126	43200	break;
43127	43201	}
43128		- case 3643LLU: // return from ~scope to procblock
	43202	+ case 3652LLU: // return from ~scope to procblock
43129	43203	{
43130	43204	stack = (uint64_t *)stack[0];
43131	43205	// releasing toplevel container
43132	43206	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
43133	43207
43134		- label = 3639LLU; // continue unrolling stack, delete next variable
	43208	+ label = 3648LLU; // continue unrolling stack, delete next variable
43135	43209	break;
43136	43210	}
43137		- case 3642LLU: // skipped deleter
	43211	+ case 3651LLU: // skipped deleter
43138	43212	{
43139	43213	// call chainscope from procblock
43140		- stack[base + 37LLU] = 3644LLU/throw to this address/;
	43214	+ stack[base + 37LLU] = 3653LLU/throw to this address/;
43141	43215	stack[base + 38LLU] = base;
43142		- stack[base + 39LLU] = 3645LLU;
	43216	+ stack[base + 39LLU] = 3654LLU;
43143	43217	// arguments for call to chainscope
43144	43218	stack[base + 41LLU] = stack[base + 35]/labelfail/;
43145	43219	// set stack-base & callee-address

		@@ -43147,13 +43221,13 @@
43147	43221	label = 579LLU; // chainscope
43148	43222	break;
43149	43223	}
43150		- case 3644LLU: // copy-back deleter (chainscope to procblock)
	43224	+ case 3653LLU: // copy-back deleter (chainscope to procblock)
43151	43225	{
43152	43226	// copy mutable arguments back from call to chainscope
43153		- label = 3639LLU; // continue to roll stack
	43227	+ label = 3648LLU; // continue to roll stack
43154	43228	break;
43155	43229	}
43156		- case 3645LLU: // return from chainscope to procblock
	43230	+ case 3654LLU: // return from chainscope to procblock
43157	43231	{
43158	43232	// copy mutable arguments back from call to chainscope
43159	43233	// copy back results provided by call to chainscope

		@@ -43174,7 +43248,7 @@
43174	43248	}
43175	43249	if(/typelist/1 != ((uint64_t )(stack[base + 29]/listtype*/))[0])
43176	43250	{
43177		- label = 3647LLU; // jump to alternative
	43251	+ label = 3656LLU; // jump to alternative
43178	43252	break;
43179	43253	}
43180	43254

		@@ -43181,42 +43255,42 @@
43181	43255	/subtype/stack[base + 36] = ((uint64_t *)(stack[base + 29]/listtype/))[1][0]/subtype*/;
43182	43256
43183	43257	// case
43184		- label = 3650LLU; // skip deleter
	43258	+ label = 3659LLU; // skip deleter
43185	43259	break;
43186	43260	}
43187		- case 3649LLU: // deleter
	43261	+ case 3658LLU: // deleter
43188	43262	{
43189	43263	// throw from procblock
43190	43264	if(!stack[base + 37])
43191	43265	{
43192		- label = 3648LLU; // skip, variable already deleted/unscoped
	43266	+ label = 3657LLU; // skip, variable already deleted/unscoped
43193	43267	break;
43194	43268	}
43195		- label = 3648LLU; // continue unrolling stack, delete next variable
	43269	+ label = 3657LLU; // continue unrolling stack, delete next variable
43196	43270	break;
43197	43271	}
43198		- case 3650LLU: // skipped deleter
	43272	+ case 3659LLU: // skipped deleter
43199	43273	{
43200		- label = 3652LLU; // skip deleter
	43274	+ label = 3661LLU; // skip deleter
43201	43275	break;
43202	43276	}
43203		- case 3651LLU: // deleter
	43277	+ case 3660LLU: // deleter
43204	43278	{
43205	43279	// throw from procblock
43206	43280	if(!stack[base + 38])
43207	43281	{
43208		- label = 3648LLU; // skip, variable already deleted/unscoped
	43282	+ label = 3657LLU; // skip, variable already deleted/unscoped
43209	43283	break;
43210	43284	}
43211		- label = 3648LLU; // continue unrolling stack, delete next variable
	43285	+ label = 3657LLU; // continue unrolling stack, delete next variable
43212	43286	break;
43213	43287	}
43214		- case 3652LLU: // skipped deleter
	43288	+ case 3661LLU: // skipped deleter
43215	43289	{
43216	43290	// call isparam from procblock
43217		- stack[base + 39LLU] = 3653LLU/throw to this address/;
	43291	+ stack[base + 39LLU] = 3662LLU/throw to this address/;
43218	43292	stack[base + 40LLU] = base;
43219		- stack[base + 41LLU] = 3654LLU;
	43293	+ stack[base + 41LLU] = 3663LLU;
43220	43294	// arguments for call to isparam
43221	43295	stack[base + 43LLU] = stack[base + 10]/fnrescount/;
43222	43296	stack[base + 44LLU] = stack[base + 11]/fnargcount/;

		@@ -43226,13 +43300,13 @@
43226	43300	label = 1635LLU; // isparam
43227	43301	break;
43228	43302	}
43229		- case 3653LLU: // copy-back deleter (isparam to procblock)
	43303	+ case 3662LLU: // copy-back deleter (isparam to procblock)
43230	43304	{
43231	43305	// copy mutable arguments back from call to isparam
43232		- label = 3648LLU; // continue to roll stack
	43306	+ label = 3657LLU; // continue to roll stack
43233	43307	break;
43234	43308	}
43235		- case 3654LLU: // return from isparam to procblock
	43309	+ case 3663LLU: // return from isparam to procblock
43236	43310	{
43237	43311	// copy mutable arguments back from call to isparam
43238	43312	// copy back results provided by call to isparam

		@@ -43239,37 +43313,37 @@
43239	43313	stack[base + 38] = stack[base + 42LLU];
43240	43314	if(!stack[base + 32]/listmut/)
43241	43315	{
43242		- label = 3655LLU; // jump to alternative
	43316	+ label = 3664LLU; // jump to alternative
43243	43317	break;
43244	43318	}
43245	43319
43246	43320	// consequent
43247		- label = 3658LLU; // skip deleter
	43321	+ label = 3667LLU; // skip deleter
43248	43322	break;
43249	43323	}
43250		- case 3657LLU: // deleter
	43324	+ case 3666LLU: // deleter
43251	43325	{
43252	43326	// throw from procblock
43253	43327	if(!stack[base + 37])
43254	43328	{
43255		- label = 3651LLU; // skip, variable already deleted/unscoped
	43329	+ label = 3660LLU; // skip, variable already deleted/unscoped
43256	43330	break;
43257	43331	}
43258		- label = 3651LLU; // continue unrolling stack, delete next variable
	43332	+ label = 3660LLU; // continue unrolling stack, delete next variable
43259	43333	break;
43260	43334	}
43261		- case 3658LLU: // skipped deleter
	43335	+ case 3667LLU: // skipped deleter
43262	43336	{
43263	43337	stack[base + 37] = 0;
43264		- label = 3656LLU; // consequent complete
	43338	+ label = 3665LLU; // consequent complete
43265	43339	break;
43266	43340	}
43267		- case 3655LLU: // alternative
	43341	+ case 3664LLU: // alternative
43268	43342	{
43269	43343	// call or from procblock
43270		- stack[base + 39LLU] = 3659LLU/throw to this address/;
	43344	+ stack[base + 39LLU] = 3668LLU/throw to this address/;
43271	43345	stack[base + 40LLU] = base;
43272		- stack[base + 41LLU] = 3660LLU;
	43346	+ stack[base + 41LLU] = 3669LLU;
43273	43347	// arguments for call to or
43274	43348	stack[base + 43LLU] = stack[base + 33]/substruct/;
43275	43349	stack[base + 44LLU] = stack[base + 38]/listparam/;

		@@ -43278,42 +43352,42 @@
43278	43352	label = 18446744073709551611LLU; // or
43279	43353	break;
43280	43354	}
43281		- case 3659LLU: // copy-back deleter (or to procblock)
	43355	+ case 3668LLU: // copy-back deleter (or to procblock)
43282	43356	{
43283	43357	// copy mutable arguments back from call to or
43284		- label = 3651LLU; // continue to roll stack
	43358	+ label = 3660LLU; // continue to roll stack
43285	43359	break;
43286	43360	}
43287		- case 3660LLU: // return from or to procblock
	43361	+ case 3669LLU: // return from or to procblock
43288	43362	{
43289	43363	// copy mutable arguments back from call to or
43290	43364	// copy back results provided by call to or
43291	43365	stack[base + 37] = stack[base + 42LLU];
43292		- label = 3656LLU; // alternative complete
	43366	+ label = 3665LLU; // alternative complete
43293	43367	break;
43294	43368	}
43295		- case 3656LLU: // completed if-then-else
	43369	+ case 3665LLU: // completed if-then-else
43296	43370	{
43297		- label = 3662LLU; // skip deleter
	43371	+ label = 3671LLU; // skip deleter
43298	43372	break;
43299	43373	}
43300		- case 3661LLU: // deleter
	43374	+ case 3670LLU: // deleter
43301	43375	{
43302	43376	// throw from procblock
43303	43377	if(!stack[base + 38])
43304	43378	{
43305		- label = 3649LLU; // skip, variable already deleted/unscoped
	43379	+ label = 3658LLU; // skip, variable already deleted/unscoped
43306	43380	break;
43307	43381	}
43308		- label = 3649LLU; // continue unrolling stack, delete next variable
	43382	+ label = 3658LLU; // continue unrolling stack, delete next variable
43309	43383	break;
43310	43384	}
43311		- case 3662LLU: // skipped deleter
	43385	+ case 3671LLU: // skipped deleter
43312	43386	{
43313	43387	// call newvarraw from procblock
43314		- stack[base + 39LLU] = 3663LLU/throw to this address/;
	43388	+ stack[base + 39LLU] = 3672LLU/throw to this address/;
43315	43389	stack[base + 40LLU] = base;
43316		- stack[base + 41LLU] = 3664LLU;
	43390	+ stack[base + 41LLU] = 3673LLU;
43317	43391	// arguments for call to newvarraw
43318	43392	stack[base + 43LLU] = stack[base + 36]/subtype/;
43319	43393	stack[base + 44LLU] = stack[base + 27]/elemid/;

		@@ -43329,16 +43403,16 @@
43329	43403	label = 759LLU; // newvarraw
43330	43404	break;
43331	43405	}
43332		- case 3663LLU: // copy-back deleter (newvarraw to procblock)
	43406	+ case 3672LLU: // copy-back deleter (newvarraw to procblock)
43333	43407	{
43334	43408	// copy mutable arguments back from call to newvarraw
43335	43409	stack[base + 3]/scope/ = stack[base + 50LLU];
43336	43410	stack[base + 18]/varcount/ = stack[base + 49LLU];
43337	43411	stack[base + 12]/fnmaxcount/ = stack[base + 48LLU];
43338		- label = 3649LLU; // continue to roll stack
	43412	+ label = 3658LLU; // continue to roll stack
43339	43413	break;
43340	43414	}
43341		- case 3664LLU: // return from newvarraw to procblock
	43415	+ case 3673LLU: // return from newvarraw to procblock
43342	43416	{
43343	43417	// copy mutable arguments back from call to newvarraw
43344	43418	stack[base + 3]/scope/ = stack[base + 50LLU];

		@@ -43349,9 +43423,9 @@
43349	43423	printf("%s", "\n {");
43350	43424	printf("%s", "\n label = ");
43351	43425	// call printnr from procblock
43352		- stack[base + 39LLU] = 3665LLU/throw to this address/;
	43426	+ stack[base + 39LLU] = 3674LLU/throw to this address/;
43353	43427	stack[base + 40LLU] = base;
43354		- stack[base + 41LLU] = 3666LLU;
	43428	+ stack[base + 41LLU] = 3675LLU;
43355	43429	// arguments for call to printnr
43356	43430	stack[base + 42LLU] = stack[base + 23]/labelalt/;
43357	43431	// set stack-base & callee-address

		@@ -43359,13 +43433,13 @@
43359	43433	label = 18446744073709551590LLU; // printnr
43360	43434	break;
43361	43435	}
43362		- case 3665LLU: // copy-back deleter (printnr to procblock)
	43436	+ case 3674LLU: // copy-back deleter (printnr to procblock)
43363	43437	{
43364	43438	// copy mutable arguments back from call to printnr
43365		- label = 3661LLU; // continue to roll stack
	43439	+ label = 3670LLU; // continue to roll stack
43366	43440	break;
43367	43441	}
43368		- case 3666LLU: // return from printnr to procblock
	43442	+ case 3675LLU: // return from printnr to procblock
43369	43443	{
43370	43444	// copy mutable arguments back from call to printnr
43371	43445	printf("%s", "LLU; // jump to alternative");

		@@ -43374,9 +43448,9 @@
43374	43448	printf("%s", "\n");
43375	43449	printf("%s", "\n // consequent");
43376	43450	// call matchsym from procblock
43377		- stack[base + 39LLU] = 3667LLU/throw to this address/;
	43451	+ stack[base + 39LLU] = 3676LLU/throw to this address/;
43378	43452	stack[base + 40LLU] = base;
43379		- stack[base + 41LLU] = 3668LLU;
	43453	+ stack[base + 41LLU] = 3677LLU;
43380	43454	// arguments for call to matchsym
43381	43455	stack[base + 42LLU] = stack[base + 8]/fnid/;
43382	43456	stack[base + 43LLU] = 123LLU;

		@@ -43386,14 +43460,14 @@
43386	43460	label = 246LLU; // matchsym
43387	43461	break;
43388	43462	}
43389		- case 3667LLU: // copy-back deleter (matchsym to procblock)
	43463	+ case 3676LLU: // copy-back deleter (matchsym to procblock)
43390	43464	{
43391	43465	// copy mutable arguments back from call to matchsym
43392	43466	stack[base + 19]/lookahead/ = stack[base + 44LLU];
43393		- label = 3661LLU; // continue to roll stack
	43467	+ label = 3670LLU; // continue to roll stack
43394	43468	break;
43395	43469	}
43396		- case 3668LLU: // return from matchsym to procblock
	43470	+ case 3677LLU: // return from matchsym to procblock
43397	43471	{
43398	43472	// copy mutable arguments back from call to matchsym
43399	43473	stack[base + 19]/lookahead/ = stack[base + 44LLU];

		@@ -43400,9 +43474,9 @@
43400	43474	printf("%s", "\n struct listnode *next = list->next;");
43401	43475	printf("%s", "\n /*");
43402	43476	// call printid from procblock
43403		- stack[base + 39LLU] = 3669LLU/throw to this address/;
	43477	+ stack[base + 39LLU] = 3678LLU/throw to this address/;
43404	43478	stack[base + 40LLU] = base;
43405		- stack[base + 41LLU] = 3670LLU;
	43479	+ stack[base + 41LLU] = 3679LLU;
43406	43480	// arguments for call to printid
43407	43481	stack[base + 42LLU] = stack[base + 27]/elemid/;
43408	43482	// set stack-base & callee-address

		@@ -43410,20 +43484,20 @@
43410	43484	label = 18446744073709551587LLU; // printid
43411	43485	break;
43412	43486	}
43413		- case 3669LLU: // copy-back deleter (printid to procblock)
	43487	+ case 3678LLU: // copy-back deleter (printid to procblock)
43414	43488	{
43415	43489	// copy mutable arguments back from call to printid
43416		- label = 3661LLU; // continue to roll stack
	43490	+ label = 3670LLU; // continue to roll stack
43417	43491	break;
43418	43492	}
43419		- case 3670LLU: // return from printid to procblock
	43493	+ case 3679LLU: // return from printid to procblock
43420	43494	{
43421	43495	// copy mutable arguments back from call to printid
43422	43496	printf("%s", "*/");
43423	43497	// call emitvaridx from procblock
43424		- stack[base + 39LLU] = 3671LLU/throw to this address/;
	43498	+ stack[base + 39LLU] = 3680LLU/throw to this address/;
43425	43499	stack[base + 40LLU] = base;
43426		- stack[base + 41LLU] = 3672LLU;
	43500	+ stack[base + 41LLU] = 3681LLU;
43427	43501	// arguments for call to emitvaridx
43428	43502	stack[base + 42LLU] = stack[base + 38]/elemindex/;
43429	43503	// set stack-base & callee-address

		@@ -43431,19 +43505,19 @@
43431	43505	label = 745LLU; // emitvaridx
43432	43506	break;
43433	43507	}
43434		- case 3671LLU: // copy-back deleter (emitvaridx to procblock)
	43508	+ case 3680LLU: // copy-back deleter (emitvaridx to procblock)
43435	43509	{
43436	43510	// copy mutable arguments back from call to emitvaridx
43437		- label = 3661LLU; // continue to roll stack
	43511	+ label = 3670LLU; // continue to roll stack
43438	43512	break;
43439	43513	}
43440		- case 3672LLU: // return from emitvaridx to procblock
	43514	+ case 3681LLU: // return from emitvaridx to procblock
43441	43515	{
43442	43516	// copy mutable arguments back from call to emitvaridx
43443	43517	printf("%s", " = list->data;");
43444	43518	if(!stack[base + 25]/consume/)
43445	43519	{
43446		- label = 3673LLU; // jump to alternative
	43520	+ label = 3682LLU; // jump to alternative
43447	43521	break;
43448	43522	}
43449	43523

		@@ -43451,9 +43525,9 @@
43451	43525	printf("%s", "\n Free(1, sizeof(struct listnode), list);");
43452	43526	printf("%s", "\n /*");
43453	43527	// call printid from procblock
43454		- stack[base + 39LLU] = 3675LLU/throw to this address/;
	43528	+ stack[base + 39LLU] = 3684LLU/throw to this address/;
43455	43529	stack[base + 40LLU] = base;
43456		- stack[base + 41LLU] = 3676LLU;
	43530	+ stack[base + 41LLU] = 3685LLU;
43457	43531	// arguments for call to printid
43458	43532	stack[base + 42LLU] = stack[base + 30]/listname/;
43459	43533	// set stack-base & callee-address

		@@ -43461,20 +43535,20 @@
43461	43535	label = 18446744073709551587LLU; // printid
43462	43536	break;
43463	43537	}
43464		- case 3675LLU: // copy-back deleter (printid to procblock)
	43538	+ case 3684LLU: // copy-back deleter (printid to procblock)
43465	43539	{
43466	43540	// copy mutable arguments back from call to printid
43467		- label = 3661LLU; // continue to roll stack
	43541	+ label = 3670LLU; // continue to roll stack
43468	43542	break;
43469	43543	}
43470		- case 3676LLU: // return from printid to procblock
	43544	+ case 3685LLU: // return from printid to procblock
43471	43545	{
43472	43546	// copy mutable arguments back from call to printid
43473	43547	printf("%s", "*/");
43474	43548	// call emitvaridx from procblock
43475		- stack[base + 39LLU] = 3677LLU/throw to this address/;
	43549	+ stack[base + 39LLU] = 3686LLU/throw to this address/;
43476	43550	stack[base + 40LLU] = base;
43477		- stack[base + 41LLU] = 3678LLU;
	43551	+ stack[base + 41LLU] = 3687LLU;
43478	43552	// arguments for call to emitvaridx
43479	43553	stack[base + 42LLU] = stack[base + 31]/listindex/;
43480	43554	// set stack-base & callee-address

		@@ -43482,33 +43556,33 @@
43482	43556	label = 745LLU; // emitvaridx
43483	43557	break;
43484	43558	}
43485		- case 3677LLU: // copy-back deleter (emitvaridx to procblock)
	43559	+ case 3686LLU: // copy-back deleter (emitvaridx to procblock)
43486	43560	{
43487	43561	// copy mutable arguments back from call to emitvaridx
43488		- label = 3661LLU; // continue to roll stack
	43562	+ label = 3670LLU; // continue to roll stack
43489	43563	break;
43490	43564	}
43491		- case 3678LLU: // return from emitvaridx to procblock
	43565	+ case 3687LLU: // return from emitvaridx to procblock
43492	43566	{
43493	43567	// copy mutable arguments back from call to emitvaridx
43494	43568	printf("%s", " = (uint64_t)next;");
43495	43569	if(!stack[base + 32]/listmut/)
43496	43570	{
43497		- label = 3679LLU; // jump to alternative
	43571	+ label = 3688LLU; // jump to alternative
43498	43572	break;
43499	43573	}
43500	43574
43501	43575	// consequent
43502		- label = 3680LLU; // consequent complete
	43576	+ label = 3689LLU; // consequent complete
43503	43577	break;
43504	43578	}
43505		- case 3679LLU: // alternative
	43579	+ case 3688LLU: // alternative
43506	43580	{
43507	43581	fprintf(stderr, "%s", "in function ");
43508	43582	// call reportid from procblock
43509		- stack[base + 39LLU] = 3681LLU/throw to this address/;
	43583	+ stack[base + 39LLU] = 3690LLU/throw to this address/;
43510	43584	stack[base + 40LLU] = base;
43511		- stack[base + 41LLU] = 3682LLU;
	43585	+ stack[base + 41LLU] = 3691LLU;
43512	43586	// arguments for call to reportid
43513	43587	stack[base + 42LLU] = stack[base + 8]/fnid/;
43514	43588	// set stack-base & callee-address

		@@ -43516,21 +43590,21 @@
43516	43590	label = 18446744073709551586LLU; // reportid
43517	43591	break;
43518	43592	}
43519		- case 3681LLU: // copy-back deleter (reportid to procblock)
	43593	+ case 3690LLU: // copy-back deleter (reportid to procblock)
43520	43594	{
43521	43595	// copy mutable arguments back from call to reportid
43522		- label = 3661LLU; // continue to roll stack
	43596	+ label = 3670LLU; // continue to roll stack
43523	43597	break;
43524	43598	}
43525		- case 3682LLU: // return from reportid to procblock
	43599	+ case 3691LLU: // return from reportid to procblock
43526	43600	{
43527	43601	// copy mutable arguments back from call to reportid
43528	43602	fprintf(stderr, "%s", ": ");
43529	43603	fprintf(stderr, "%s", "can't pop from CONSTANT list ");
43530	43604	// call reportid from procblock
43531		- stack[base + 39LLU] = 3683LLU/throw to this address/;
	43605	+ stack[base + 39LLU] = 3692LLU/throw to this address/;
43532	43606	stack[base + 40LLU] = base;
43533		- stack[base + 41LLU] = 3684LLU;
	43607	+ stack[base + 41LLU] = 3693LLU;
43534	43608	// arguments for call to reportid
43535	43609	stack[base + 42LLU] = stack[base + 30]/listname/;
43536	43610	// set stack-base & callee-address

		@@ -43538,13 +43612,13 @@
43538	43612	label = 18446744073709551586LLU; // reportid
43539	43613	break;
43540	43614	}
43541		- case 3683LLU: // copy-back deleter (reportid to procblock)
	43615	+ case 3692LLU: // copy-back deleter (reportid to procblock)
43542	43616	{
43543	43617	// copy mutable arguments back from call to reportid
43544		- label = 3661LLU; // continue to roll stack
	43618	+ label = 3670LLU; // continue to roll stack
43545	43619	break;
43546	43620	}
43547		- case 3684LLU: // return from reportid to procblock
	43621	+ case 3693LLU: // return from reportid to procblock
43548	43622	{
43549	43623	// copy mutable arguments back from call to reportid
43550	43624	fprintf(stderr, "%s", " of type ");

		@@ -43551,7 +43625,7 @@
43551	43625	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
43552	43626	if(!newstack)
43553	43627	{
43554		- label = 3661LLU; // throw: begin to unroll stack
	43628	+ label = 3670LLU; // throw: begin to unroll stack
43555	43629	break;
43556	43630	}
43557	43631

		@@ -43558,9 +43632,9 @@
43558	43632	newstack[10LLU] = 9876543210LLU; // overflow-marker
43559	43633	// call reporttype from procblock
43560	43634	newstack[0] = (uint64_t)stack; // backup stack location
43561		- newstack[1] = 3685LLU;
	43635	+ newstack[1] = 3694LLU;
43562	43636	newstack[2] = base;
43563		- newstack[3] = 3686LLU;
	43637	+ newstack[3] = 3695LLU;
43564	43638	// arguments for call to reporttype
43565	43639	newstack[4LLU] = stack[base + 29]/listtype/;
43566	43640	stack = newstack;

		@@ -43569,7 +43643,7 @@
43569	43643	label = 330LLU; // reporttype
43570	43644	break;
43571	43645	}
43572		- case 3685LLU: // copy-back deleter (reporttype to procblock)
	43646	+ case 3694LLU: // copy-back deleter (reporttype to procblock)
43573	43647	{
43574	43648	uint64_t oldstack = (uint64_t )stack[0];
43575	43649	// copy mutable arguments back from call to reporttype

		@@ -43580,10 +43654,10 @@
43580	43654	}
43581	43655	Free(10LLU + 1, sizeof(uint64_t), stack);
43582	43656	stack = oldstack;
43583		- label = 3661LLU; // continue to unroll stack
	43657	+ label = 3670LLU; // continue to unroll stack
43584	43658	break;
43585	43659	}
43586		- case 3686LLU: // return from reporttype to procblock
	43660	+ case 3695LLU: // return from reporttype to procblock
43587	43661	{
43588	43662	uint64_t oldstack = (uint64_t )stack[0];
43589	43663	// copy mutable arguments back from call to reporttype

		@@ -43596,40 +43670,40 @@
43596	43670	stack = oldstack;
43597	43671	fprintf(stderr, "%s", "\n");
43598	43672	{
43599		- label = 3661LLU; // throw: begin to unroll stack
	43673	+ label = 3670LLU; // throw: begin to unroll stack
43600	43674	break;
43601	43675	}
43602	43676
43603		- label = 3680LLU; // alternative complete
	43677	+ label = 3689LLU; // alternative complete
43604	43678	break;
43605	43679	}
43606		- case 3680LLU: // completed if-then-else
	43680	+ case 3689LLU: // completed if-then-else
43607	43681	{
43608		- label = 3674LLU; // consequent complete
	43682	+ label = 3683LLU; // consequent complete
43609	43683	break;
43610	43684	}
43611		- case 3673LLU: // alternative
	43685	+ case 3682LLU: // alternative
43612	43686	{
43613		- label = 3688LLU; // skip deleter
	43687	+ label = 3697LLU; // skip deleter
43614	43688	break;
43615	43689	}
43616		- case 3687LLU: // deleter
	43690	+ case 3696LLU: // deleter
43617	43691	{
43618	43692	// throw from procblock
43619	43693	if(!stack[base + 39])
43620	43694	{
43621		- label = 3661LLU; // skip, variable already deleted/unscoped
	43695	+ label = 3670LLU; // skip, variable already deleted/unscoped
43622	43696	break;
43623	43697	}
43624		- label = 3661LLU; // continue unrolling stack, delete next variable
	43698	+ label = 3670LLU; // continue unrolling stack, delete next variable
43625	43699	break;
43626	43700	}
43627		- case 3688LLU: // skipped deleter
	43701	+ case 3697LLU: // skipped deleter
43628	43702	{
43629	43703	// call newvarraw from procblock
43630		- stack[base + 40LLU] = 3689LLU/throw to this address/;
	43704	+ stack[base + 40LLU] = 3698LLU/throw to this address/;
43631	43705	stack[base + 41LLU] = base;
43632		- stack[base + 42LLU] = 3690LLU;
	43706	+ stack[base + 42LLU] = 3699LLU;
43633	43707	// arguments for call to newvarraw
43634	43708	stack[base + 44LLU] = stack[base + 29]/listtype/;
43635	43709	stack[base + 45LLU] = stack[base + 30]/listname/;

		@@ -43645,16 +43719,16 @@
43645	43719	label = 759LLU; // newvarraw
43646	43720	break;
43647	43721	}
43648		- case 3689LLU: // copy-back deleter (newvarraw to procblock)
	43722	+ case 3698LLU: // copy-back deleter (newvarraw to procblock)
43649	43723	{
43650	43724	// copy mutable arguments back from call to newvarraw
43651	43725	stack[base + 3]/scope/ = stack[base + 51LLU];
43652	43726	stack[base + 18]/varcount/ = stack[base + 50LLU];
43653	43727	stack[base + 12]/fnmaxcount/ = stack[base + 49LLU];
43654		- label = 3661LLU; // continue to roll stack
	43728	+ label = 3670LLU; // continue to roll stack
43655	43729	break;
43656	43730	}
43657		- case 3690LLU: // return from newvarraw to procblock
	43731	+ case 3699LLU: // return from newvarraw to procblock
43658	43732	{
43659	43733	// copy mutable arguments back from call to newvarraw
43660	43734	stack[base + 3]/scope/ = stack[base + 51LLU];

		@@ -43664,9 +43738,9 @@
43664	43738	stack[base + 39] = stack[base + 43LLU];
43665	43739	printf("%s", "\n /*");
43666	43740	// call printid from procblock
43667		- stack[base + 40LLU] = 3691LLU/throw to this address/;
	43741	+ stack[base + 40LLU] = 3700LLU/throw to this address/;
43668	43742	stack[base + 41LLU] = base;
43669		- stack[base + 42LLU] = 3692LLU;
	43743	+ stack[base + 42LLU] = 3701LLU;
43670	43744	// arguments for call to printid
43671	43745	stack[base + 43LLU] = stack[base + 30]/listname/;
43672	43746	// set stack-base & callee-address

		@@ -43674,20 +43748,20 @@
43674	43748	label = 18446744073709551587LLU; // printid
43675	43749	break;
43676	43750	}
43677		- case 3691LLU: // copy-back deleter (printid to procblock)
	43751	+ case 3700LLU: // copy-back deleter (printid to procblock)
43678	43752	{
43679	43753	// copy mutable arguments back from call to printid
43680		- label = 3687LLU; // continue to roll stack
	43754	+ label = 3696LLU; // continue to roll stack
43681	43755	break;
43682	43756	}
43683		- case 3692LLU: // return from printid to procblock
	43757	+ case 3701LLU: // return from printid to procblock
43684	43758	{
43685	43759	// copy mutable arguments back from call to printid
43686	43760	printf("%s", "*/");
43687	43761	// call emitvaridx from procblock
43688		- stack[base + 40LLU] = 3693LLU/throw to this address/;
	43762	+ stack[base + 40LLU] = 3702LLU/throw to this address/;
43689	43763	stack[base + 41LLU] = base;
43690		- stack[base + 42LLU] = 3694LLU;
	43764	+ stack[base + 42LLU] = 3703LLU;
43691	43765	// arguments for call to emitvaridx
43692	43766	stack[base + 43LLU] = stack[base + 39]/restindex/;
43693	43767	// set stack-base & callee-address

		@@ -43695,25 +43769,25 @@
43695	43769	label = 745LLU; // emitvaridx
43696	43770	break;
43697	43771	}
43698		- case 3693LLU: // copy-back deleter (emitvaridx to procblock)
	43772	+ case 3702LLU: // copy-back deleter (emitvaridx to procblock)
43699	43773	{
43700	43774	// copy mutable arguments back from call to emitvaridx
43701		- label = 3687LLU; // continue to roll stack
	43775	+ label = 3696LLU; // continue to roll stack
43702	43776	break;
43703	43777	}
43704		- case 3694LLU: // return from emitvaridx to procblock
	43778	+ case 3703LLU: // return from emitvaridx to procblock
43705	43779	{
43706	43780	// copy mutable arguments back from call to emitvaridx
43707	43781	printf("%s", " = (uint64_t)next;");
43708		- label = 3674LLU; // alternative complete
	43782	+ label = 3683LLU; // alternative complete
43709	43783	break;
43710	43784	}
43711		- case 3674LLU: // completed if-then-else
	43785	+ case 3683LLU: // completed if-then-else
43712	43786	{
43713	43787	printf("%s", "\n }");
43714	43788	if(!stack[base + 21]/returnflag/)
43715	43789	{
43716		- label = 3695LLU; // jump to alternative
	43790	+ label = 3704LLU; // jump to alternative
43717	43791	break;
43718	43792	}
43719	43793

		@@ -43721,7 +43795,7 @@
43721	43795	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
43722	43796	if(!newstack)
43723	43797	{
43724		- label = 3661LLU; // throw: begin to unroll stack
	43798	+ label = 3670LLU; // throw: begin to unroll stack
43725	43799	break;
43726	43800	}
43727	43801

		@@ -43728,9 +43802,9 @@
43728	43802	newstack[160LLU] = 9876543210LLU; // overflow-marker
43729	43803	// call procblock from procblock
43730	43804	newstack[0] = (uint64_t)stack; // backup stack location
43731		- newstack[1] = 3697LLU;
	43805	+ newstack[1] = 3706LLU;
43732	43806	newstack[2] = base;
43733		- newstack[3] = 3698LLU;
	43807	+ newstack[3] = 3707LLU;
43734	43808	// arguments for call to procblock
43735	43809	newstack[4LLU] = stack[base + 0]/fndefs/;
43736	43810	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -43753,10 +43827,10 @@
43753	43827	stack = newstack;
43754	43828	// set stack-base & callee-address
43755	43829	base = 4/deloffset/;
43756		- label = 3429LLU; // procblock
	43830	+ label = 3438LLU; // procblock
43757	43831	break;
43758	43832	}
43759		- case 3697LLU: // copy-back deleter (procblock to procblock)
	43833	+ case 3706LLU: // copy-back deleter (procblock to procblock)
43760	43834	{
43761	43835	uint64_t oldstack = (uint64_t )stack[0];
43762	43836	// copy mutable arguments back from call to procblock

		@@ -43773,10 +43847,10 @@
43773	43847	}
43774	43848	Free(160LLU + 1, sizeof(uint64_t), stack);
43775	43849	stack = oldstack;
43776		- label = 3661LLU; // continue to unroll stack
	43850	+ label = 3670LLU; // continue to unroll stack
43777	43851	break;
43778	43852	}
43779		- case 3698LLU: // return from procblock to procblock
	43853	+ case 3707LLU: // return from procblock to procblock
43780	43854	{
43781	43855	uint64_t oldstack = (uint64_t )stack[0];
43782	43856	// copy mutable arguments back from call to procblock

		@@ -43793,31 +43867,31 @@
43793	43867	}
43794	43868	Free(160LLU + 1, sizeof(uint64_t), stack);
43795	43869	stack = oldstack;
43796		- label = 3696LLU; // consequent complete
	43870	+ label = 3705LLU; // consequent complete
43797	43871	break;
43798	43872	}
43799		- case 3695LLU: // alternative
	43873	+ case 3704LLU: // alternative
43800	43874	{
43801		- label = 3700LLU; // skip deleter
	43875	+ label = 3709LLU; // skip deleter
43802	43876	break;
43803	43877	}
43804		- case 3699LLU: // deleter
	43878	+ case 3708LLU: // deleter
43805	43879	{
43806	43880	// throw from procblock
43807	43881	if(!stack[base + 39])
43808	43882	{
43809		- label = 3661LLU; // skip, variable already deleted/unscoped
	43883	+ label = 3670LLU; // skip, variable already deleted/unscoped
43810	43884	break;
43811	43885	}
43812	43886	// delete list
43813		- label = 3701LLU; // start to repeat
	43887	+ label = 3710LLU; // start to repeat
43814	43888	break;
43815	43889	}
43816		- case 3701LLU: // repeat from here
	43890	+ case 3710LLU: // repeat from here
43817	43891	{
43818	43892	if(!stack[base + 39])
43819	43893	{
43820		- label = 3702LLU; // break loop
	43894	+ label = 3711LLU; // break loop
43821	43895	break;
43822	43896	}
43823	43897

		@@ -43828,7 +43902,7 @@
43828	43902	newstack[0] = (uint64_t)stack; // backup stack location
43829	43903	newstack[1] = 1234567890;
43830	43904	newstack[2] = base;
43831		- newstack[3] = 3703LLU;
	43905	+ newstack[3] = 3712LLU;
43832	43906	stack = newstack;
43833	43907	// set stack-base & callee-address
43834	43908	base = 4/deloffset/;

		@@ -43835,7 +43909,7 @@
43835	43909	label = 399LLU; // ~typeidx
43836	43910	break;
43837	43911	}
43838		- case 3703LLU: // return from ~typeidx to procblock
	43912	+ case 3712LLU: // return from ~typeidx to procblock
43839	43913	{
43840	43914	stack = (uint64_t *)stack[0];
43841	43915	// releasing toplevel container

		@@ -43846,21 +43920,21 @@
43846	43920	stack[base + 39] = (uint64_t)list->next;
43847	43921	Free(1, sizeof(struct listnode), list);
43848	43922	}
43849		- label = 3701LLU; // repeat
	43923	+ label = 3710LLU; // repeat
43850	43924	break;
43851	43925	}
43852		- case 3702LLU: // loop finished
	43926	+ case 3711LLU: // loop finished
43853	43927	{
43854		- label = 3661LLU; // continue unrolling stack, delete next variable
	43928	+ label = 3670LLU; // continue unrolling stack, delete next variable
43855	43929	break;
43856	43930	}
43857		- case 3700LLU: // skipped deleter
	43931	+ case 3709LLU: // skipped deleter
43858	43932	{
43859	43933	stack[base + 39] = 0;
43860	43934	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
43861	43935	if(!newstack)
43862	43936	{
43863		- label = 3699LLU; // throw: begin to unroll stack
	43937	+ label = 3708LLU; // throw: begin to unroll stack
43864	43938	break;
43865	43939	}
43866	43940

		@@ -43867,9 +43941,9 @@
43867	43941	newstack[160LLU] = 9876543210LLU; // overflow-marker
43868	43942	// call procblock from procblock
43869	43943	newstack[0] = (uint64_t)stack; // backup stack location
43870		- newstack[1] = 3704LLU;
	43944	+ newstack[1] = 3713LLU;
43871	43945	newstack[2] = base;
43872		- newstack[3] = 3705LLU;
	43946	+ newstack[3] = 3714LLU;
43873	43947	// arguments for call to procblock
43874	43948	newstack[4LLU] = stack[base + 0]/fndefs/;
43875	43949	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -43892,10 +43966,10 @@
43892	43966	stack = newstack;
43893	43967	// set stack-base & callee-address
43894	43968	base = 4/deloffset/;
43895		- label = 3429LLU; // procblock
	43969	+ label = 3438LLU; // procblock
43896	43970	break;
43897	43971	}
43898		- case 3704LLU: // copy-back deleter (procblock to procblock)
	43972	+ case 3713LLU: // copy-back deleter (procblock to procblock)
43899	43973	{
43900	43974	uint64_t oldstack = (uint64_t )stack[0];
43901	43975	// copy mutable arguments back from call to procblock

		@@ -43912,10 +43986,10 @@
43912	43986	}
43913	43987	Free(160LLU + 1, sizeof(uint64_t), stack);
43914	43988	stack = oldstack;
43915		- label = 3699LLU; // continue to unroll stack
	43989	+ label = 3708LLU; // continue to unroll stack
43916	43990	break;
43917	43991	}
43918		- case 3705LLU: // return from procblock to procblock
	43992	+ case 3714LLU: // return from procblock to procblock
43919	43993	{
43920	43994	uint64_t oldstack = (uint64_t )stack[0];
43921	43995	// copy mutable arguments back from call to procblock

		@@ -43933,14 +44007,14 @@
43933	44007	Free(160LLU + 1, sizeof(uint64_t), stack);
43934	44008	stack = oldstack;
43935	44009	// delete list
43936		- label = 3706LLU; // start to repeat
	44010	+ label = 3715LLU; // start to repeat
43937	44011	break;
43938	44012	}
43939		- case 3706LLU: // repeat from here
	44013	+ case 3715LLU: // repeat from here
43940	44014	{
43941	44015	if(!stack[base + 39])
43942	44016	{
43943		- label = 3707LLU; // break loop
	44017	+ label = 3716LLU; // break loop
43944	44018	break;
43945	44019	}
43946	44020

		@@ -43951,7 +44025,7 @@
43951	44025	newstack[0] = (uint64_t)stack; // backup stack location
43952	44026	newstack[1] = 1234567890;
43953	44027	newstack[2] = base;
43954		- newstack[3] = 3708LLU;
	44028	+ newstack[3] = 3717LLU;
43955	44029	stack = newstack;
43956	44030	// set stack-base & callee-address
43957	44031	base = 4/deloffset/;

		@@ -43958,7 +44032,7 @@
43958	44032	label = 399LLU; // ~typeidx
43959	44033	break;
43960	44034	}
43961		- case 3708LLU: // return from ~typeidx to procblock
	44035	+ case 3717LLU: // return from ~typeidx to procblock
43962	44036	{
43963	44037	stack = (uint64_t *)stack[0];
43964	44038	// releasing toplevel container

		@@ -43969,27 +44043,27 @@
43969	44043	stack[base + 39] = (uint64_t)list->next;
43970	44044	Free(1, sizeof(struct listnode), list);
43971	44045	}
43972		- label = 3706LLU; // repeat
	44046	+ label = 3715LLU; // repeat
43973	44047	break;
43974	44048	}
43975		- case 3707LLU: // loop finished
	44049	+ case 3716LLU: // loop finished
43976	44050	{
43977		- label = 3696LLU; // alternative complete
	44051	+ label = 3705LLU; // alternative complete
43978	44052	break;
43979	44053	}
43980		- case 3696LLU: // completed if-then-else
	44054	+ case 3705LLU: // completed if-then-else
43981	44055	{
43982	44056	if(!stack[base + 25]/consume/)
43983	44057	{
43984		- label = 3709LLU; // jump to alternative
	44058	+ label = 3718LLU; // jump to alternative
43985	44059	break;
43986	44060	}
43987	44061
43988	44062	// consequent
43989	44063	// call closescope from procblock
43990		- stack[base + 39LLU] = 3711LLU/throw to this address/;
	44064	+ stack[base + 39LLU] = 3720LLU/throw to this address/;
43991	44065	stack[base + 40LLU] = base;
43992		- stack[base + 41LLU] = 3712LLU;
	44066	+ stack[base + 41LLU] = 3721LLU;
43993	44067	// arguments for call to closescope
43994	44068	stack[base + 42LLU] = stack[base + 8]/fnid/;
43995	44069	stack[base + 43LLU] = stack[base + 1]/datadefs/;

		@@ -43997,25 +44071,25 @@
43997	44071	stack[base + 45LLU] = stack[base + 17]/label/;
43998	44072	// set stack-base & callee-address
43999	44073	base += 42LLU;
44000		- label = 3190LLU; // closescope
	44074	+ label = 3199LLU; // closescope
44001	44075	break;
44002	44076	}
44003		- case 3711LLU: // copy-back deleter (closescope to procblock)
	44077	+ case 3720LLU: // copy-back deleter (closescope to procblock)
44004	44078	{
44005	44079	// copy mutable arguments back from call to closescope
44006	44080	stack[base + 17]/label/ = stack[base + 45LLU];
44007		- label = 3661LLU; // continue to roll stack
	44081	+ label = 3670LLU; // continue to roll stack
44008	44082	break;
44009	44083	}
44010		- case 3712LLU: // return from closescope to procblock
	44084	+ case 3721LLU: // return from closescope to procblock
44011	44085	{
44012	44086	// copy mutable arguments back from call to closescope
44013	44087	stack[base + 17]/label/ = stack[base + 45LLU];
44014	44088	printf("%s", "\n label = ");
44015	44089	// call printnr from procblock
44016		- stack[base + 39LLU] = 3713LLU/throw to this address/;
	44090	+ stack[base + 39LLU] = 3722LLU/throw to this address/;
44017	44091	stack[base + 40LLU] = base;
44018		- stack[base + 41LLU] = 3714LLU;
	44092	+ stack[base + 41LLU] = 3723LLU;
44019	44093	// arguments for call to printnr
44020	44094	stack[base + 42LLU] = stack[base + 24]/labelskip/;
44021	44095	// set stack-base & callee-address

		@@ -44023,13 +44097,13 @@
44023	44097	label = 18446744073709551590LLU; // printnr
44024	44098	break;
44025	44099	}
44026		- case 3713LLU: // copy-back deleter (printnr to procblock)
	44100	+ case 3722LLU: // copy-back deleter (printnr to procblock)
44027	44101	{
44028	44102	// copy mutable arguments back from call to printnr
44029		- label = 3661LLU; // continue to roll stack
	44103	+ label = 3670LLU; // continue to roll stack
44030	44104	break;
44031	44105	}
44032		- case 3714LLU: // return from printnr to procblock
	44106	+ case 3723LLU: // return from printnr to procblock
44033	44107	{
44034	44108	// copy mutable arguments back from call to printnr
44035	44109	printf("%s", "LLU; // consequent complete");

		@@ -44037,9 +44111,9 @@
44037	44111	printf("%s", "\n }");
44038	44112	printf("%s", "\n case ");
44039	44113	// call printnr from procblock
44040		- stack[base + 39LLU] = 3715LLU/throw to this address/;
	44114	+ stack[base + 39LLU] = 3724LLU/throw to this address/;
44041	44115	stack[base + 40LLU] = base;
44042		- stack[base + 41LLU] = 3716LLU;
	44116	+ stack[base + 41LLU] = 3725LLU;
44043	44117	// arguments for call to printnr
44044	44118	stack[base + 42LLU] = stack[base + 35]/labelfail/;
44045	44119	// set stack-base & callee-address

		@@ -44047,21 +44121,21 @@
44047	44121	label = 18446744073709551590LLU; // printnr
44048	44122	break;
44049	44123	}
44050		- case 3715LLU: // copy-back deleter (printnr to procblock)
	44124	+ case 3724LLU: // copy-back deleter (printnr to procblock)
44051	44125	{
44052	44126	// copy mutable arguments back from call to printnr
44053		- label = 3661LLU; // continue to roll stack
	44127	+ label = 3670LLU; // continue to roll stack
44054	44128	break;
44055	44129	}
44056		- case 3716LLU: // return from printnr to procblock
	44130	+ case 3725LLU: // return from printnr to procblock
44057	44131	{
44058	44132	// copy mutable arguments back from call to printnr
44059	44133	printf("%s", "LLU: // copy-back deleter (if pop)");
44060	44134	printf("%s", "\n {");
44061	44135	// call closescope from procblock
44062		- stack[base + 39LLU] = 3717LLU/throw to this address/;
	44136	+ stack[base + 39LLU] = 3726LLU/throw to this address/;
44063	44137	stack[base + 40LLU] = base;
44064		- stack[base + 41LLU] = 3718LLU;
	44138	+ stack[base + 41LLU] = 3727LLU;
44065	44139	// arguments for call to closescope
44066	44140	stack[base + 42LLU] = stack[base + 8]/fnid/;
44067	44141	stack[base + 43LLU] = stack[base + 1]/datadefs/;

		@@ -44069,25 +44143,25 @@
44069	44143	stack[base + 45LLU] = stack[base + 17]/label/;
44070	44144	// set stack-base & callee-address
44071	44145	base += 42LLU;
44072		- label = 3190LLU; // closescope
	44146	+ label = 3199LLU; // closescope
44073	44147	break;
44074	44148	}
44075		- case 3717LLU: // copy-back deleter (closescope to procblock)
	44149	+ case 3726LLU: // copy-back deleter (closescope to procblock)
44076	44150	{
44077	44151	// copy mutable arguments back from call to closescope
44078	44152	stack[base + 17]/label/ = stack[base + 45LLU];
44079		- label = 3661LLU; // continue to roll stack
	44153	+ label = 3670LLU; // continue to roll stack
44080	44154	break;
44081	44155	}
44082		- case 3718LLU: // return from closescope to procblock
	44156	+ case 3727LLU: // return from closescope to procblock
44083	44157	{
44084	44158	// copy mutable arguments back from call to closescope
44085	44159	stack[base + 17]/label/ = stack[base + 45LLU];
44086	44160	printf("%s", "\n label = ");
44087	44161	// call printnr from procblock
44088		- stack[base + 39LLU] = 3719LLU/throw to this address/;
	44162	+ stack[base + 39LLU] = 3728LLU/throw to this address/;
44089	44163	stack[base + 40LLU] = base;
44090		- stack[base + 41LLU] = 3720LLU;
	44164	+ stack[base + 41LLU] = 3729LLU;
44091	44165	// arguments for call to printnr
44092	44166	stack[base + 42LLU] = stack[base + 34]/labelthrow/;
44093	44167	// set stack-base & callee-address

		@@ -44095,13 +44169,13 @@
44095	44169	label = 18446744073709551590LLU; // printnr
44096	44170	break;
44097	44171	}
44098		- case 3719LLU: // copy-back deleter (printnr to procblock)
	44172	+ case 3728LLU: // copy-back deleter (printnr to procblock)
44099	44173	{
44100	44174	// copy mutable arguments back from call to printnr
44101		- label = 3661LLU; // continue to roll stack
	44175	+ label = 3670LLU; // continue to roll stack
44102	44176	break;
44103	44177	}
44104		- case 3720LLU: // return from printnr to procblock
	44178	+ case 3729LLU: // return from printnr to procblock
44105	44179	{
44106	44180	// copy mutable arguments back from call to printnr
44107	44181	printf("%s", "LLU; // consequent complete");

		@@ -44109,9 +44183,9 @@
44109	44183	printf("%s", "\n }");
44110	44184	printf("%s", "\n case ");
44111	44185	// call printnr from procblock
44112		- stack[base + 39LLU] = 3721LLU/throw to this address/;
	44186	+ stack[base + 39LLU] = 3730LLU/throw to this address/;
44113	44187	stack[base + 40LLU] = base;
44114		- stack[base + 41LLU] = 3722LLU;
	44188	+ stack[base + 41LLU] = 3731LLU;
44115	44189	// arguments for call to printnr
44116	44190	stack[base + 42LLU] = stack[base + 23]/labelalt/;
44117	44191	// set stack-base & callee-address

		@@ -44119,28 +44193,28 @@
44119	44193	label = 18446744073709551590LLU; // printnr
44120	44194	break;
44121	44195	}
44122		- case 3721LLU: // copy-back deleter (printnr to procblock)
	44196	+ case 3730LLU: // copy-back deleter (printnr to procblock)
44123	44197	{
44124	44198	// copy mutable arguments back from call to printnr
44125		- label = 3661LLU; // continue to roll stack
	44199	+ label = 3670LLU; // continue to roll stack
44126	44200	break;
44127	44201	}
44128		- case 3722LLU: // return from printnr to procblock
	44202	+ case 3731LLU: // return from printnr to procblock
44129	44203	{
44130	44204	// copy mutable arguments back from call to printnr
44131	44205	printf("%s", "LLU: // alternative");
44132	44206	printf("%s", "\n {");
44133		- label = 3710LLU; // consequent complete
	44207	+ label = 3719LLU; // consequent complete
44134	44208	break;
44135	44209	}
44136		- case 3709LLU: // alternative
	44210	+ case 3718LLU: // alternative
44137	44211	{
44138	44212	printf("%s", "\n { // copyback");
44139	44213	printf("%s", "\n struct listnode list = (struct listnode )");
44140	44214	// call emitvaridx from procblock
44141		- stack[base + 39LLU] = 3723LLU/throw to this address/;
	44215	+ stack[base + 39LLU] = 3732LLU/throw to this address/;
44142	44216	stack[base + 40LLU] = base;
44143		- stack[base + 41LLU] = 3724LLU;
	44217	+ stack[base + 41LLU] = 3733LLU;
44144	44218	// arguments for call to emitvaridx
44145	44219	stack[base + 42LLU] = stack[base + 31]/listindex/;
44146	44220	// set stack-base & callee-address

		@@ -44148,20 +44222,20 @@
44148	44222	label = 745LLU; // emitvaridx
44149	44223	break;
44150	44224	}
44151		- case 3723LLU: // copy-back deleter (emitvaridx to procblock)
	44225	+ case 3732LLU: // copy-back deleter (emitvaridx to procblock)
44152	44226	{
44153	44227	// copy mutable arguments back from call to emitvaridx
44154		- label = 3661LLU; // continue to roll stack
	44228	+ label = 3670LLU; // continue to roll stack
44155	44229	break;
44156	44230	}
44157		- case 3724LLU: // return from emitvaridx to procblock
	44231	+ case 3733LLU: // return from emitvaridx to procblock
44158	44232	{
44159	44233	// copy mutable arguments back from call to emitvaridx
44160	44234	printf("%s", "/*");
44161	44235	// call printid from procblock
44162		- stack[base + 39LLU] = 3725LLU/throw to this address/;
	44236	+ stack[base + 39LLU] = 3734LLU/throw to this address/;
44163	44237	stack[base + 40LLU] = base;
44164		- stack[base + 41LLU] = 3726LLU;
	44238	+ stack[base + 41LLU] = 3735LLU;
44165	44239	// arguments for call to printid
44166	44240	stack[base + 42LLU] = stack[base + 30]/listname/;
44167	44241	// set stack-base & callee-address

		@@ -44169,21 +44243,21 @@
44169	44243	label = 18446744073709551587LLU; // printid
44170	44244	break;
44171	44245	}
44172		- case 3725LLU: // copy-back deleter (printid to procblock)
	44246	+ case 3734LLU: // copy-back deleter (printid to procblock)
44173	44247	{
44174	44248	// copy mutable arguments back from call to printid
44175		- label = 3661LLU; // continue to roll stack
	44249	+ label = 3670LLU; // continue to roll stack
44176	44250	break;
44177	44251	}
44178		- case 3726LLU: // return from printid to procblock
	44252	+ case 3735LLU: // return from printid to procblock
44179	44253	{
44180	44254	// copy mutable arguments back from call to printid
44181	44255	printf("%s", "*/;");
44182	44256	printf("%s", "\n list->data = ");
44183	44257	// call emitvaridx from procblock
44184		- stack[base + 39LLU] = 3727LLU/throw to this address/;
	44258	+ stack[base + 39LLU] = 3736LLU/throw to this address/;
44185	44259	stack[base + 40LLU] = base;
44186		- stack[base + 41LLU] = 3728LLU;
	44260	+ stack[base + 41LLU] = 3737LLU;
44187	44261	// arguments for call to emitvaridx
44188	44262	stack[base + 42LLU] = stack[base + 38]/elemindex/;
44189	44263	// set stack-base & callee-address

		@@ -44191,21 +44265,21 @@
44191	44265	label = 745LLU; // emitvaridx
44192	44266	break;
44193	44267	}
44194		- case 3727LLU: // copy-back deleter (emitvaridx to procblock)
	44268	+ case 3736LLU: // copy-back deleter (emitvaridx to procblock)
44195	44269	{
44196	44270	// copy mutable arguments back from call to emitvaridx
44197		- label = 3661LLU; // continue to roll stack
	44271	+ label = 3670LLU; // continue to roll stack
44198	44272	break;
44199	44273	}
44200		- case 3728LLU: // return from emitvaridx to procblock
	44274	+ case 3737LLU: // return from emitvaridx to procblock
44201	44275	{
44202	44276	// copy mutable arguments back from call to emitvaridx
44203	44277	printf("%s", ";");
44204	44278	printf("%s", "\n list->next = (struct listnode *)");
44205	44279	// call emitvar from procblock
44206		- stack[base + 39LLU] = 3729LLU/throw to this address/;
	44280	+ stack[base + 39LLU] = 3738LLU/throw to this address/;
44207	44281	stack[base + 40LLU] = base;
44208		- stack[base + 41LLU] = 3730LLU;
	44282	+ stack[base + 41LLU] = 3739LLU;
44209	44283	// arguments for call to emitvar
44210	44284	stack[base + 42LLU] = stack[base + 8]/fnid/;
44211	44285	stack[base + 43LLU] = stack[base + 30]/listname/;

		@@ -44216,13 +44290,13 @@
44216	44290	label = 749LLU; // emitvar
44217	44291	break;
44218	44292	}
44219		- case 3729LLU: // copy-back deleter (emitvar to procblock)
	44293	+ case 3738LLU: // copy-back deleter (emitvar to procblock)
44220	44294	{
44221	44295	// copy mutable arguments back from call to emitvar
44222		- label = 3661LLU; // continue to roll stack
	44296	+ label = 3670LLU; // continue to roll stack
44223	44297	break;
44224	44298	}
44225		- case 3730LLU: // return from emitvar to procblock
	44299	+ case 3739LLU: // return from emitvar to procblock
44226	44300	{
44227	44301	// copy mutable arguments back from call to emitvar
44228	44302	printf("%s", ";");

		@@ -44229,9 +44303,9 @@
44229	44303	printf("%s", "\n }");
44230	44304	printf("%s", "\n label = ");
44231	44305	// call printnr from procblock
44232		- stack[base + 39LLU] = 3731LLU/throw to this address/;
	44306	+ stack[base + 39LLU] = 3740LLU/throw to this address/;
44233	44307	stack[base + 40LLU] = base;
44234		- stack[base + 41LLU] = 3732LLU;
	44308	+ stack[base + 41LLU] = 3741LLU;
44235	44309	// arguments for call to printnr
44236	44310	stack[base + 42LLU] = stack[base + 24]/labelskip/;
44237	44311	// set stack-base & callee-address

		@@ -44239,13 +44313,13 @@
44239	44313	label = 18446744073709551590LLU; // printnr
44240	44314	break;
44241	44315	}
44242		- case 3731LLU: // copy-back deleter (printnr to procblock)
	44316	+ case 3740LLU: // copy-back deleter (printnr to procblock)
44243	44317	{
44244	44318	// copy mutable arguments back from call to printnr
44245		- label = 3661LLU; // continue to roll stack
	44319	+ label = 3670LLU; // continue to roll stack
44246	44320	break;
44247	44321	}
44248		- case 3732LLU: // return from printnr to procblock
	44322	+ case 3741LLU: // return from printnr to procblock
44249	44323	{
44250	44324	// copy mutable arguments back from call to printnr
44251	44325	printf("%s", "LLU; // consequent complete");

		@@ -44253,9 +44327,9 @@
44253	44327	printf("%s", "\n }");
44254	44328	printf("%s", "\n case ");
44255	44329	// call printnr from procblock
44256		- stack[base + 39LLU] = 3733LLU/throw to this address/;
	44330	+ stack[base + 39LLU] = 3742LLU/throw to this address/;
44257	44331	stack[base + 40LLU] = base;
44258		- stack[base + 41LLU] = 3734LLU;
	44332	+ stack[base + 41LLU] = 3743LLU;
44259	44333	// arguments for call to printnr
44260	44334	stack[base + 42LLU] = stack[base + 23]/labelalt/;
44261	44335	// set stack-base & callee-address

		@@ -44263,40 +44337,40 @@
44263	44337	label = 18446744073709551590LLU; // printnr
44264	44338	break;
44265	44339	}
44266		- case 3733LLU: // copy-back deleter (printnr to procblock)
	44340	+ case 3742LLU: // copy-back deleter (printnr to procblock)
44267	44341	{
44268	44342	// copy mutable arguments back from call to printnr
44269		- label = 3661LLU; // continue to roll stack
	44343	+ label = 3670LLU; // continue to roll stack
44270	44344	break;
44271	44345	}
44272		- case 3734LLU: // return from printnr to procblock
	44346	+ case 3743LLU: // return from printnr to procblock
44273	44347	{
44274	44348	// copy mutable arguments back from call to printnr
44275	44349	printf("%s", "LLU: // alternative");
44276	44350	printf("%s", "\n {");
44277		- label = 3710LLU; // alternative complete
	44351	+ label = 3719LLU; // alternative complete
44278	44352	break;
44279	44353	}
44280		- case 3710LLU: // completed if-then-else
	44354	+ case 3719LLU: // completed if-then-else
44281	44355	{
44282	44356	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 36];
44283		- label = 3646LLU; // case complete
	44357	+ label = 3655LLU; // case complete
44284	44358	break;
44285	44359	}
44286		- case 3648LLU: // copy-back deleter (switch)
	44360	+ case 3657LLU: // copy-back deleter (switch)
44287	44361	{
44288	44362	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 36];
44289		- label = 3639LLU; // continue to unroll stack
	44363	+ label = 3648LLU; // continue to unroll stack
44290	44364	break;
44291	44365	}
44292		- case 3647LLU: // try next case
	44366	+ case 3656LLU: // try next case
44293	44367	{
44294	44368	// default
44295	44369	fprintf(stderr, "%s", "in function ");
44296	44370	// call reportid from procblock
44297		- stack[base + 36LLU] = 3735LLU/throw to this address/;
	44371	+ stack[base + 36LLU] = 3744LLU/throw to this address/;
44298	44372	stack[base + 37LLU] = base;
44299		- stack[base + 38LLU] = 3736LLU;
	44373	+ stack[base + 38LLU] = 3745LLU;
44300	44374	// arguments for call to reportid
44301	44375	stack[base + 39LLU] = stack[base + 8]/fnid/;
44302	44376	// set stack-base & callee-address

		@@ -44304,13 +44378,13 @@
44304	44378	label = 18446744073709551586LLU; // reportid
44305	44379	break;
44306	44380	}
44307		- case 3735LLU: // copy-back deleter (reportid to procblock)
	44381	+ case 3744LLU: // copy-back deleter (reportid to procblock)
44308	44382	{
44309	44383	// copy mutable arguments back from call to reportid
44310		- label = 3639LLU; // continue to roll stack
	44384	+ label = 3648LLU; // continue to roll stack
44311	44385	break;
44312	44386	}
44313		- case 3736LLU: // return from reportid to procblock
	44387	+ case 3745LLU: // return from reportid to procblock
44314	44388	{
44315	44389	// copy mutable arguments back from call to reportid
44316	44390	fprintf(stderr, "%s", ": ");

		@@ -44317,28 +44391,28 @@
44317	44391	fprintf(stderr, "%s", "can only ");
44318	44392	if(!stack[base + 25]/consume/)
44319	44393	{
44320		- label = 3737LLU; // jump to alternative
	44394	+ label = 3746LLU; // jump to alternative
44321	44395	break;
44322	44396	}
44323	44397
44324	44398	// consequent
44325	44399	printf("%s", "pop");
44326		- label = 3738LLU; // consequent complete
	44400	+ label = 3747LLU; // consequent complete
44327	44401	break;
44328	44402	}
44329		- case 3737LLU: // alternative
	44403	+ case 3746LLU: // alternative
44330	44404	{
44331	44405	printf("%s", "next");
44332		- label = 3738LLU; // alternative complete
	44406	+ label = 3747LLU; // alternative complete
44333	44407	break;
44334	44408	}
44335		- case 3738LLU: // completed if-then-else
	44409	+ case 3747LLU: // completed if-then-else
44336	44410	{
44337	44411	printf("%s", " from list but type of ");
44338	44412	// call reportid from procblock
44339		- stack[base + 36LLU] = 3739LLU/throw to this address/;
	44413	+ stack[base + 36LLU] = 3748LLU/throw to this address/;
44340	44414	stack[base + 37LLU] = base;
44341		- stack[base + 38LLU] = 3740LLU;
	44415	+ stack[base + 38LLU] = 3749LLU;
44342	44416	// arguments for call to reportid
44343	44417	stack[base + 39LLU] = stack[base + 30]/listname/;
44344	44418	// set stack-base & callee-address

		@@ -44346,13 +44420,13 @@
44346	44420	label = 18446744073709551586LLU; // reportid
44347	44421	break;
44348	44422	}
44349		- case 3739LLU: // copy-back deleter (reportid to procblock)
	44423	+ case 3748LLU: // copy-back deleter (reportid to procblock)
44350	44424	{
44351	44425	// copy mutable arguments back from call to reportid
44352		- label = 3639LLU; // continue to roll stack
	44426	+ label = 3648LLU; // continue to roll stack
44353	44427	break;
44354	44428	}
44355		- case 3740LLU: // return from reportid to procblock
	44429	+ case 3749LLU: // return from reportid to procblock
44356	44430	{
44357	44431	// copy mutable arguments back from call to reportid
44358	44432	fprintf(stderr, "%s", " is ");

		@@ -44359,7 +44433,7 @@
44359	44433	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
44360	44434	if(!newstack)
44361	44435	{
44362		- label = 3639LLU; // throw: begin to unroll stack
	44436	+ label = 3648LLU; // throw: begin to unroll stack
44363	44437	break;
44364	44438	}
44365	44439

		@@ -44366,9 +44440,9 @@
44366	44440	newstack[10LLU] = 9876543210LLU; // overflow-marker
44367	44441	// call reporttype from procblock
44368	44442	newstack[0] = (uint64_t)stack; // backup stack location
44369		- newstack[1] = 3741LLU;
	44443	+ newstack[1] = 3750LLU;
44370	44444	newstack[2] = base;
44371		- newstack[3] = 3742LLU;
	44445	+ newstack[3] = 3751LLU;
44372	44446	// arguments for call to reporttype
44373	44447	newstack[4LLU] = stack[base + 29]/listtype/;
44374	44448	stack = newstack;

		@@ -44377,7 +44451,7 @@
44377	44451	label = 330LLU; // reporttype
44378	44452	break;
44379	44453	}
44380		- case 3741LLU: // copy-back deleter (reporttype to procblock)
	44454	+ case 3750LLU: // copy-back deleter (reporttype to procblock)
44381	44455	{
44382	44456	uint64_t oldstack = (uint64_t )stack[0];
44383	44457	// copy mutable arguments back from call to reporttype

		@@ -44388,10 +44462,10 @@
44388	44462	}
44389	44463	Free(10LLU + 1, sizeof(uint64_t), stack);
44390	44464	stack = oldstack;
44391		- label = 3639LLU; // continue to unroll stack
	44465	+ label = 3648LLU; // continue to unroll stack
44392	44466	break;
44393	44467	}
44394		- case 3742LLU: // return from reporttype to procblock
	44468	+ case 3751LLU: // return from reporttype to procblock
44395	44469	{
44396	44470	uint64_t oldstack = (uint64_t )stack[0];
44397	44471	// copy mutable arguments back from call to reporttype

		@@ -44404,20 +44478,20 @@
44404	44478	stack = oldstack;
44405	44479	fprintf(stderr, "%s", "\n");
44406	44480	{
44407		- label = 3639LLU; // throw: begin to unroll stack
	44481	+ label = 3648LLU; // throw: begin to unroll stack
44408	44482	break;
44409	44483	}
44410	44484
44411		- label = 3646LLU; // default complete
	44485	+ label = 3655LLU; // default complete
44412	44486	break;
44413	44487	}
44414		- case 3646LLU: // completed switch
	44488	+ case 3655LLU: // completed switch
44415	44489	{
44416	44490	{ // if pop
44417	44491	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
44418	44492	if(!list)
44419	44493	{
44420		- label = 3743LLU; // jump to alternative
	44494	+ label = 3752LLU; // jump to alternative
44421	44495	break;
44422	44496	}
44423	44497

		@@ -44434,7 +44508,7 @@
44434	44508	newstack[0] = (uint64_t)stack; // backup stack location
44435	44509	newstack[1] = 1234567890;
44436	44510	newstack[2] = base;
44437		- newstack[3] = 3746LLU;
	44511	+ newstack[3] = 3755LLU;
44438	44512	stack = newstack;
44439	44513	// set stack-base & callee-address
44440	44514	base = 4/deloffset/;

		@@ -44441,16 +44515,16 @@
44441	44515	label = 562LLU; // ~scope
44442	44516	break;
44443	44517	}
44444		- case 3746LLU: // return from ~scope to procblock
	44518	+ case 3755LLU: // return from ~scope to procblock
44445	44519	{
44446	44520	stack = (uint64_t *)stack[0];
44447	44521	// releasing toplevel container
44448	44522	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
44449	44523
44450		- label = 3744LLU; // consequent complete
	44524	+ label = 3753LLU; // consequent complete
44451	44525	break;
44452	44526	}
44453		- case 3745LLU: // copy-back deleter (if pop)
	44527	+ case 3754LLU: // copy-back deleter (if pop)
44454	44528	{
44455	44529
44456	44530	uint64_t newstack = (uint64_t )(stack[base + 36] - sizeof(uint64_t) * 4);

		@@ -44458,7 +44532,7 @@
44458	44532	newstack[0] = (uint64_t)stack; // backup stack location
44459	44533	newstack[1] = 1234567890;
44460	44534	newstack[2] = base;
44461		- newstack[3] = 3747LLU;
	44535	+ newstack[3] = 3756LLU;
44462	44536	stack = newstack;
44463	44537	// set stack-base & callee-address
44464	44538	base = 4/deloffset/;

		@@ -44465,33 +44539,33 @@
44465	44539	label = 562LLU; // ~scope
44466	44540	break;
44467	44541	}
44468		- case 3747LLU: // return from ~scope to procblock
	44542	+ case 3756LLU: // return from ~scope to procblock
44469	44543	{
44470	44544	stack = (uint64_t *)stack[0];
44471	44545	// releasing toplevel container
44472	44546	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
44473	44547
44474		- label = 3639LLU; // consequent complete
	44548	+ label = 3648LLU; // consequent complete
44475	44549	break;
44476	44550	}
44477		- case 3743LLU: // alternative
	44551	+ case 3752LLU: // alternative
44478	44552	{
44479	44553	fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n");
44480	44554	{
44481		- label = 3639LLU; // throw: begin to unroll stack
	44555	+ label = 3648LLU; // throw: begin to unroll stack
44482	44556	break;
44483	44557	}
44484	44558
44485		- label = 3744LLU; // alternative complete
	44559	+ label = 3753LLU; // alternative complete
44486	44560	break;
44487	44561	}
44488		- case 3744LLU: // completed if-then-else
	44562	+ case 3753LLU: // completed if-then-else
44489	44563	{
44490	44564	{ // if pop
44491	44565	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
44492	44566	if(!list)
44493	44567	{
44494		- label = 3748LLU; // jump to alternative
	44568	+ label = 3757LLU; // jump to alternative
44495	44569	break;
44496	44570	}
44497	44571

		@@ -44508,7 +44582,7 @@
44508	44582	newstack[0] = (uint64_t)stack; // backup stack location
44509	44583	newstack[1] = 1234567890;
44510	44584	newstack[2] = base;
44511		- newstack[3] = 3751LLU;
	44585	+ newstack[3] = 3760LLU;
44512	44586	stack = newstack;
44513	44587	// set stack-base & callee-address
44514	44588	base = 4/deloffset/;

		@@ -44515,16 +44589,16 @@
44515	44589	label = 562LLU; // ~scope
44516	44590	break;
44517	44591	}
44518		- case 3751LLU: // return from ~scope to procblock
	44592	+ case 3760LLU: // return from ~scope to procblock
44519	44593	{
44520	44594	stack = (uint64_t *)stack[0];
44521	44595	// releasing toplevel container
44522	44596	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
44523	44597
44524		- label = 3749LLU; // consequent complete
	44598	+ label = 3758LLU; // consequent complete
44525	44599	break;
44526	44600	}
44527		- case 3750LLU: // copy-back deleter (if pop)
	44601	+ case 3759LLU: // copy-back deleter (if pop)
44528	44602	{
44529	44603
44530	44604	uint64_t newstack = (uint64_t )(stack[base + 36] - sizeof(uint64_t) * 4);

		@@ -44532,7 +44606,7 @@
44532	44606	newstack[0] = (uint64_t)stack; // backup stack location
44533	44607	newstack[1] = 1234567890;
44534	44608	newstack[2] = base;
44535		- newstack[3] = 3752LLU;
	44609	+ newstack[3] = 3761LLU;
44536	44610	stack = newstack;
44537	44611	// set stack-base & callee-address
44538	44612	base = 4/deloffset/;

		@@ -44539,27 +44613,27 @@
44539	44613	label = 562LLU; // ~scope
44540	44614	break;
44541	44615	}
44542		- case 3752LLU: // return from ~scope to procblock
	44616	+ case 3761LLU: // return from ~scope to procblock
44543	44617	{
44544	44618	stack = (uint64_t *)stack[0];
44545	44619	// releasing toplevel container
44546	44620	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 36] - sizeof(uint64_t) 4));
44547	44621
44548		- label = 3639LLU; // consequent complete
	44622	+ label = 3648LLU; // consequent complete
44549	44623	break;
44550	44624	}
44551		- case 3748LLU: // alternative
	44625	+ case 3757LLU: // alternative
44552	44626	{
44553	44627	fprintf(stderr, "%s", "INTERNAL ERROR popping scope\n");
44554	44628	{
44555		- label = 3639LLU; // throw: begin to unroll stack
	44629	+ label = 3648LLU; // throw: begin to unroll stack
44556	44630	break;
44557	44631	}
44558	44632
44559		- label = 3749LLU; // alternative complete
	44633	+ label = 3758LLU; // alternative complete
44560	44634	break;
44561	44635	}
44562		- case 3749LLU: // completed if-then-else
	44636	+ case 3758LLU: // completed if-then-else
44563	44637	{
44564	44638	((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33];
44565	44639	((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32];

		@@ -44566,10 +44640,10 @@
44566	44640	((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31];
44567	44641	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30];
44568	44642	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29];
44569		- label = 3619LLU; // case complete
	44643	+ label = 3628LLU; // case complete
44570	44644	break;
44571	44645	}
44572		- case 3621LLU: // copy-back deleter (switch)
	44646	+ case 3630LLU: // copy-back deleter (switch)
44573	44647	{
44574	44648	((uint64_t **)(stack[base + 28]))[1][4] = stack[base + 33];
44575	44649	((uint64_t **)(stack[base + 28]))[1][3] = stack[base + 32];

		@@ -44576,15 +44650,15 @@
44576	44650	((uint64_t **)(stack[base + 28]))[1][2] = stack[base + 31];
44577	44651	((uint64_t **)(stack[base + 28]))[1][1] = stack[base + 30];
44578	44652	((uint64_t **)(stack[base + 28]))[1][0] = stack[base + 29];
44579		- label = 3614LLU; // continue to unroll stack
	44653	+ label = 3623LLU; // continue to unroll stack
44580	44654	break;
44581	44655	}
44582		- case 3620LLU: // try next case
	44656	+ case 3629LLU: // try next case
44583	44657	{
44584	44658	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
44585	44659	exit(-1);
44586	44660	}
44587		- case 3619LLU: // completed switch
	44661	+ case 3628LLU: // completed switch
44588	44662	{
44589	44663
44590	44664	uint64_t newstack = (uint64_t )(stack[base + 28] - sizeof(uint64_t) * 4);

		@@ -44592,7 +44666,7 @@
44592	44666	newstack[0] = (uint64_t)stack; // backup stack location
44593	44667	newstack[1] = 1234567890;
44594	44668	newstack[2] = base;
44595		- newstack[3] = 3753LLU;
	44669	+ newstack[3] = 3762LLU;
44596	44670	stack = newstack;
44597	44671	// set stack-base & callee-address
44598	44672	base = 4/deloffset/;

		@@ -44599,20 +44673,20 @@
44599	44673	label = 486LLU; // ~letdef
44600	44674	break;
44601	44675	}
44602		- case 3753LLU: // return from ~letdef to procblock
	44676	+ case 3762LLU: // return from ~letdef to procblock
44603	44677	{
44604	44678	stack = (uint64_t *)stack[0];
44605	44679	// releasing toplevel container
44606	44680	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 28] - sizeof(uint64_t) 4));
44607	44681
44608		- label = 3551LLU; // alternative complete
	44682	+ label = 3560LLU; // alternative complete
44609	44683	break;
44610	44684	}
44611		- case 3551LLU: // completed if-then-else
	44685	+ case 3560LLU: // completed if-then-else
44612	44686	{
44613	44687	if(!stack[base + 22]/when/)
44614	44688	{
44615		- label = 3754LLU; // jump to alternative
	44689	+ label = 3763LLU; // jump to alternative
44616	44690	break;
44617	44691	}
44618	44692

		@@ -44619,7 +44693,7 @@
44619	44693	// consequent
44620	44694	if(!stack[base + 21]/returnflag/)
44621	44695	{
44622		- label = 3756LLU; // jump to alternative
	44696	+ label = 3765LLU; // jump to alternative
44623	44697	break;
44624	44698	}
44625	44699

		@@ -44626,9 +44700,9 @@
44626	44700	// consequent
44627	44701	fprintf(stderr, "%s", "in function ");
44628	44702	// call reportid from procblock
44629		- stack[base + 25LLU] = 3758LLU/throw to this address/;
	44703	+ stack[base + 25LLU] = 3767LLU/throw to this address/;
44630	44704	stack[base + 26LLU] = base;
44631		- stack[base + 27LLU] = 3759LLU;
	44705	+ stack[base + 27LLU] = 3768LLU;
44632	44706	// arguments for call to reportid
44633	44707	stack[base + 28LLU] = stack[base + 8]/fnid/;
44634	44708	// set stack-base & callee-address

		@@ -44636,41 +44710,41 @@
44636	44710	label = 18446744073709551586LLU; // reportid
44637	44711	break;
44638	44712	}
44639		- case 3758LLU: // copy-back deleter (reportid to procblock)
	44713	+ case 3767LLU: // copy-back deleter (reportid to procblock)
44640	44714	{
44641	44715	// copy mutable arguments back from call to reportid
44642		- label = 3544LLU; // continue to roll stack
	44716	+ label = 3553LLU; // continue to roll stack
44643	44717	break;
44644	44718	}
44645		- case 3759LLU: // return from reportid to procblock
	44719	+ case 3768LLU: // return from reportid to procblock
44646	44720	{
44647	44721	// copy mutable arguments back from call to reportid
44648	44722	fprintf(stderr, "%s", ": ");
44649	44723	fprintf(stderr, "%s", "can't return from when\n");
44650	44724	{
44651		- label = 3544LLU; // throw: begin to unroll stack
	44725	+ label = 3553LLU; // throw: begin to unroll stack
44652	44726	break;
44653	44727	}
44654	44728
44655		- label = 3757LLU; // consequent complete
	44729	+ label = 3766LLU; // consequent complete
44656	44730	break;
44657	44731	}
44658		- case 3756LLU: // alternative
	44732	+ case 3765LLU: // alternative
44659	44733	{
44660		- label = 3757LLU; // alternative complete
	44734	+ label = 3766LLU; // alternative complete
44661	44735	break;
44662	44736	}
44663		- case 3757LLU: // completed if-then-else
	44737	+ case 3766LLU: // completed if-then-else
44664	44738	{
44665		- label = 3755LLU; // consequent complete
	44739	+ label = 3764LLU; // consequent complete
44666	44740	break;
44667	44741	}
44668		- case 3754LLU: // alternative
	44742	+ case 3763LLU: // alternative
44669	44743	{
44670	44744	// call matchid from procblock
44671		- stack[base + 25LLU] = 3760LLU/throw to this address/;
	44745	+ stack[base + 25LLU] = 3769LLU/throw to this address/;
44672	44746	stack[base + 26LLU] = base;
44673		- stack[base + 27LLU] = 3761LLU;
	44747	+ stack[base + 27LLU] = 3770LLU;
44674	44748	// arguments for call to matchid
44675	44749	stack[base + 28LLU] = stack[base + 8]/fnid/;
44676	44750	stack[base + 29LLU] = 587642785557905408LLU;

		@@ -44680,21 +44754,21 @@
44680	44754	label = 256LLU; // matchid
44681	44755	break;
44682	44756	}
44683		- case 3760LLU: // copy-back deleter (matchid to procblock)
	44757	+ case 3769LLU: // copy-back deleter (matchid to procblock)
44684	44758	{
44685	44759	// copy mutable arguments back from call to matchid
44686	44760	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44687		- label = 3544LLU; // continue to roll stack
	44761	+ label = 3553LLU; // continue to roll stack
44688	44762	break;
44689	44763	}
44690		- case 3761LLU: // return from matchid to procblock
	44764	+ case 3770LLU: // return from matchid to procblock
44691	44765	{
44692	44766	// copy mutable arguments back from call to matchid
44693	44767	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44694	44768	// call matchsym from procblock
44695		- stack[base + 25LLU] = 3762LLU/throw to this address/;
	44769	+ stack[base + 25LLU] = 3771LLU/throw to this address/;
44696	44770	stack[base + 26LLU] = base;
44697		- stack[base + 27LLU] = 3763LLU;
	44771	+ stack[base + 27LLU] = 3772LLU;
44698	44772	// arguments for call to matchsym
44699	44773	stack[base + 28LLU] = stack[base + 8]/fnid/;
44700	44774	stack[base + 29LLU] = 123LLU;

		@@ -44704,20 +44778,20 @@
44704	44778	label = 246LLU; // matchsym
44705	44779	break;
44706	44780	}
44707		- case 3762LLU: // copy-back deleter (matchsym to procblock)
	44781	+ case 3771LLU: // copy-back deleter (matchsym to procblock)
44708	44782	{
44709	44783	// copy mutable arguments back from call to matchsym
44710	44784	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44711		- label = 3544LLU; // continue to roll stack
	44785	+ label = 3553LLU; // continue to roll stack
44712	44786	break;
44713	44787	}
44714		- case 3763LLU: // return from matchsym to procblock
	44788	+ case 3772LLU: // return from matchsym to procblock
44715	44789	{
44716	44790	// copy mutable arguments back from call to matchsym
44717	44791	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44718	44792	if(!stack[base + 21]/returnflag/)
44719	44793	{
44720		- label = 3764LLU; // jump to alternative
	44794	+ label = 3773LLU; // jump to alternative
44721	44795	break;
44722	44796	}
44723	44797

		@@ -44725,7 +44799,7 @@
44725	44799	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
44726	44800	if(!newstack)
44727	44801	{
44728		- label = 3544LLU; // throw: begin to unroll stack
	44802	+ label = 3553LLU; // throw: begin to unroll stack
44729	44803	break;
44730	44804	}
44731	44805

		@@ -44732,9 +44806,9 @@
44732	44806	newstack[160LLU] = 9876543210LLU; // overflow-marker
44733	44807	// call procblock from procblock
44734	44808	newstack[0] = (uint64_t)stack; // backup stack location
44735		- newstack[1] = 3766LLU;
	44809	+ newstack[1] = 3775LLU;
44736	44810	newstack[2] = base;
44737		- newstack[3] = 3767LLU;
	44811	+ newstack[3] = 3776LLU;
44738	44812	// arguments for call to procblock
44739	44813	newstack[4LLU] = stack[base + 0]/fndefs/;
44740	44814	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -44757,10 +44831,10 @@
44757	44831	stack = newstack;
44758	44832	// set stack-base & callee-address
44759	44833	base = 4/deloffset/;
44760		- label = 3429LLU; // procblock
	44834	+ label = 3438LLU; // procblock
44761	44835	break;
44762	44836	}
44763		- case 3766LLU: // copy-back deleter (procblock to procblock)
	44837	+ case 3775LLU: // copy-back deleter (procblock to procblock)
44764	44838	{
44765	44839	uint64_t oldstack = (uint64_t )stack[0];
44766	44840	// copy mutable arguments back from call to procblock

		@@ -44777,10 +44851,10 @@
44777	44851	}
44778	44852	Free(160LLU + 1, sizeof(uint64_t), stack);
44779	44853	stack = oldstack;
44780		- label = 3544LLU; // continue to unroll stack
	44854	+ label = 3553LLU; // continue to unroll stack
44781	44855	break;
44782	44856	}
44783		- case 3767LLU: // return from procblock to procblock
	44857	+ case 3776LLU: // return from procblock to procblock
44784	44858	{
44785	44859	uint64_t oldstack = (uint64_t )stack[0];
44786	44860	// copy mutable arguments back from call to procblock

		@@ -44798,9 +44872,9 @@
44798	44872	Free(160LLU + 1, sizeof(uint64_t), stack);
44799	44873	stack = oldstack;
44800	44874	// call MATCHPEEK from procblock
44801		- stack[base + 25LLU] = 3768LLU/throw to this address/;
	44875	+ stack[base + 25LLU] = 3777LLU/throw to this address/;
44802	44876	stack[base + 26LLU] = base;
44803		- stack[base + 27LLU] = 3769LLU;
	44877	+ stack[base + 27LLU] = 3778LLU;
44804	44878	// arguments for call to MATCHPEEK
44805	44879	stack[base + 28LLU] = stack[base + 8]/fnid/;
44806	44880	stack[base + 29LLU] = 125LLU;

		@@ -44810,21 +44884,21 @@
44810	44884	label = 206LLU; // MATCHPEEK
44811	44885	break;
44812	44886	}
44813		- case 3768LLU: // copy-back deleter (MATCHPEEK to procblock)
	44887	+ case 3777LLU: // copy-back deleter (MATCHPEEK to procblock)
44814	44888	{
44815	44889	// copy mutable arguments back from call to MATCHPEEK
44816	44890	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44817		- label = 3544LLU; // continue to roll stack
	44891	+ label = 3553LLU; // continue to roll stack
44818	44892	break;
44819	44893	}
44820		- case 3769LLU: // return from MATCHPEEK to procblock
	44894	+ case 3778LLU: // return from MATCHPEEK to procblock
44821	44895	{
44822	44896	// copy mutable arguments back from call to MATCHPEEK
44823	44897	stack[base + 19]/lookahead/ = stack[base + 30LLU];
44824	44898	// call EOSbyte from procblock
44825		- stack[base + 25LLU] = 3770LLU/throw to this address/;
	44899	+ stack[base + 25LLU] = 3779LLU/throw to this address/;
44826	44900	stack[base + 26LLU] = base;
44827		- stack[base + 27LLU] = 3771LLU;
	44901	+ stack[base + 27LLU] = 3780LLU;
44828	44902	// arguments for call to EOSbyte
44829	44903	// set stack-base & callee-address
44830	44904	base += 28LLU;

		@@ -44831,42 +44905,42 @@
44831	44905	label = 77LLU; // EOSbyte
44832	44906	break;
44833	44907	}
44834		- case 3770LLU: // copy-back deleter (EOSbyte to procblock)
	44908	+ case 3779LLU: // copy-back deleter (EOSbyte to procblock)
44835	44909	{
44836	44910	// copy mutable arguments back from call to EOSbyte
44837		- label = 3544LLU; // continue to roll stack
	44911	+ label = 3553LLU; // continue to roll stack
44838	44912	break;
44839	44913	}
44840		- case 3771LLU: // return from EOSbyte to procblock
	44914	+ case 3780LLU: // return from EOSbyte to procblock
44841	44915	{
44842	44916	// copy mutable arguments back from call to EOSbyte
44843	44917	// copy back results provided by call to EOSbyte
44844	44918	stack[base + 19] = stack[base + 28LLU];
44845		- label = 3765LLU; // consequent complete
	44919	+ label = 3774LLU; // consequent complete
44846	44920	break;
44847	44921	}
44848		- case 3764LLU: // alternative
	44922	+ case 3773LLU: // alternative
44849	44923	{
44850		- label = 3773LLU; // skip deleter
	44924	+ label = 3782LLU; // skip deleter
44851	44925	break;
44852	44926	}
44853		- case 3772LLU: // deleter
	44927	+ case 3781LLU: // deleter
44854	44928	{
44855	44929	// throw from procblock
44856	44930	if(!stack[base + 25])
44857	44931	{
44858		- label = 3544LLU; // skip, variable already deleted/unscoped
	44932	+ label = 3553LLU; // skip, variable already deleted/unscoped
44859	44933	break;
44860	44934	}
44861	44935	// delete list
44862		- label = 3774LLU; // start to repeat
	44936	+ label = 3783LLU; // start to repeat
44863	44937	break;
44864	44938	}
44865		- case 3774LLU: // repeat from here
	44939	+ case 3783LLU: // repeat from here
44866	44940	{
44867	44941	if(!stack[base + 25])
44868	44942	{
44869		- label = 3775LLU; // break loop
	44943	+ label = 3784LLU; // break loop
44870	44944	break;
44871	44945	}
44872	44946

		@@ -44877,7 +44951,7 @@
44877	44951	newstack[0] = (uint64_t)stack; // backup stack location
44878	44952	newstack[1] = 1234567890;
44879	44953	newstack[2] = base;
44880		- newstack[3] = 3776LLU;
	44954	+ newstack[3] = 3785LLU;
44881	44955	stack = newstack;
44882	44956	// set stack-base & callee-address
44883	44957	base = 4/deloffset/;

		@@ -44884,7 +44958,7 @@
44884	44958	label = 399LLU; // ~typeidx
44885	44959	break;
44886	44960	}
44887		- case 3776LLU: // return from ~typeidx to procblock
	44961	+ case 3785LLU: // return from ~typeidx to procblock
44888	44962	{
44889	44963	stack = (uint64_t *)stack[0];
44890	44964	// releasing toplevel container

		@@ -44895,21 +44969,21 @@
44895	44969	stack[base + 25] = (uint64_t)list->next;
44896	44970	Free(1, sizeof(struct listnode), list);
44897	44971	}
44898		- label = 3774LLU; // repeat
	44972	+ label = 3783LLU; // repeat
44899	44973	break;
44900	44974	}
44901		- case 3775LLU: // loop finished
	44975	+ case 3784LLU: // loop finished
44902	44976	{
44903		- label = 3544LLU; // continue unrolling stack, delete next variable
	44977	+ label = 3553LLU; // continue unrolling stack, delete next variable
44904	44978	break;
44905	44979	}
44906		- case 3773LLU: // skipped deleter
	44980	+ case 3782LLU: // skipped deleter
44907	44981	{
44908	44982	stack[base + 25] = 0;
44909	44983	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
44910	44984	if(!newstack)
44911	44985	{
44912		- label = 3772LLU; // throw: begin to unroll stack
	44986	+ label = 3781LLU; // throw: begin to unroll stack
44913	44987	break;
44914	44988	}
44915	44989

		@@ -44916,9 +44990,9 @@
44916	44990	newstack[160LLU] = 9876543210LLU; // overflow-marker
44917	44991	// call procblock from procblock
44918	44992	newstack[0] = (uint64_t)stack; // backup stack location
44919		- newstack[1] = 3777LLU;
	44993	+ newstack[1] = 3786LLU;
44920	44994	newstack[2] = base;
44921		- newstack[3] = 3778LLU;
	44995	+ newstack[3] = 3787LLU;
44922	44996	// arguments for call to procblock
44923	44997	newstack[4LLU] = stack[base + 0]/fndefs/;
44924	44998	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -44941,10 +45015,10 @@
44941	45015	stack = newstack;
44942	45016	// set stack-base & callee-address
44943	45017	base = 4/deloffset/;
44944		- label = 3429LLU; // procblock
	45018	+ label = 3438LLU; // procblock
44945	45019	break;
44946	45020	}
44947		- case 3777LLU: // copy-back deleter (procblock to procblock)
	45021	+ case 3786LLU: // copy-back deleter (procblock to procblock)
44948	45022	{
44949	45023	uint64_t oldstack = (uint64_t )stack[0];
44950	45024	// copy mutable arguments back from call to procblock

		@@ -44961,10 +45035,10 @@
44961	45035	}
44962	45036	Free(160LLU + 1, sizeof(uint64_t), stack);
44963	45037	stack = oldstack;
44964		- label = 3772LLU; // continue to unroll stack
	45038	+ label = 3781LLU; // continue to unroll stack
44965	45039	break;
44966	45040	}
44967		- case 3778LLU: // return from procblock to procblock
	45041	+ case 3787LLU: // return from procblock to procblock
44968	45042	{
44969	45043	uint64_t oldstack = (uint64_t )stack[0];
44970	45044	// copy mutable arguments back from call to procblock

		@@ -44982,14 +45056,14 @@
44982	45056	Free(160LLU + 1, sizeof(uint64_t), stack);
44983	45057	stack = oldstack;
44984	45058	// delete list
44985		- label = 3779LLU; // start to repeat
	45059	+ label = 3788LLU; // start to repeat
44986	45060	break;
44987	45061	}
44988		- case 3779LLU: // repeat from here
	45062	+ case 3788LLU: // repeat from here
44989	45063	{
44990	45064	if(!stack[base + 25])
44991	45065	{
44992		- label = 3780LLU; // break loop
	45066	+ label = 3789LLU; // break loop
44993	45067	break;
44994	45068	}
44995	45069

		@@ -45000,7 +45074,7 @@
45000	45074	newstack[0] = (uint64_t)stack; // backup stack location
45001	45075	newstack[1] = 1234567890;
45002	45076	newstack[2] = base;
45003		- newstack[3] = 3781LLU;
	45077	+ newstack[3] = 3790LLU;
45004	45078	stack = newstack;
45005	45079	// set stack-base & callee-address
45006	45080	base = 4/deloffset/;

		@@ -45007,7 +45081,7 @@
45007	45081	label = 399LLU; // ~typeidx
45008	45082	break;
45009	45083	}
45010		- case 3781LLU: // return from ~typeidx to procblock
	45084	+ case 3790LLU: // return from ~typeidx to procblock
45011	45085	{
45012	45086	stack = (uint64_t *)stack[0];
45013	45087	// releasing toplevel container

		@@ -45018,26 +45092,26 @@
45018	45092	stack[base + 25] = (uint64_t)list->next;
45019	45093	Free(1, sizeof(struct listnode), list);
45020	45094	}
45021		- label = 3779LLU; // repeat
	45095	+ label = 3788LLU; // repeat
45022	45096	break;
45023	45097	}
45024		- case 3780LLU: // loop finished
	45098	+ case 3789LLU: // loop finished
45025	45099	{
45026		- label = 3765LLU; // alternative complete
	45100	+ label = 3774LLU; // alternative complete
45027	45101	break;
45028	45102	}
45029		- case 3765LLU: // completed if-then-else
	45103	+ case 3774LLU: // completed if-then-else
45030	45104	{
45031		- label = 3755LLU; // alternative complete
	45105	+ label = 3764LLU; // alternative complete
45032	45106	break;
45033	45107	}
45034		- case 3755LLU: // completed if-then-else
	45108	+ case 3764LLU: // completed if-then-else
45035	45109	{
45036	45110	printf("%s", "\n label = ");
45037	45111	// call printnr from procblock
45038		- stack[base + 25LLU] = 3782LLU/throw to this address/;
	45112	+ stack[base + 25LLU] = 3791LLU/throw to this address/;
45039	45113	stack[base + 26LLU] = base;
45040		- stack[base + 27LLU] = 3783LLU;
	45114	+ stack[base + 27LLU] = 3792LLU;
45041	45115	// arguments for call to printnr
45042	45116	stack[base + 28LLU] = stack[base + 24]/labelskip/;
45043	45117	// set stack-base & callee-address

		@@ -45045,13 +45119,13 @@
45045	45119	label = 18446744073709551590LLU; // printnr
45046	45120	break;
45047	45121	}
45048		- case 3782LLU: // copy-back deleter (printnr to procblock)
	45122	+ case 3791LLU: // copy-back deleter (printnr to procblock)
45049	45123	{
45050	45124	// copy mutable arguments back from call to printnr
45051		- label = 3544LLU; // continue to roll stack
	45125	+ label = 3553LLU; // continue to roll stack
45052	45126	break;
45053	45127	}
45054		- case 3783LLU: // return from printnr to procblock
	45128	+ case 3792LLU: // return from printnr to procblock
45055	45129	{
45056	45130	// copy mutable arguments back from call to printnr
45057	45131	printf("%s", "LLU; // alternative complete");

		@@ -45059,9 +45133,9 @@
45059	45133	printf("%s", "\n }");
45060	45134	printf("%s", "\n case ");
45061	45135	// call printnr from procblock
45062		- stack[base + 25LLU] = 3784LLU/throw to this address/;
	45136	+ stack[base + 25LLU] = 3793LLU/throw to this address/;
45063	45137	stack[base + 26LLU] = base;
45064		- stack[base + 27LLU] = 3785LLU;
	45138	+ stack[base + 27LLU] = 3794LLU;
45065	45139	// arguments for call to printnr
45066	45140	stack[base + 28LLU] = stack[base + 24]/labelskip/;
45067	45141	// set stack-base & callee-address

		@@ -45069,26 +45143,26 @@
45069	45143	label = 18446744073709551590LLU; // printnr
45070	45144	break;
45071	45145	}
45072		- case 3784LLU: // copy-back deleter (printnr to procblock)
	45146	+ case 3793LLU: // copy-back deleter (printnr to procblock)
45073	45147	{
45074	45148	// copy mutable arguments back from call to printnr
45075		- label = 3544LLU; // continue to roll stack
	45149	+ label = 3553LLU; // continue to roll stack
45076	45150	break;
45077	45151	}
45078		- case 3785LLU: // return from printnr to procblock
	45152	+ case 3794LLU: // return from printnr to procblock
45079	45153	{
45080	45154	// copy mutable arguments back from call to printnr
45081	45155	printf("%s", "LLU: // completed if-then-else");
45082	45156	printf("%s", "\n {");
45083		- label = 3537LLU; // consequent complete
	45157	+ label = 3546LLU; // consequent complete
45084	45158	break;
45085	45159	}
45086		- case 3536LLU: // alternative
	45160	+ case 3545LLU: // alternative
45087	45161	{
45088	45162	// call equ from procblock
45089		- stack[base + 23LLU] = 3786LLU/throw to this address/;
	45163	+ stack[base + 23LLU] = 3795LLU/throw to this address/;
45090	45164	stack[base + 24LLU] = base;
45091		- stack[base + 25LLU] = 3787LLU;
	45165	+ stack[base + 25LLU] = 3796LLU;
45092	45166	// arguments for call to equ
45093	45167	stack[base + 27LLU] = stack[base + 16]/content/;
45094	45168	stack[base + 28LLU] = 910732593752702976LLU;

		@@ -45097,13 +45171,13 @@
45097	45171	label = 18446744073709551600LLU; // equ
45098	45172	break;
45099	45173	}
45100		- case 3786LLU: // copy-back deleter (equ to procblock)
	45174	+ case 3795LLU: // copy-back deleter (equ to procblock)
45101	45175	{
45102	45176	// copy mutable arguments back from call to equ
45103		- label = 3528LLU; // continue to roll stack
	45177	+ label = 3537LLU; // continue to roll stack
45104	45178	break;
45105	45179	}
45106		- case 3787LLU: // return from equ to procblock
	45180	+ case 3796LLU: // return from equ to procblock
45107	45181	{
45108	45182	// copy mutable arguments back from call to equ
45109	45183	// copy back results provided by call to equ

		@@ -45110,20 +45184,20 @@
45110	45184	stack[base + 20] = stack[base + 26LLU];
45111	45185	if(!stack[base + 20]/isequal/)
45112	45186	{
45113		- label = 3788LLU; // jump to alternative
	45187	+ label = 3797LLU; // jump to alternative
45114	45188	break;
45115	45189	}
45116	45190
45117	45191	// consequent
45118		- label = 3791LLU; // skip deleter
	45192	+ label = 3800LLU; // skip deleter
45119	45193	break;
45120	45194	}
45121		- case 3790LLU: // deleter
	45195	+ case 3799LLU: // deleter
45122	45196	{
45123	45197	// throw from procblock
45124	45198	if(!stack[base + 23])
45125	45199	{
45126		- label = 3528LLU; // skip, variable already deleted/unscoped
	45200	+ label = 3537LLU; // skip, variable already deleted/unscoped
45127	45201	break;
45128	45202	}
45129	45203

		@@ -45132,7 +45206,7 @@
45132	45206	newstack[0] = (uint64_t)stack; // backup stack location
45133	45207	newstack[1] = 1234567890;
45134	45208	newstack[2] = base;
45135		- newstack[3] = 3792LLU;
	45209	+ newstack[3] = 3801LLU;
45136	45210	stack = newstack;
45137	45211	// set stack-base & callee-address
45138	45212	base = 4/deloffset/;

		@@ -45139,21 +45213,21 @@
45139	45213	label = 562LLU; // ~scope
45140	45214	break;
45141	45215	}
45142		- case 3792LLU: // return from ~scope to procblock
	45216	+ case 3801LLU: // return from ~scope to procblock
45143	45217	{
45144	45218	stack = (uint64_t *)stack[0];
45145	45219	// releasing toplevel container
45146	45220	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 23] - sizeof(uint64_t) 4));
45147	45221
45148		- label = 3528LLU; // continue unrolling stack, delete next variable
	45222	+ label = 3537LLU; // continue unrolling stack, delete next variable
45149	45223	break;
45150	45224	}
45151		- case 3791LLU: // skipped deleter
	45225	+ case 3800LLU: // skipped deleter
45152	45226	{
45153	45227	// call linkscope from procblock
45154		- stack[base + 24LLU] = 3793LLU/throw to this address/;
	45228	+ stack[base + 24LLU] = 3802LLU/throw to this address/;
45155	45229	stack[base + 25LLU] = base;
45156		- stack[base + 26LLU] = 3794LLU;
	45230	+ stack[base + 26LLU] = 3803LLU;
45157	45231	// arguments for call to linkscope
45158	45232	stack[base + 28LLU] = stack[base + 3]/scope/;
45159	45233	// set stack-base & callee-address

		@@ -45161,13 +45235,13 @@
45161	45235	label = 589LLU; // linkscope
45162	45236	break;
45163	45237	}
45164		- case 3793LLU: // copy-back deleter (linkscope to procblock)
	45238	+ case 3802LLU: // copy-back deleter (linkscope to procblock)
45165	45239	{
45166	45240	// copy mutable arguments back from call to linkscope
45167		- label = 3528LLU; // continue to roll stack
	45241	+ label = 3537LLU; // continue to roll stack
45168	45242	break;
45169	45243	}
45170		- case 3794LLU: // return from linkscope to procblock
	45244	+ case 3803LLU: // return from linkscope to procblock
45171	45245	{
45172	45246	// copy mutable arguments back from call to linkscope
45173	45247	// copy back results provided by call to linkscope

		@@ -45187,9 +45261,9 @@
45187	45261	MOVE(&list->data, &stack[base + 23]/newscope/);
45188	45262	}
45189	45263	// call add from procblock
45190		- stack[base + 23LLU] = 3795LLU/throw to this address/;
	45264	+ stack[base + 23LLU] = 3804LLU/throw to this address/;
45191	45265	stack[base + 24LLU] = base;
45192		- stack[base + 25LLU] = 3796LLU;
	45266	+ stack[base + 25LLU] = 3805LLU;
45193	45267	// arguments for call to add
45194	45268	stack[base + 27LLU] = 1LLU;
45195	45269	stack[base + 28LLU] = stack[base + 17]/label/;

		@@ -45198,38 +45272,38 @@
45198	45272	label = 18446744073709551605LLU; // add
45199	45273	break;
45200	45274	}
45201		- case 3795LLU: // copy-back deleter (add to procblock)
	45275	+ case 3804LLU: // copy-back deleter (add to procblock)
45202	45276	{
45203	45277	// copy mutable arguments back from call to add
45204		- label = 3528LLU; // continue to roll stack
	45278	+ label = 3537LLU; // continue to roll stack
45205	45279	break;
45206	45280	}
45207		- case 3796LLU: // return from add to procblock
	45281	+ case 3805LLU: // return from add to procblock
45208	45282	{
45209	45283	// copy mutable arguments back from call to add
45210	45284	// copy back results provided by call to add
45211	45285	stack[base + 17] = stack[base + 26LLU];
45212		- label = 3798LLU; // skip deleter
	45286	+ label = 3807LLU; // skip deleter
45213	45287	break;
45214	45288	}
45215		- case 3797LLU: // deleter
	45289	+ case 3806LLU: // deleter
45216	45290	{
45217	45291	// throw from procblock
45218	45292	if(!stack[base + 23])
45219	45293	{
45220		- label = 3528LLU; // skip, variable already deleted/unscoped
	45294	+ label = 3537LLU; // skip, variable already deleted/unscoped
45221	45295	break;
45222	45296	}
45223		- label = 3528LLU; // continue unrolling stack, delete next variable
	45297	+ label = 3537LLU; // continue unrolling stack, delete next variable
45224	45298	break;
45225	45299	}
45226		- case 3798LLU: // skipped deleter
	45300	+ case 3807LLU: // skipped deleter
45227	45301	{
45228	45302	stack[base + 23] = stack[base + 17]/label/;
45229	45303	// call add from procblock
45230		- stack[base + 24LLU] = 3799LLU/throw to this address/;
	45304	+ stack[base + 24LLU] = 3808LLU/throw to this address/;
45231	45305	stack[base + 25LLU] = base;
45232		- stack[base + 26LLU] = 3800LLU;
	45306	+ stack[base + 26LLU] = 3809LLU;
45233	45307	// arguments for call to add
45234	45308	stack[base + 28LLU] = 1LLU;
45235	45309	stack[base + 29LLU] = stack[base + 17]/label/;

		@@ -45238,38 +45312,38 @@
45238	45312	label = 18446744073709551605LLU; // add
45239	45313	break;
45240	45314	}
45241		- case 3799LLU: // copy-back deleter (add to procblock)
	45315	+ case 3808LLU: // copy-back deleter (add to procblock)
45242	45316	{
45243	45317	// copy mutable arguments back from call to add
45244		- label = 3797LLU; // continue to roll stack
	45318	+ label = 3806LLU; // continue to roll stack
45245	45319	break;
45246	45320	}
45247		- case 3800LLU: // return from add to procblock
	45321	+ case 3809LLU: // return from add to procblock
45248	45322	{
45249	45323	// copy mutable arguments back from call to add
45250	45324	// copy back results provided by call to add
45251	45325	stack[base + 17] = stack[base + 27LLU];
45252		- label = 3802LLU; // skip deleter
	45326	+ label = 3811LLU; // skip deleter
45253	45327	break;
45254	45328	}
45255		- case 3801LLU: // deleter
	45329	+ case 3810LLU: // deleter
45256	45330	{
45257	45331	// throw from procblock
45258	45332	if(!stack[base + 24])
45259	45333	{
45260		- label = 3797LLU; // skip, variable already deleted/unscoped
	45334	+ label = 3806LLU; // skip, variable already deleted/unscoped
45261	45335	break;
45262	45336	}
45263		- label = 3797LLU; // continue unrolling stack, delete next variable
	45337	+ label = 3806LLU; // continue unrolling stack, delete next variable
45264	45338	break;
45265	45339	}
45266		- case 3802LLU: // skipped deleter
	45340	+ case 3811LLU: // skipped deleter
45267	45341	{
45268	45342	stack[base + 24] = stack[base + 17]/label/;
45269	45343	// call ParseToken from procblock
45270		- stack[base + 25LLU] = 3803LLU/throw to this address/;
	45344	+ stack[base + 25LLU] = 3812LLU/throw to this address/;
45271	45345	stack[base + 26LLU] = base;
45272		- stack[base + 27LLU] = 3804LLU;
	45346	+ stack[base + 27LLU] = 3813LLU;
45273	45347	// arguments for call to ParseToken
45274	45348	stack[base + 30LLU] = stack[base + 19]/lookahead/;
45275	45349	// set stack-base & callee-address

		@@ -45277,14 +45351,14 @@
45277	45351	label = 3LLU; // ParseToken
45278	45352	break;
45279	45353	}
45280		- case 3803LLU: // copy-back deleter (ParseToken to procblock)
	45354	+ case 3812LLU: // copy-back deleter (ParseToken to procblock)
45281	45355	{
45282	45356	// copy mutable arguments back from call to ParseToken
45283	45357	stack[base + 19]/lookahead/ = stack[base + 30LLU];
45284		- label = 3801LLU; // continue to roll stack
	45358	+ label = 3810LLU; // continue to roll stack
45285	45359	break;
45286	45360	}
45287		- case 3804LLU: // return from ParseToken to procblock
	45361	+ case 3813LLU: // return from ParseToken to procblock
45288	45362	{
45289	45363	// copy mutable arguments back from call to ParseToken
45290	45364	stack[base + 19]/lookahead/ = stack[base + 30LLU];

		@@ -45291,42 +45365,42 @@
45291	45365	// copy back results provided by call to ParseToken
45292	45366	stack[base + 15] = stack[base + 28LLU];
45293	45367	stack[base + 16] = stack[base + 29LLU];
45294		- label = 3806LLU; // skip deleter
	45368	+ label = 3815LLU; // skip deleter
45295	45369	break;
45296	45370	}
45297		- case 3805LLU: // deleter
	45371	+ case 3814LLU: // deleter
45298	45372	{
45299	45373	// throw from procblock
45300	45374	if(!stack[base + 25])
45301	45375	{
45302		- label = 3801LLU; // skip, variable already deleted/unscoped
	45376	+ label = 3810LLU; // skip, variable already deleted/unscoped
45303	45377	break;
45304	45378	}
45305		- label = 3801LLU; // continue unrolling stack, delete next variable
	45379	+ label = 3810LLU; // continue unrolling stack, delete next variable
45306	45380	break;
45307	45381	}
45308		- case 3806LLU: // skipped deleter
	45382	+ case 3815LLU: // skipped deleter
45309	45383	{
45310		- label = 3808LLU; // skip deleter
	45384	+ label = 3817LLU; // skip deleter
45311	45385	break;
45312	45386	}
45313		- case 3807LLU: // deleter
	45387	+ case 3816LLU: // deleter
45314	45388	{
45315	45389	// throw from procblock
45316	45390	if(!stack[base + 26])
45317	45391	{
45318		- label = 3805LLU; // skip, variable already deleted/unscoped
	45392	+ label = 3814LLU; // skip, variable already deleted/unscoped
45319	45393	break;
45320	45394	}
45321		- label = 3805LLU; // continue unrolling stack, delete next variable
	45395	+ label = 3814LLU; // continue unrolling stack, delete next variable
45322	45396	break;
45323	45397	}
45324		- case 3808LLU: // skipped deleter
	45398	+ case 3817LLU: // skipped deleter
45325	45399	{
45326	45400	// call isident from procblock
45327		- stack[base + 27LLU] = 3809LLU/throw to this address/;
	45401	+ stack[base + 27LLU] = 3818LLU/throw to this address/;
45328	45402	stack[base + 28LLU] = base;
45329		- stack[base + 29LLU] = 3810LLU;
	45403	+ stack[base + 29LLU] = 3819LLU;
45330	45404	// arguments for call to isident
45331	45405	stack[base + 31LLU] = stack[base + 15]/variant/;
45332	45406	stack[base + 32LLU] = stack[base + 16]/content/;

		@@ -45336,13 +45410,13 @@
45336	45410	label = 184LLU; // isident
45337	45411	break;
45338	45412	}
45339		- case 3809LLU: // copy-back deleter (isident to procblock)
	45413	+ case 3818LLU: // copy-back deleter (isident to procblock)
45340	45414	{
45341	45415	// copy mutable arguments back from call to isident
45342		- label = 3801LLU; // continue to roll stack
	45416	+ label = 3810LLU; // continue to roll stack
45343	45417	break;
45344	45418	}
45345		- case 3810LLU: // return from isident to procblock
	45419	+ case 3819LLU: // return from isident to procblock
45346	45420	{
45347	45421	// copy mutable arguments back from call to isident
45348	45422	// copy back results provided by call to isident

		@@ -45349,15 +45423,15 @@
45349	45423	stack[base + 20] = stack[base + 30LLU];
45350	45424	if(!stack[base + 20]/isequal/)
45351	45425	{
45352		- label = 3811LLU; // jump to alternative
	45426	+ label = 3820LLU; // jump to alternative
45353	45427	break;
45354	45428	}
45355	45429
45356	45430	// consequent
45357	45431	// call ParseToken from procblock
45358		- stack[base + 27LLU] = 3813LLU/throw to this address/;
	45432	+ stack[base + 27LLU] = 3822LLU/throw to this address/;
45359	45433	stack[base + 28LLU] = base;
45360		- stack[base + 29LLU] = 3814LLU;
	45434	+ stack[base + 29LLU] = 3823LLU;
45361	45435	// arguments for call to ParseToken
45362	45436	stack[base + 32LLU] = stack[base + 19]/lookahead/;
45363	45437	// set stack-base & callee-address

		@@ -45365,14 +45439,14 @@
45365	45439	label = 3LLU; // ParseToken
45366	45440	break;
45367	45441	}
45368		- case 3813LLU: // copy-back deleter (ParseToken to procblock)
	45442	+ case 3822LLU: // copy-back deleter (ParseToken to procblock)
45369	45443	{
45370	45444	// copy mutable arguments back from call to ParseToken
45371	45445	stack[base + 19]/lookahead/ = stack[base + 32LLU];
45372		- label = 3801LLU; // continue to roll stack
	45446	+ label = 3810LLU; // continue to roll stack
45373	45447	break;
45374	45448	}
45375		- case 3814LLU: // return from ParseToken to procblock
	45449	+ case 3823LLU: // return from ParseToken to procblock
45376	45450	{
45377	45451	// copy mutable arguments back from call to ParseToken
45378	45452	stack[base + 19]/lookahead/ = stack[base + 32LLU];

		@@ -45379,49 +45453,49 @@
45379	45453	// copy back results provided by call to ParseToken
45380	45454	stack[base + 15] = stack[base + 30LLU];
45381	45455	stack[base + 16] = stack[base + 31LLU];
45382		- label = 3816LLU; // skip deleter
	45456	+ label = 3825LLU; // skip deleter
45383	45457	break;
45384	45458	}
45385		- case 3815LLU: // deleter
	45459	+ case 3824LLU: // deleter
45386	45460	{
45387	45461	// throw from procblock
45388	45462	if(!stack[base + 25])
45389	45463	{
45390		- label = 3801LLU; // skip, variable already deleted/unscoped
	45464	+ label = 3810LLU; // skip, variable already deleted/unscoped
45391	45465	break;
45392	45466	}
45393		- label = 3801LLU; // continue unrolling stack, delete next variable
	45467	+ label = 3810LLU; // continue unrolling stack, delete next variable
45394	45468	break;
45395	45469	}
45396		- case 3816LLU: // skipped deleter
	45470	+ case 3825LLU: // skipped deleter
45397	45471	{
45398	45472	stack[base + 25] = 1;
45399		- label = 3818LLU; // skip deleter
	45473	+ label = 3827LLU; // skip deleter
45400	45474	break;
45401	45475	}
45402		- case 3817LLU: // deleter
	45476	+ case 3826LLU: // deleter
45403	45477	{
45404	45478	// throw from procblock
45405	45479	if(!stack[base + 26])
45406	45480	{
45407		- label = 3815LLU; // skip, variable already deleted/unscoped
	45481	+ label = 3824LLU; // skip, variable already deleted/unscoped
45408	45482	break;
45409	45483	}
45410		- label = 3815LLU; // continue unrolling stack, delete next variable
	45484	+ label = 3824LLU; // continue unrolling stack, delete next variable
45411	45485	break;
45412	45486	}
45413		- case 3818LLU: // skipped deleter
	45487	+ case 3827LLU: // skipped deleter
45414	45488	{
45415	45489	stack[base + 26] = 0;
45416		- label = 3812LLU; // consequent complete
	45490	+ label = 3821LLU; // consequent complete
45417	45491	break;
45418	45492	}
45419		- case 3811LLU: // alternative
	45493	+ case 3820LLU: // alternative
45420	45494	{
45421	45495	// call isident from procblock
45422		- stack[base + 27LLU] = 3819LLU/throw to this address/;
	45496	+ stack[base + 27LLU] = 3828LLU/throw to this address/;
45423	45497	stack[base + 28LLU] = base;
45424		- stack[base + 29LLU] = 3820LLU;
	45498	+ stack[base + 29LLU] = 3829LLU;
45425	45499	// arguments for call to isident
45426	45500	stack[base + 31LLU] = stack[base + 15]/variant/;
45427	45501	stack[base + 32LLU] = stack[base + 16]/content/;

		@@ -45431,13 +45505,13 @@
45431	45505	label = 184LLU; // isident
45432	45506	break;
45433	45507	}
45434		- case 3819LLU: // copy-back deleter (isident to procblock)
	45508	+ case 3828LLU: // copy-back deleter (isident to procblock)
45435	45509	{
45436	45510	// copy mutable arguments back from call to isident
45437		- label = 3801LLU; // continue to roll stack
	45511	+ label = 3810LLU; // continue to roll stack
45438	45512	break;
45439	45513	}
45440		- case 3820LLU: // return from isident to procblock
	45514	+ case 3829LLU: // return from isident to procblock
45441	45515	{
45442	45516	// copy mutable arguments back from call to isident
45443	45517	// copy back results provided by call to isident

		@@ -45444,7 +45518,7 @@
45444	45518	stack[base + 20] = stack[base + 30LLU];
45445	45519	if(!stack[base + 20]/isequal/)
45446	45520	{
45447		- label = 3821LLU; // jump to alternative
	45521	+ label = 3830LLU; // jump to alternative
45448	45522	break;
45449	45523	}
45450	45524

		@@ -45451,21 +45525,21 @@
45451	45525	// consequent
45452	45526	if(!stack[base + 7]/fnIO/)
45453	45527	{
45454		- label = 3823LLU; // jump to alternative
	45528	+ label = 3832LLU; // jump to alternative
45455	45529	break;
45456	45530	}
45457	45531
45458	45532	// consequent
45459		- label = 3824LLU; // consequent complete
	45533	+ label = 3833LLU; // consequent complete
45460	45534	break;
45461	45535	}
45462		- case 3823LLU: // alternative
	45536	+ case 3832LLU: // alternative
45463	45537	{
45464	45538	fprintf(stderr, "%s", "in function ");
45465	45539	// call reportid from procblock
45466		- stack[base + 27LLU] = 3825LLU/throw to this address/;
	45540	+ stack[base + 27LLU] = 3834LLU/throw to this address/;
45467	45541	stack[base + 28LLU] = base;
45468		- stack[base + 29LLU] = 3826LLU;
	45542	+ stack[base + 29LLU] = 3835LLU;
45469	45543	// arguments for call to reportid
45470	45544	stack[base + 30LLU] = stack[base + 8]/fnid/;
45471	45545	// set stack-base & callee-address

		@@ -45473,31 +45547,31 @@
45473	45547	label = 18446744073709551586LLU; // reportid
45474	45548	break;
45475	45549	}
45476		- case 3825LLU: // copy-back deleter (reportid to procblock)
	45550	+ case 3834LLU: // copy-back deleter (reportid to procblock)
45477	45551	{
45478	45552	// copy mutable arguments back from call to reportid
45479		- label = 3801LLU; // continue to roll stack
	45553	+ label = 3810LLU; // continue to roll stack
45480	45554	break;
45481	45555	}
45482		- case 3826LLU: // return from reportid to procblock
	45556	+ case 3835LLU: // return from reportid to procblock
45483	45557	{
45484	45558	// copy mutable arguments back from call to reportid
45485	45559	fprintf(stderr, "%s", ": ");
45486	45560	fprintf(stderr, "%s", "while input used in non-IO environment\n");
45487	45561	{
45488		- label = 3801LLU; // throw: begin to unroll stack
	45562	+ label = 3810LLU; // throw: begin to unroll stack
45489	45563	break;
45490	45564	}
45491	45565
45492		- label = 3824LLU; // alternative complete
	45566	+ label = 3833LLU; // alternative complete
45493	45567	break;
45494	45568	}
45495		- case 3824LLU: // completed if-then-else
	45569	+ case 3833LLU: // completed if-then-else
45496	45570	{
45497	45571	// call ParseToken from procblock
45498		- stack[base + 27LLU] = 3827LLU/throw to this address/;
	45572	+ stack[base + 27LLU] = 3836LLU/throw to this address/;
45499	45573	stack[base + 28LLU] = base;
45500		- stack[base + 29LLU] = 3828LLU;
	45574	+ stack[base + 29LLU] = 3837LLU;
45501	45575	// arguments for call to ParseToken
45502	45576	stack[base + 32LLU] = stack[base + 19]/lookahead/;
45503	45577	// set stack-base & callee-address

		@@ -45505,14 +45579,14 @@
45505	45579	label = 3LLU; // ParseToken
45506	45580	break;
45507	45581	}
45508		- case 3827LLU: // copy-back deleter (ParseToken to procblock)
	45582	+ case 3836LLU: // copy-back deleter (ParseToken to procblock)
45509	45583	{
45510	45584	// copy mutable arguments back from call to ParseToken
45511	45585	stack[base + 19]/lookahead/ = stack[base + 32LLU];
45512		- label = 3801LLU; // continue to roll stack
	45586	+ label = 3810LLU; // continue to roll stack
45513	45587	break;
45514	45588	}
45515		- case 3828LLU: // return from ParseToken to procblock
	45589	+ case 3837LLU: // return from ParseToken to procblock
45516	45590	{
45517	45591	// copy mutable arguments back from call to ParseToken
45518	45592	stack[base + 19]/lookahead/ = stack[base + 32LLU];

		@@ -45519,93 +45593,93 @@
45519	45593	// copy back results provided by call to ParseToken
45520	45594	stack[base + 15] = stack[base + 30LLU];
45521	45595	stack[base + 16] = stack[base + 31LLU];
45522		- label = 3830LLU; // skip deleter
	45596	+ label = 3839LLU; // skip deleter
45523	45597	break;
45524	45598	}
45525		- case 3829LLU: // deleter
	45599	+ case 3838LLU: // deleter
45526	45600	{
45527	45601	// throw from procblock
45528	45602	if(!stack[base + 25])
45529	45603	{
45530		- label = 3801LLU; // skip, variable already deleted/unscoped
	45604	+ label = 3810LLU; // skip, variable already deleted/unscoped
45531	45605	break;
45532	45606	}
45533		- label = 3801LLU; // continue unrolling stack, delete next variable
	45607	+ label = 3810LLU; // continue unrolling stack, delete next variable
45534	45608	break;
45535	45609	}
45536		- case 3830LLU: // skipped deleter
	45610	+ case 3839LLU: // skipped deleter
45537	45611	{
45538	45612	stack[base + 25] = 0;
45539		- label = 3832LLU; // skip deleter
	45613	+ label = 3841LLU; // skip deleter
45540	45614	break;
45541	45615	}
45542		- case 3831LLU: // deleter
	45616	+ case 3840LLU: // deleter
45543	45617	{
45544	45618	// throw from procblock
45545	45619	if(!stack[base + 26])
45546	45620	{
45547		- label = 3829LLU; // skip, variable already deleted/unscoped
	45621	+ label = 3838LLU; // skip, variable already deleted/unscoped
45548	45622	break;
45549	45623	}
45550		- label = 3829LLU; // continue unrolling stack, delete next variable
	45624	+ label = 3838LLU; // continue unrolling stack, delete next variable
45551	45625	break;
45552	45626	}
45553		- case 3832LLU: // skipped deleter
	45627	+ case 3841LLU: // skipped deleter
45554	45628	{
45555	45629	stack[base + 26] = 1;
45556		- label = 3822LLU; // consequent complete
	45630	+ label = 3831LLU; // consequent complete
45557	45631	break;
45558	45632	}
45559		- case 3821LLU: // alternative
	45633	+ case 3830LLU: // alternative
45560	45634	{
45561		- label = 3834LLU; // skip deleter
	45635	+ label = 3843LLU; // skip deleter
45562	45636	break;
45563	45637	}
45564		- case 3833LLU: // deleter
	45638	+ case 3842LLU: // deleter
45565	45639	{
45566	45640	// throw from procblock
45567	45641	if(!stack[base + 25])
45568	45642	{
45569		- label = 3801LLU; // skip, variable already deleted/unscoped
	45643	+ label = 3810LLU; // skip, variable already deleted/unscoped
45570	45644	break;
45571	45645	}
45572		- label = 3801LLU; // continue unrolling stack, delete next variable
	45646	+ label = 3810LLU; // continue unrolling stack, delete next variable
45573	45647	break;
45574	45648	}
45575		- case 3834LLU: // skipped deleter
	45649	+ case 3843LLU: // skipped deleter
45576	45650	{
45577	45651	stack[base + 25] = 0;
45578		- label = 3836LLU; // skip deleter
	45652	+ label = 3845LLU; // skip deleter
45579	45653	break;
45580	45654	}
45581		- case 3835LLU: // deleter
	45655	+ case 3844LLU: // deleter
45582	45656	{
45583	45657	// throw from procblock
45584	45658	if(!stack[base + 26])
45585	45659	{
45586		- label = 3833LLU; // skip, variable already deleted/unscoped
	45660	+ label = 3842LLU; // skip, variable already deleted/unscoped
45587	45661	break;
45588	45662	}
45589		- label = 3833LLU; // continue unrolling stack, delete next variable
	45663	+ label = 3842LLU; // continue unrolling stack, delete next variable
45590	45664	break;
45591	45665	}
45592		- case 3836LLU: // skipped deleter
	45666	+ case 3845LLU: // skipped deleter
45593	45667	{
45594	45668	stack[base + 26] = 0;
45595		- label = 3822LLU; // alternative complete
	45669	+ label = 3831LLU; // alternative complete
45596	45670	break;
45597	45671	}
45598		- case 3822LLU: // completed if-then-else
	45672	+ case 3831LLU: // completed if-then-else
45599	45673	{
45600		- label = 3812LLU; // alternative complete
	45674	+ label = 3821LLU; // alternative complete
45601	45675	break;
45602	45676	}
45603		- case 3812LLU: // completed if-then-else
	45677	+ case 3821LLU: // completed if-then-else
45604	45678	{
45605	45679	// call equ from procblock
45606		- stack[base + 27LLU] = 3837LLU/throw to this address/;
	45680	+ stack[base + 27LLU] = 3846LLU/throw to this address/;
45607	45681	stack[base + 28LLU] = base;
45608		- stack[base + 29LLU] = 3838LLU;
	45682	+ stack[base + 29LLU] = 3847LLU;
45609	45683	// arguments for call to equ
45610	45684	stack[base + 31LLU] = stack[base + 15]/variant/;
45611	45685	stack[base + 32LLU] = 0LLU;

		@@ -45614,13 +45688,13 @@
45614	45688	label = 18446744073709551600LLU; // equ
45615	45689	break;
45616	45690	}
45617		- case 3837LLU: // copy-back deleter (equ to procblock)
	45691	+ case 3846LLU: // copy-back deleter (equ to procblock)
45618	45692	{
45619	45693	// copy mutable arguments back from call to equ
45620		- label = 3807LLU; // continue to roll stack
	45694	+ label = 3816LLU; // continue to roll stack
45621	45695	break;
45622	45696	}
45623		- case 3838LLU: // return from equ to procblock
	45697	+ case 3847LLU: // return from equ to procblock
45624	45698	{
45625	45699	// copy mutable arguments back from call to equ
45626	45700	// copy back results provided by call to equ

		@@ -45627,15 +45701,15 @@
45627	45701	stack[base + 20] = stack[base + 30LLU];
45628	45702	if(!stack[base + 20]/isequal/)
45629	45703	{
45630		- label = 3839LLU; // jump to alternative
	45704	+ label = 3848LLU; // jump to alternative
45631	45705	break;
45632	45706	}
45633	45707
45634	45708	// consequent
45635	45709	// call equ from procblock
45636		- stack[base + 27LLU] = 3841LLU/throw to this address/;
	45710	+ stack[base + 27LLU] = 3850LLU/throw to this address/;
45637	45711	stack[base + 28LLU] = base;
45638		- stack[base + 29LLU] = 3842LLU;
	45712	+ stack[base + 29LLU] = 3851LLU;
45639	45713	// arguments for call to equ
45640	45714	stack[base + 31LLU] = stack[base + 16]/content/;
45641	45715	stack[base + 32LLU] = 40LLU;

		@@ -45644,13 +45718,13 @@
45644	45718	label = 18446744073709551600LLU; // equ
45645	45719	break;
45646	45720	}
45647		- case 3841LLU: // copy-back deleter (equ to procblock)
	45721	+ case 3850LLU: // copy-back deleter (equ to procblock)
45648	45722	{
45649	45723	// copy mutable arguments back from call to equ
45650		- label = 3807LLU; // continue to roll stack
	45724	+ label = 3816LLU; // continue to roll stack
45651	45725	break;
45652	45726	}
45653		- case 3842LLU: // return from equ to procblock
	45727	+ case 3851LLU: // return from equ to procblock
45654	45728	{
45655	45729	// copy mutable arguments back from call to equ
45656	45730	// copy back results provided by call to equ

		@@ -45657,21 +45731,21 @@
45657	45731	stack[base + 20] = stack[base + 30LLU];
45658	45732	if(!stack[base + 20]/isequal/)
45659	45733	{
45660		- label = 3843LLU; // jump to alternative
	45734	+ label = 3852LLU; // jump to alternative
45661	45735	break;
45662	45736	}
45663	45737
45664	45738	// consequent
45665		- label = 3844LLU; // consequent complete
	45739	+ label = 3853LLU; // consequent complete
45666	45740	break;
45667	45741	}
45668		- case 3843LLU: // alternative
	45742	+ case 3852LLU: // alternative
45669	45743	{
45670	45744	fprintf(stderr, "%s", "expected '(' but found token ");
45671	45745	// call reporttok from procblock
45672		- stack[base + 27LLU] = 3845LLU/throw to this address/;
	45746	+ stack[base + 27LLU] = 3854LLU/throw to this address/;
45673	45747	stack[base + 28LLU] = base;
45674		- stack[base + 29LLU] = 3846LLU;
	45748	+ stack[base + 29LLU] = 3855LLU;
45675	45749	// arguments for call to reporttok
45676	45750	stack[base + 30LLU] = stack[base + 15]/variant/;
45677	45751	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -45680,47 +45754,47 @@
45680	45754	label = 18446744073709551582LLU; // reporttok
45681	45755	break;
45682	45756	}
45683		- case 3845LLU: // copy-back deleter (reporttok to procblock)
	45757	+ case 3854LLU: // copy-back deleter (reporttok to procblock)
45684	45758	{
45685	45759	// copy mutable arguments back from call to reporttok
45686		- label = 3807LLU; // continue to roll stack
	45760	+ label = 3816LLU; // continue to roll stack
45687	45761	break;
45688	45762	}
45689		- case 3846LLU: // return from reporttok to procblock
	45763	+ case 3855LLU: // return from reporttok to procblock
45690	45764	{
45691	45765	// copy mutable arguments back from call to reporttok
45692	45766	fprintf(stderr, "%s", "\n");
45693	45767	{
45694		- label = 3807LLU; // throw: begin to unroll stack
	45768	+ label = 3816LLU; // throw: begin to unroll stack
45695	45769	break;
45696	45770	}
45697	45771
45698		- label = 3844LLU; // alternative complete
	45772	+ label = 3853LLU; // alternative complete
45699	45773	break;
45700	45774	}
45701		- case 3844LLU: // completed if-then-else
	45775	+ case 3853LLU: // completed if-then-else
45702	45776	{
45703		- label = 3848LLU; // skip deleter
	45777	+ label = 3857LLU; // skip deleter
45704	45778	break;
45705	45779	}
45706		- case 3847LLU: // deleter
	45780	+ case 3856LLU: // deleter
45707	45781	{
45708	45782	// throw from procblock
45709	45783	if(!stack[base + 27])
45710	45784	{
45711		- label = 3807LLU; // skip, variable already deleted/unscoped
	45785	+ label = 3816LLU; // skip, variable already deleted/unscoped
45712	45786	break;
45713	45787	}
45714		- label = 3807LLU; // continue unrolling stack, delete next variable
	45788	+ label = 3816LLU; // continue unrolling stack, delete next variable
45715	45789	break;
45716	45790	}
45717		- case 3848LLU: // skipped deleter
	45791	+ case 3857LLU: // skipped deleter
45718	45792	{
45719	45793	stack[base + 27] = 0;
45720	45794	// call ParseToken from procblock
45721		- stack[base + 28LLU] = 3849LLU/throw to this address/;
	45795	+ stack[base + 28LLU] = 3858LLU/throw to this address/;
45722	45796	stack[base + 29LLU] = base;
45723		- stack[base + 30LLU] = 3850LLU;
	45797	+ stack[base + 30LLU] = 3859LLU;
45724	45798	// arguments for call to ParseToken
45725	45799	stack[base + 33LLU] = stack[base + 19]/lookahead/;
45726	45800	// set stack-base & callee-address

		@@ -45728,14 +45802,14 @@
45728	45802	label = 3LLU; // ParseToken
45729	45803	break;
45730	45804	}
45731		- case 3849LLU: // copy-back deleter (ParseToken to procblock)
	45805	+ case 3858LLU: // copy-back deleter (ParseToken to procblock)
45732	45806	{
45733	45807	// copy mutable arguments back from call to ParseToken
45734	45808	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45735		- label = 3847LLU; // continue to roll stack
	45809	+ label = 3856LLU; // continue to roll stack
45736	45810	break;
45737	45811	}
45738		- case 3850LLU: // return from ParseToken to procblock
	45812	+ case 3859LLU: // return from ParseToken to procblock
45739	45813	{
45740	45814	// copy mutable arguments back from call to ParseToken
45741	45815	stack[base + 19]/lookahead/ = stack[base + 33LLU];

		@@ -45743,9 +45817,9 @@
45743	45817	stack[base + 15] = stack[base + 31LLU];
45744	45818	stack[base + 27] = stack[base + 32LLU];
45745	45819	// call equ from procblock
45746		- stack[base + 28LLU] = 3851LLU/throw to this address/;
	45820	+ stack[base + 28LLU] = 3860LLU/throw to this address/;
45747	45821	stack[base + 29LLU] = base;
45748		- stack[base + 30LLU] = 3852LLU;
	45822	+ stack[base + 30LLU] = 3861LLU;
45749	45823	// arguments for call to equ
45750	45824	stack[base + 32LLU] = stack[base + 15]/variant/;
45751	45825	stack[base + 33LLU] = 4LLU;

		@@ -45754,13 +45828,13 @@
45754	45828	label = 18446744073709551600LLU; // equ
45755	45829	break;
45756	45830	}
45757		- case 3851LLU: // copy-back deleter (equ to procblock)
	45831	+ case 3860LLU: // copy-back deleter (equ to procblock)
45758	45832	{
45759	45833	// copy mutable arguments back from call to equ
45760		- label = 3847LLU; // continue to roll stack
	45834	+ label = 3856LLU; // continue to roll stack
45761	45835	break;
45762	45836	}
45763		- case 3852LLU: // return from equ to procblock
	45837	+ case 3861LLU: // return from equ to procblock
45764	45838	{
45765	45839	// copy mutable arguments back from call to equ
45766	45840	// copy back results provided by call to equ

		@@ -45767,15 +45841,15 @@
45767	45841	stack[base + 20] = stack[base + 31LLU];
45768	45842	if(!stack[base + 20]/isequal/)
45769	45843	{
45770		- label = 3853LLU; // jump to alternative
	45844	+ label = 3862LLU; // jump to alternative
45771	45845	break;
45772	45846	}
45773	45847
45774	45848	// consequent
45775	45849	// call assertu64 from procblock
45776		- stack[base + 28LLU] = 3855LLU/throw to this address/;
	45850	+ stack[base + 28LLU] = 3864LLU/throw to this address/;
45777	45851	stack[base + 29LLU] = base;
45778		- stack[base + 30LLU] = 3856LLU;
	45852	+ stack[base + 30LLU] = 3865LLU;
45779	45853	// arguments for call to assertu64
45780	45854	stack[base + 31LLU] = stack[base + 8]/fnid/;
45781	45855	stack[base + 32LLU] = 910732593752702976LLU;

		@@ -45787,25 +45861,25 @@
45787	45861	label = 2451LLU; // assertu64
45788	45862	break;
45789	45863	}
45790		- case 3855LLU: // copy-back deleter (assertu64 to procblock)
	45864	+ case 3864LLU: // copy-back deleter (assertu64 to procblock)
45791	45865	{
45792	45866	// copy mutable arguments back from call to assertu64
45793		- label = 3847LLU; // continue to roll stack
	45867	+ label = 3856LLU; // continue to roll stack
45794	45868	break;
45795	45869	}
45796		- case 3856LLU: // return from assertu64 to procblock
	45870	+ case 3865LLU: // return from assertu64 to procblock
45797	45871	{
45798	45872	// copy mutable arguments back from call to assertu64
45799		- label = 3854LLU; // consequent complete
	45873	+ label = 3863LLU; // consequent complete
45800	45874	break;
45801	45875	}
45802		- case 3853LLU: // alternative
	45876	+ case 3862LLU: // alternative
45803	45877	{
45804	45878	fprintf(stderr, "%s", "expected identifier in while but found ");
45805	45879	// call reporttok from procblock
45806		- stack[base + 28LLU] = 3857LLU/throw to this address/;
	45880	+ stack[base + 28LLU] = 3866LLU/throw to this address/;
45807	45881	stack[base + 29LLU] = base;
45808		- stack[base + 30LLU] = 3858LLU;
	45882	+ stack[base + 30LLU] = 3867LLU;
45809	45883	// arguments for call to reporttok
45810	45884	stack[base + 31LLU] = stack[base + 15]/variant/;
45811	45885	stack[base + 32LLU] = stack[base + 27]/loopid/;

		@@ -45814,30 +45888,30 @@
45814	45888	label = 18446744073709551582LLU; // reporttok
45815	45889	break;
45816	45890	}
45817		- case 3857LLU: // copy-back deleter (reporttok to procblock)
	45891	+ case 3866LLU: // copy-back deleter (reporttok to procblock)
45818	45892	{
45819	45893	// copy mutable arguments back from call to reporttok
45820		- label = 3847LLU; // continue to roll stack
	45894	+ label = 3856LLU; // continue to roll stack
45821	45895	break;
45822	45896	}
45823		- case 3858LLU: // return from reporttok to procblock
	45897	+ case 3867LLU: // return from reporttok to procblock
45824	45898	{
45825	45899	// copy mutable arguments back from call to reporttok
45826	45900	fprintf(stderr, "%s", "\n");
45827	45901	{
45828		- label = 3847LLU; // throw: begin to unroll stack
	45902	+ label = 3856LLU; // throw: begin to unroll stack
45829	45903	break;
45830	45904	}
45831	45905
45832		- label = 3854LLU; // alternative complete
	45906	+ label = 3863LLU; // alternative complete
45833	45907	break;
45834	45908	}
45835		- case 3854LLU: // completed if-then-else
	45909	+ case 3863LLU: // completed if-then-else
45836	45910	{
45837	45911	// call matchsym from procblock
45838		- stack[base + 28LLU] = 3859LLU/throw to this address/;
	45912	+ stack[base + 28LLU] = 3868LLU/throw to this address/;
45839	45913	stack[base + 29LLU] = base;
45840		- stack[base + 30LLU] = 3860LLU;
	45914	+ stack[base + 30LLU] = 3869LLU;
45841	45915	// arguments for call to matchsym
45842	45916	stack[base + 31LLU] = stack[base + 8]/fnid/;
45843	45917	stack[base + 32LLU] = 41LLU;

		@@ -45847,28 +45921,28 @@
45847	45921	label = 246LLU; // matchsym
45848	45922	break;
45849	45923	}
45850		- case 3859LLU: // copy-back deleter (matchsym to procblock)
	45924	+ case 3868LLU: // copy-back deleter (matchsym to procblock)
45851	45925	{
45852	45926	// copy mutable arguments back from call to matchsym
45853	45927	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45854		- label = 3847LLU; // continue to roll stack
	45928	+ label = 3856LLU; // continue to roll stack
45855	45929	break;
45856	45930	}
45857		- case 3860LLU: // return from matchsym to procblock
	45931	+ case 3869LLU: // return from matchsym to procblock
45858	45932	{
45859	45933	// copy mutable arguments back from call to matchsym
45860	45934	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45861	45935	if(!stack[base + 25]/decflag/)
45862	45936	{
45863		- label = 3861LLU; // jump to alternative
	45937	+ label = 3870LLU; // jump to alternative
45864	45938	break;
45865	45939	}
45866	45940
45867	45941	// consequent
45868	45942	// call matchsym from procblock
45869		- stack[base + 28LLU] = 3863LLU/throw to this address/;
	45943	+ stack[base + 28LLU] = 3872LLU/throw to this address/;
45870	45944	stack[base + 29LLU] = base;
45871		- stack[base + 30LLU] = 3864LLU;
	45945	+ stack[base + 30LLU] = 3873LLU;
45872	45946	// arguments for call to matchsym
45873	45947	stack[base + 31LLU] = stack[base + 8]/fnid/;
45874	45948	stack[base + 32LLU] = 45LLU;

		@@ -45878,21 +45952,21 @@
45878	45952	label = 246LLU; // matchsym
45879	45953	break;
45880	45954	}
45881		- case 3863LLU: // copy-back deleter (matchsym to procblock)
	45955	+ case 3872LLU: // copy-back deleter (matchsym to procblock)
45882	45956	{
45883	45957	// copy mutable arguments back from call to matchsym
45884	45958	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45885		- label = 3847LLU; // continue to roll stack
	45959	+ label = 3856LLU; // continue to roll stack
45886	45960	break;
45887	45961	}
45888		- case 3864LLU: // return from matchsym to procblock
	45962	+ case 3873LLU: // return from matchsym to procblock
45889	45963	{
45890	45964	// copy mutable arguments back from call to matchsym
45891	45965	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45892	45966	// call matchsym from procblock
45893		- stack[base + 28LLU] = 3865LLU/throw to this address/;
	45967	+ stack[base + 28LLU] = 3874LLU/throw to this address/;
45894	45968	stack[base + 29LLU] = base;
45895		- stack[base + 30LLU] = 3866LLU;
	45969	+ stack[base + 30LLU] = 3875LLU;
45896	45970	// arguments for call to matchsym
45897	45971	stack[base + 31LLU] = stack[base + 8]/fnid/;
45898	45972	stack[base + 32LLU] = 62LLU;

		@@ -45902,21 +45976,21 @@
45902	45976	label = 246LLU; // matchsym
45903	45977	break;
45904	45978	}
45905		- case 3865LLU: // copy-back deleter (matchsym to procblock)
	45979	+ case 3874LLU: // copy-back deleter (matchsym to procblock)
45906	45980	{
45907	45981	// copy mutable arguments back from call to matchsym
45908	45982	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45909		- label = 3847LLU; // continue to roll stack
	45983	+ label = 3856LLU; // continue to roll stack
45910	45984	break;
45911	45985	}
45912		- case 3866LLU: // return from matchsym to procblock
	45986	+ case 3875LLU: // return from matchsym to procblock
45913	45987	{
45914	45988	// copy mutable arguments back from call to matchsym
45915	45989	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45916	45990	// call matchsym from procblock
45917		- stack[base + 28LLU] = 3867LLU/throw to this address/;
	45991	+ stack[base + 28LLU] = 3876LLU/throw to this address/;
45918	45992	stack[base + 29LLU] = base;
45919		- stack[base + 30LLU] = 3868LLU;
	45993	+ stack[base + 30LLU] = 3877LLU;
45920	45994	// arguments for call to matchsym
45921	45995	stack[base + 31LLU] = stack[base + 8]/fnid/;
45922	45996	stack[base + 32LLU] = 40LLU;

		@@ -45926,38 +46000,38 @@
45926	46000	label = 246LLU; // matchsym
45927	46001	break;
45928	46002	}
45929		- case 3867LLU: // copy-back deleter (matchsym to procblock)
	46003	+ case 3876LLU: // copy-back deleter (matchsym to procblock)
45930	46004	{
45931	46005	// copy mutable arguments back from call to matchsym
45932	46006	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45933		- label = 3847LLU; // continue to roll stack
	46007	+ label = 3856LLU; // continue to roll stack
45934	46008	break;
45935	46009	}
45936		- case 3868LLU: // return from matchsym to procblock
	46010	+ case 3877LLU: // return from matchsym to procblock
45937	46011	{
45938	46012	// copy mutable arguments back from call to matchsym
45939	46013	stack[base + 19]/lookahead/ = stack[base + 33LLU];
45940		- label = 3870LLU; // skip deleter
	46014	+ label = 3879LLU; // skip deleter
45941	46015	break;
45942	46016	}
45943		- case 3869LLU: // deleter
	46017	+ case 3878LLU: // deleter
45944	46018	{
45945	46019	// throw from procblock
45946	46020	if(!stack[base + 28])
45947	46021	{
45948		- label = 3847LLU; // skip, variable already deleted/unscoped
	46022	+ label = 3856LLU; // skip, variable already deleted/unscoped
45949	46023	break;
45950	46024	}
45951		- label = 3847LLU; // continue unrolling stack, delete next variable
	46025	+ label = 3856LLU; // continue unrolling stack, delete next variable
45952	46026	break;
45953	46027	}
45954		- case 3870LLU: // skipped deleter
	46028	+ case 3879LLU: // skipped deleter
45955	46029	{
45956	46030	stack[base + 28] = 0;
45957	46031	// call ParseToken from procblock
45958		- stack[base + 29LLU] = 3871LLU/throw to this address/;
	46032	+ stack[base + 29LLU] = 3880LLU/throw to this address/;
45959	46033	stack[base + 30LLU] = base;
45960		- stack[base + 31LLU] = 3872LLU;
	46034	+ stack[base + 31LLU] = 3881LLU;
45961	46035	// arguments for call to ParseToken
45962	46036	stack[base + 34LLU] = stack[base + 19]/lookahead/;
45963	46037	// set stack-base & callee-address

		@@ -45965,14 +46039,14 @@
45965	46039	label = 3LLU; // ParseToken
45966	46040	break;
45967	46041	}
45968		- case 3871LLU: // copy-back deleter (ParseToken to procblock)
	46042	+ case 3880LLU: // copy-back deleter (ParseToken to procblock)
45969	46043	{
45970	46044	// copy mutable arguments back from call to ParseToken
45971	46045	stack[base + 19]/lookahead/ = stack[base + 34LLU];
45972		- label = 3869LLU; // continue to roll stack
	46046	+ label = 3878LLU; // continue to roll stack
45973	46047	break;
45974	46048	}
45975		- case 3872LLU: // return from ParseToken to procblock
	46049	+ case 3881LLU: // return from ParseToken to procblock
45976	46050	{
45977	46051	// copy mutable arguments back from call to ParseToken
45978	46052	stack[base + 19]/lookahead/ = stack[base + 34LLU];

		@@ -45980,9 +46054,9 @@
45980	46054	stack[base + 15] = stack[base + 32LLU];
45981	46055	stack[base + 28] = stack[base + 33LLU];
45982	46056	// call equ from procblock
45983		- stack[base + 29LLU] = 3873LLU/throw to this address/;
	46057	+ stack[base + 29LLU] = 3882LLU/throw to this address/;
45984	46058	stack[base + 30LLU] = base;
45985		- stack[base + 31LLU] = 3874LLU;
	46059	+ stack[base + 31LLU] = 3883LLU;
45986	46060	// arguments for call to equ
45987	46061	stack[base + 33LLU] = stack[base + 15]/variant/;
45988	46062	stack[base + 34LLU] = 4LLU;

		@@ -45991,13 +46065,13 @@
45991	46065	label = 18446744073709551600LLU; // equ
45992	46066	break;
45993	46067	}
45994		- case 3873LLU: // copy-back deleter (equ to procblock)
	46068	+ case 3882LLU: // copy-back deleter (equ to procblock)
45995	46069	{
45996	46070	// copy mutable arguments back from call to equ
45997		- label = 3869LLU; // continue to roll stack
	46071	+ label = 3878LLU; // continue to roll stack
45998	46072	break;
45999	46073	}
46000		- case 3874LLU: // return from equ to procblock
	46074	+ case 3883LLU: // return from equ to procblock
46001	46075	{
46002	46076	// copy mutable arguments back from call to equ
46003	46077	// copy back results provided by call to equ

		@@ -46004,15 +46078,15 @@
46004	46078	stack[base + 20] = stack[base + 32LLU];
46005	46079	if(!stack[base + 20]/isequal/)
46006	46080	{
46007		- label = 3875LLU; // jump to alternative
	46081	+ label = 3884LLU; // jump to alternative
46008	46082	break;
46009	46083	}
46010	46084
46011	46085	// consequent
46012	46086	// call assertu64 from procblock
46013		- stack[base + 29LLU] = 3877LLU/throw to this address/;
	46087	+ stack[base + 29LLU] = 3886LLU/throw to this address/;
46014	46088	stack[base + 30LLU] = base;
46015		- stack[base + 31LLU] = 3878LLU;
	46089	+ stack[base + 31LLU] = 3887LLU;
46016	46090	// arguments for call to assertu64
46017	46091	stack[base + 32LLU] = stack[base + 8]/fnid/;
46018	46092	stack[base + 33LLU] = 910732593752702976LLU;

		@@ -46024,25 +46098,25 @@
46024	46098	label = 2451LLU; // assertu64
46025	46099	break;
46026	46100	}
46027		- case 3877LLU: // copy-back deleter (assertu64 to procblock)
	46101	+ case 3886LLU: // copy-back deleter (assertu64 to procblock)
46028	46102	{
46029	46103	// copy mutable arguments back from call to assertu64
46030		- label = 3869LLU; // continue to roll stack
	46104	+ label = 3878LLU; // continue to roll stack
46031	46105	break;
46032	46106	}
46033		- case 3878LLU: // return from assertu64 to procblock
	46107	+ case 3887LLU: // return from assertu64 to procblock
46034	46108	{
46035	46109	// copy mutable arguments back from call to assertu64
46036		- label = 3876LLU; // consequent complete
	46110	+ label = 3885LLU; // consequent complete
46037	46111	break;
46038	46112	}
46039		- case 3875LLU: // alternative
	46113	+ case 3884LLU: // alternative
46040	46114	{
46041	46115	fprintf(stderr, "%s", "expected identifier in while but found ");
46042	46116	// call reporttok from procblock
46043		- stack[base + 29LLU] = 3879LLU/throw to this address/;
	46117	+ stack[base + 29LLU] = 3888LLU/throw to this address/;
46044	46118	stack[base + 30LLU] = base;
46045		- stack[base + 31LLU] = 3880LLU;
	46119	+ stack[base + 31LLU] = 3889LLU;
46046	46120	// arguments for call to reporttok
46047	46121	stack[base + 32LLU] = stack[base + 15]/variant/;
46048	46122	stack[base + 33LLU] = stack[base + 28]/counterid/;

		@@ -46051,30 +46125,30 @@
46051	46125	label = 18446744073709551582LLU; // reporttok
46052	46126	break;
46053	46127	}
46054		- case 3879LLU: // copy-back deleter (reporttok to procblock)
	46128	+ case 3888LLU: // copy-back deleter (reporttok to procblock)
46055	46129	{
46056	46130	// copy mutable arguments back from call to reporttok
46057		- label = 3869LLU; // continue to roll stack
	46131	+ label = 3878LLU; // continue to roll stack
46058	46132	break;
46059	46133	}
46060		- case 3880LLU: // return from reporttok to procblock
	46134	+ case 3889LLU: // return from reporttok to procblock
46061	46135	{
46062	46136	// copy mutable arguments back from call to reporttok
46063	46137	fprintf(stderr, "%s", "\n");
46064	46138	{
46065		- label = 3869LLU; // throw: begin to unroll stack
	46139	+ label = 3878LLU; // throw: begin to unroll stack
46066	46140	break;
46067	46141	}
46068	46142
46069		- label = 3876LLU; // alternative complete
	46143	+ label = 3885LLU; // alternative complete
46070	46144	break;
46071	46145	}
46072		- case 3876LLU: // completed if-then-else
	46146	+ case 3885LLU: // completed if-then-else
46073	46147	{
46074	46148	// call matchsym from procblock
46075		- stack[base + 29LLU] = 3881LLU/throw to this address/;
	46149	+ stack[base + 29LLU] = 3890LLU/throw to this address/;
46076	46150	stack[base + 30LLU] = base;
46077		- stack[base + 31LLU] = 3882LLU;
	46151	+ stack[base + 31LLU] = 3891LLU;
46078	46152	// arguments for call to matchsym
46079	46153	stack[base + 32LLU] = stack[base + 8]/fnid/;
46080	46154	stack[base + 33LLU] = 41LLU;

		@@ -46084,26 +46158,26 @@
46084	46158	label = 246LLU; // matchsym
46085	46159	break;
46086	46160	}
46087		- case 3881LLU: // copy-back deleter (matchsym to procblock)
	46161	+ case 3890LLU: // copy-back deleter (matchsym to procblock)
46088	46162	{
46089	46163	// copy mutable arguments back from call to matchsym
46090	46164	stack[base + 19]/lookahead/ = stack[base + 34LLU];
46091		- label = 3869LLU; // continue to roll stack
	46165	+ label = 3878LLU; // continue to roll stack
46092	46166	break;
46093	46167	}
46094		- case 3882LLU: // return from matchsym to procblock
	46168	+ case 3891LLU: // return from matchsym to procblock
46095	46169	{
46096	46170	// copy mutable arguments back from call to matchsym
46097	46171	stack[base + 19]/lookahead/ = stack[base + 34LLU];
46098		- label = 3884LLU; // skip deleter
	46172	+ label = 3893LLU; // skip deleter
46099	46173	break;
46100	46174	}
46101		- case 3883LLU: // deleter
	46175	+ case 3892LLU: // deleter
46102	46176	{
46103	46177	// throw from procblock
46104	46178	if(!stack[base + 29])
46105	46179	{
46106		- label = 3869LLU; // skip, variable already deleted/unscoped
	46180	+ label = 3878LLU; // skip, variable already deleted/unscoped
46107	46181	break;
46108	46182	}
46109	46183

		@@ -46112,7 +46186,7 @@
46112	46186	newstack[0] = (uint64_t)stack; // backup stack location
46113	46187	newstack[1] = 1234567890;
46114	46188	newstack[2] = base;
46115		- newstack[3] = 3885LLU;
	46189	+ newstack[3] = 3894LLU;
46116	46190	stack = newstack;
46117	46191	// set stack-base & callee-address
46118	46192	base = 4/deloffset/;

		@@ -46119,21 +46193,21 @@
46119	46193	label = 310LLU; // ~type
46120	46194	break;
46121	46195	}
46122		- case 3885LLU: // return from ~type to procblock
	46196	+ case 3894LLU: // return from ~type to procblock
46123	46197	{
46124	46198	stack = (uint64_t *)stack[0];
46125	46199	// releasing toplevel container
46126	46200	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 29] - sizeof(uint64_t) 4));
46127	46201
46128		- label = 3869LLU; // continue unrolling stack, delete next variable
	46202	+ label = 3878LLU; // continue unrolling stack, delete next variable
46129	46203	break;
46130	46204	}
46131		- case 3884LLU: // skipped deleter
	46205	+ case 3893LLU: // skipped deleter
46132	46206	{
46133	46207	// call mktypedata from procblock
46134		- stack[base + 30LLU] = 3886LLU/throw to this address/;
	46208	+ stack[base + 30LLU] = 3895LLU/throw to this address/;
46135	46209	stack[base + 31LLU] = base;
46136		- stack[base + 32LLU] = 3887LLU;
	46210	+ stack[base + 32LLU] = 3896LLU;
46137	46211	// arguments for call to mktypedata
46138	46212	stack[base + 34LLU] = 881834713755418624LLU;
46139	46213	// set stack-base & callee-address

		@@ -46141,37 +46215,37 @@
46141	46215	label = 314LLU; // mktypedata
46142	46216	break;
46143	46217	}
46144		- case 3886LLU: // copy-back deleter (mktypedata to procblock)
	46218	+ case 3895LLU: // copy-back deleter (mktypedata to procblock)
46145	46219	{
46146	46220	// copy mutable arguments back from call to mktypedata
46147		- label = 3869LLU; // continue to roll stack
	46221	+ label = 3878LLU; // continue to roll stack
46148	46222	break;
46149	46223	}
46150		- case 3887LLU: // return from mktypedata to procblock
	46224	+ case 3896LLU: // return from mktypedata to procblock
46151	46225	{
46152	46226	// copy mutable arguments back from call to mktypedata
46153	46227	// copy back results provided by call to mktypedata
46154	46228	stack[base + 29] = stack[base + 33LLU];
46155		- label = 3889LLU; // skip deleter
	46229	+ label = 3898LLU; // skip deleter
46156	46230	break;
46157	46231	}
46158		- case 3888LLU: // deleter
	46232	+ case 3897LLU: // deleter
46159	46233	{
46160	46234	// throw from procblock
46161	46235	if(!stack[base + 30])
46162	46236	{
46163		- label = 3883LLU; // skip, variable already deleted/unscoped
	46237	+ label = 3892LLU; // skip, variable already deleted/unscoped
46164	46238	break;
46165	46239	}
46166		- label = 3883LLU; // continue unrolling stack, delete next variable
	46240	+ label = 3892LLU; // continue unrolling stack, delete next variable
46167	46241	break;
46168	46242	}
46169		- case 3889LLU: // skipped deleter
	46243	+ case 3898LLU: // skipped deleter
46170	46244	{
46171	46245	// call newvarraw from procblock
46172		- stack[base + 31LLU] = 3890LLU/throw to this address/;
	46246	+ stack[base + 31LLU] = 3899LLU/throw to this address/;
46173	46247	stack[base + 32LLU] = base;
46174		- stack[base + 33LLU] = 3891LLU;
	46248	+ stack[base + 33LLU] = 3900LLU;
46175	46249	// arguments for call to newvarraw
46176	46250	stack[base + 35LLU] = stack[base + 29]/counttype/;
46177	46251	stack[base + 36LLU] = stack[base + 28]/counterid/;

		@@ -46187,16 +46261,16 @@
46187	46261	label = 759LLU; // newvarraw
46188	46262	break;
46189	46263	}
46190		- case 3890LLU: // copy-back deleter (newvarraw to procblock)
	46264	+ case 3899LLU: // copy-back deleter (newvarraw to procblock)
46191	46265	{
46192	46266	// copy mutable arguments back from call to newvarraw
46193	46267	stack[base + 3]/scope/ = stack[base + 42LLU];
46194	46268	stack[base + 18]/varcount/ = stack[base + 41LLU];
46195	46269	stack[base + 12]/fnmaxcount/ = stack[base + 40LLU];
46196		- label = 3883LLU; // continue to roll stack
	46270	+ label = 3892LLU; // continue to roll stack
46197	46271	break;
46198	46272	}
46199		- case 3891LLU: // return from newvarraw to procblock
	46273	+ case 3900LLU: // return from newvarraw to procblock
46200	46274	{
46201	46275	// copy mutable arguments back from call to newvarraw
46202	46276	stack[base + 3]/scope/ = stack[base + 42LLU];

		@@ -46206,9 +46280,9 @@
46206	46280	stack[base + 30] = stack[base + 34LLU];
46207	46281	printf("%s", "\n ");
46208	46282	// call emitvaridx from procblock
46209		- stack[base + 31LLU] = 3892LLU/throw to this address/;
	46283	+ stack[base + 31LLU] = 3901LLU/throw to this address/;
46210	46284	stack[base + 32LLU] = base;
46211		- stack[base + 33LLU] = 3893LLU;
	46285	+ stack[base + 33LLU] = 3902LLU;
46212	46286	// arguments for call to emitvaridx
46213	46287	stack[base + 34LLU] = stack[base + 30]/counteridx/;
46214	46288	// set stack-base & callee-address

		@@ -46216,20 +46290,20 @@
46216	46290	label = 745LLU; // emitvaridx
46217	46291	break;
46218	46292	}
46219		- case 3892LLU: // copy-back deleter (emitvaridx to procblock)
	46293	+ case 3901LLU: // copy-back deleter (emitvaridx to procblock)
46220	46294	{
46221	46295	// copy mutable arguments back from call to emitvaridx
46222		- label = 3888LLU; // continue to roll stack
	46296	+ label = 3897LLU; // continue to roll stack
46223	46297	break;
46224	46298	}
46225		- case 3893LLU: // return from emitvaridx to procblock
	46299	+ case 3902LLU: // return from emitvaridx to procblock
46226	46300	{
46227	46301	// copy mutable arguments back from call to emitvaridx
46228	46302	printf("%s", " = ");
46229	46303	// call emitvar from procblock
46230		- stack[base + 31LLU] = 3894LLU/throw to this address/;
	46304	+ stack[base + 31LLU] = 3903LLU/throw to this address/;
46231	46305	stack[base + 32LLU] = base;
46232		- stack[base + 33LLU] = 3895LLU;
	46306	+ stack[base + 33LLU] = 3904LLU;
46233	46307	// arguments for call to emitvar
46234	46308	stack[base + 34LLU] = stack[base + 8]/fnid/;
46235	46309	stack[base + 35LLU] = stack[base + 27]/loopid/;

		@@ -46240,21 +46314,21 @@
46240	46314	label = 749LLU; // emitvar
46241	46315	break;
46242	46316	}
46243		- case 3894LLU: // copy-back deleter (emitvar to procblock)
	46317	+ case 3903LLU: // copy-back deleter (emitvar to procblock)
46244	46318	{
46245	46319	// copy mutable arguments back from call to emitvar
46246		- label = 3888LLU; // continue to roll stack
	46320	+ label = 3897LLU; // continue to roll stack
46247	46321	break;
46248	46322	}
46249		- case 3895LLU: // return from emitvar to procblock
	46323	+ case 3904LLU: // return from emitvar to procblock
46250	46324	{
46251	46325	// copy mutable arguments back from call to emitvar
46252	46326	printf("%s", ";\n");
46253	46327	printf("%s", "\n label = ");
46254	46328	// call printnr from procblock
46255		- stack[base + 31LLU] = 3896LLU/throw to this address/;
	46329	+ stack[base + 31LLU] = 3905LLU/throw to this address/;
46256	46330	stack[base + 32LLU] = base;
46257		- stack[base + 33LLU] = 3897LLU;
	46331	+ stack[base + 33LLU] = 3906LLU;
46258	46332	// arguments for call to printnr
46259	46333	stack[base + 34LLU] = stack[base + 23]/labelloop/;
46260	46334	// set stack-base & callee-address

		@@ -46262,13 +46336,13 @@
46262	46336	label = 18446744073709551590LLU; // printnr
46263	46337	break;
46264	46338	}
46265		- case 3896LLU: // copy-back deleter (printnr to procblock)
	46339	+ case 3905LLU: // copy-back deleter (printnr to procblock)
46266	46340	{
46267	46341	// copy mutable arguments back from call to printnr
46268		- label = 3888LLU; // continue to roll stack
	46342	+ label = 3897LLU; // continue to roll stack
46269	46343	break;
46270	46344	}
46271		- case 3897LLU: // return from printnr to procblock
	46345	+ case 3906LLU: // return from printnr to procblock
46272	46346	{
46273	46347	// copy mutable arguments back from call to printnr
46274	46348	printf("%s", "LLU; // start to repeat");

		@@ -46276,9 +46350,9 @@
46276	46350	printf("%s", "\n }");
46277	46351	printf("%s", "\n case ");
46278	46352	// call printnr from procblock
46279		- stack[base + 31LLU] = 3898LLU/throw to this address/;
	46353	+ stack[base + 31LLU] = 3907LLU/throw to this address/;
46280	46354	stack[base + 32LLU] = base;
46281		- stack[base + 33LLU] = 3899LLU;
	46355	+ stack[base + 33LLU] = 3908LLU;
46282	46356	// arguments for call to printnr
46283	46357	stack[base + 34LLU] = stack[base + 23]/labelloop/;
46284	46358	// set stack-base & callee-address

		@@ -46286,13 +46360,13 @@
46286	46360	label = 18446744073709551590LLU; // printnr
46287	46361	break;
46288	46362	}
46289		- case 3898LLU: // copy-back deleter (printnr to procblock)
	46363	+ case 3907LLU: // copy-back deleter (printnr to procblock)
46290	46364	{
46291	46365	// copy mutable arguments back from call to printnr
46292		- label = 3888LLU; // continue to roll stack
	46366	+ label = 3897LLU; // continue to roll stack
46293	46367	break;
46294	46368	}
46295		- case 3899LLU: // return from printnr to procblock
	46369	+ case 3908LLU: // return from printnr to procblock
46296	46370	{
46297	46371	// copy mutable arguments back from call to printnr
46298	46372	printf("%s", "LLU: // repeat from here");

		@@ -46299,9 +46373,9 @@
46299	46373	printf("%s", "\n {");
46300	46374	printf("%s", "\n if(!");
46301	46375	// call emitvaridx from procblock
46302		- stack[base + 31LLU] = 3900LLU/throw to this address/;
	46376	+ stack[base + 31LLU] = 3909LLU/throw to this address/;
46303	46377	stack[base + 32LLU] = base;
46304		- stack[base + 33LLU] = 3901LLU;
	46378	+ stack[base + 33LLU] = 3910LLU;
46305	46379	// arguments for call to emitvaridx
46306	46380	stack[base + 34LLU] = stack[base + 30]/counteridx/;
46307	46381	// set stack-base & callee-address

		@@ -46309,13 +46383,13 @@
46309	46383	label = 745LLU; // emitvaridx
46310	46384	break;
46311	46385	}
46312		- case 3900LLU: // copy-back deleter (emitvaridx to procblock)
	46386	+ case 3909LLU: // copy-back deleter (emitvaridx to procblock)
46313	46387	{
46314	46388	// copy mutable arguments back from call to emitvaridx
46315		- label = 3888LLU; // continue to roll stack
	46389	+ label = 3897LLU; // continue to roll stack
46316	46390	break;
46317	46391	}
46318		- case 3901LLU: // return from emitvaridx to procblock
	46392	+ case 3910LLU: // return from emitvaridx to procblock
46319	46393	{
46320	46394	// copy mutable arguments back from call to emitvaridx
46321	46395	printf("%s", "--)");

		@@ -46325,7 +46399,7 @@
46325	46399	newstack[0] = (uint64_t)stack; // backup stack location
46326	46400	newstack[1] = 1234567890;
46327	46401	newstack[2] = base;
46328		- newstack[3] = 3902LLU;
	46402	+ newstack[3] = 3911LLU;
46329	46403	stack = newstack;
46330	46404	// set stack-base & callee-address
46331	46405	base = 4/deloffset/;

		@@ -46332,22 +46406,22 @@
46332	46406	label = 310LLU; // ~type
46333	46407	break;
46334	46408	}
46335		- case 3902LLU: // return from ~type to procblock
	46409	+ case 3911LLU: // return from ~type to procblock
46336	46410	{
46337	46411	stack = (uint64_t *)stack[0];
46338	46412	// releasing toplevel container
46339	46413	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 29] - sizeof(uint64_t) 4));
46340	46414
46341		- label = 3862LLU; // consequent complete
	46415	+ label = 3871LLU; // consequent complete
46342	46416	break;
46343	46417	}
46344		- case 3861LLU: // alternative
	46418	+ case 3870LLU: // alternative
46345	46419	{
46346	46420	printf("%s", "\n label = ");
46347	46421	// call printnr from procblock
46348		- stack[base + 28LLU] = 3903LLU/throw to this address/;
	46422	+ stack[base + 28LLU] = 3912LLU/throw to this address/;
46349	46423	stack[base + 29LLU] = base;
46350		- stack[base + 30LLU] = 3904LLU;
	46424	+ stack[base + 30LLU] = 3913LLU;
46351	46425	// arguments for call to printnr
46352	46426	stack[base + 31LLU] = stack[base + 23]/labelloop/;
46353	46427	// set stack-base & callee-address

		@@ -46355,13 +46429,13 @@
46355	46429	label = 18446744073709551590LLU; // printnr
46356	46430	break;
46357	46431	}
46358		- case 3903LLU: // copy-back deleter (printnr to procblock)
	46432	+ case 3912LLU: // copy-back deleter (printnr to procblock)
46359	46433	{
46360	46434	// copy mutable arguments back from call to printnr
46361		- label = 3847LLU; // continue to roll stack
	46435	+ label = 3856LLU; // continue to roll stack
46362	46436	break;
46363	46437	}
46364		- case 3904LLU: // return from printnr to procblock
	46438	+ case 3913LLU: // return from printnr to procblock
46365	46439	{
46366	46440	// copy mutable arguments back from call to printnr
46367	46441	printf("%s", "LLU; // start to repeat");

		@@ -46369,9 +46443,9 @@
46369	46443	printf("%s", "\n }");
46370	46444	printf("%s", "\n case ");
46371	46445	// call printnr from procblock
46372		- stack[base + 28LLU] = 3905LLU/throw to this address/;
	46446	+ stack[base + 28LLU] = 3914LLU/throw to this address/;
46373	46447	stack[base + 29LLU] = base;
46374		- stack[base + 30LLU] = 3906LLU;
	46448	+ stack[base + 30LLU] = 3915LLU;
46375	46449	// arguments for call to printnr
46376	46450	stack[base + 31LLU] = stack[base + 23]/labelloop/;
46377	46451	// set stack-base & callee-address

		@@ -46379,13 +46453,13 @@
46379	46453	label = 18446744073709551590LLU; // printnr
46380	46454	break;
46381	46455	}
46382		- case 3905LLU: // copy-back deleter (printnr to procblock)
	46456	+ case 3914LLU: // copy-back deleter (printnr to procblock)
46383	46457	{
46384	46458	// copy mutable arguments back from call to printnr
46385		- label = 3847LLU; // continue to roll stack
	46459	+ label = 3856LLU; // continue to roll stack
46386	46460	break;
46387	46461	}
46388		- case 3906LLU: // return from printnr to procblock
	46462	+ case 3915LLU: // return from printnr to procblock
46389	46463	{
46390	46464	// copy mutable arguments back from call to printnr
46391	46465	printf("%s", "LLU: // repeat from here");

		@@ -46392,31 +46466,31 @@
46392	46466	printf("%s", "\n {");
46393	46467	if(!stack[base + 26]/inputflag/)
46394	46468	{
46395		- label = 3907LLU; // jump to alternative
	46469	+ label = 3916LLU; // jump to alternative
46396	46470	break;
46397	46471	}
46398	46472
46399	46473	// consequent
46400		- label = 3910LLU; // skip deleter
	46474	+ label = 3919LLU; // skip deleter
46401	46475	break;
46402	46476	}
46403		- case 3909LLU: // deleter
	46477	+ case 3918LLU: // deleter
46404	46478	{
46405	46479	// throw from procblock
46406	46480	if(!stack[base + 28])
46407	46481	{
46408		- label = 3847LLU; // skip, variable already deleted/unscoped
	46482	+ label = 3856LLU; // skip, variable already deleted/unscoped
46409	46483	break;
46410	46484	}
46411		- label = 3847LLU; // continue unrolling stack, delete next variable
	46485	+ label = 3856LLU; // continue unrolling stack, delete next variable
46412	46486	break;
46413	46487	}
46414		- case 3910LLU: // skipped deleter
	46488	+ case 3919LLU: // skipped deleter
46415	46489	{
46416	46490	// call findletmut from procblock
46417		- stack[base + 29LLU] = 3911LLU/throw to this address/;
	46491	+ stack[base + 29LLU] = 3920LLU/throw to this address/;
46418	46492	stack[base + 30LLU] = base;
46419		- stack[base + 31LLU] = 3912LLU;
	46493	+ stack[base + 31LLU] = 3921LLU;
46420	46494	// arguments for call to findletmut
46421	46495	stack[base + 33LLU] = stack[base + 8]/fnid/;
46422	46496	stack[base + 34LLU] = stack[base + 27]/loopid/;

		@@ -46427,13 +46501,13 @@
46427	46501	label = 718LLU; // findletmut
46428	46502	break;
46429	46503	}
46430		- case 3911LLU: // copy-back deleter (findletmut to procblock)
	46504	+ case 3920LLU: // copy-back deleter (findletmut to procblock)
46431	46505	{
46432	46506	// copy mutable arguments back from call to findletmut
46433		- label = 3847LLU; // continue to roll stack
	46507	+ label = 3856LLU; // continue to roll stack
46434	46508	break;
46435	46509	}
46436		- case 3912LLU: // return from findletmut to procblock
	46510	+ case 3921LLU: // return from findletmut to procblock
46437	46511	{
46438	46512	// copy mutable arguments back from call to findletmut
46439	46513	// copy back results provided by call to findletmut

		@@ -46440,21 +46514,21 @@
46440	46514	stack[base + 28] = stack[base + 32LLU];
46441	46515	if(!stack[base + 28]/mutable/)
46442	46516	{
46443		- label = 3913LLU; // jump to alternative
	46517	+ label = 3922LLU; // jump to alternative
46444	46518	break;
46445	46519	}
46446	46520
46447	46521	// consequent
46448		- label = 3914LLU; // consequent complete
	46522	+ label = 3923LLU; // consequent complete
46449	46523	break;
46450	46524	}
46451		- case 3913LLU: // alternative
	46525	+ case 3922LLU: // alternative
46452	46526	{
46453	46527	fprintf(stderr, "%s", "in function ");
46454	46528	// call reportid from procblock
46455		- stack[base + 29LLU] = 3915LLU/throw to this address/;
	46529	+ stack[base + 29LLU] = 3924LLU/throw to this address/;
46456	46530	stack[base + 30LLU] = base;
46457		- stack[base + 31LLU] = 3916LLU;
	46531	+ stack[base + 31LLU] = 3925LLU;
46458	46532	// arguments for call to reportid
46459	46533	stack[base + 32LLU] = stack[base + 8]/fnid/;
46460	46534	// set stack-base & callee-address

		@@ -46462,21 +46536,21 @@
46462	46536	label = 18446744073709551586LLU; // reportid
46463	46537	break;
46464	46538	}
46465		- case 3915LLU: // copy-back deleter (reportid to procblock)
	46539	+ case 3924LLU: // copy-back deleter (reportid to procblock)
46466	46540	{
46467	46541	// copy mutable arguments back from call to reportid
46468		- label = 3909LLU; // continue to roll stack
	46542	+ label = 3918LLU; // continue to roll stack
46469	46543	break;
46470	46544	}
46471		- case 3916LLU: // return from reportid to procblock
	46545	+ case 3925LLU: // return from reportid to procblock
46472	46546	{
46473	46547	// copy mutable arguments back from call to reportid
46474	46548	fprintf(stderr, "%s", ": ");
46475	46549	fprintf(stderr, "%s", "while input requires mutable variable but found constant ");
46476	46550	// call reportid from procblock
46477		- stack[base + 29LLU] = 3917LLU/throw to this address/;
	46551	+ stack[base + 29LLU] = 3926LLU/throw to this address/;
46478	46552	stack[base + 30LLU] = base;
46479		- stack[base + 31LLU] = 3918LLU;
	46553	+ stack[base + 31LLU] = 3927LLU;
46480	46554	// arguments for call to reportid
46481	46555	stack[base + 32LLU] = stack[base + 27]/loopid/;
46482	46556	// set stack-base & callee-address

		@@ -46484,31 +46558,31 @@
46484	46558	label = 18446744073709551586LLU; // reportid
46485	46559	break;
46486	46560	}
46487		- case 3917LLU: // copy-back deleter (reportid to procblock)
	46561	+ case 3926LLU: // copy-back deleter (reportid to procblock)
46488	46562	{
46489	46563	// copy mutable arguments back from call to reportid
46490		- label = 3909LLU; // continue to roll stack
	46564	+ label = 3918LLU; // continue to roll stack
46491	46565	break;
46492	46566	}
46493		- case 3918LLU: // return from reportid to procblock
	46567	+ case 3927LLU: // return from reportid to procblock
46494	46568	{
46495	46569	// copy mutable arguments back from call to reportid
46496	46570	fprintf(stderr, "%s", "\n");
46497	46571	{
46498		- label = 3909LLU; // throw: begin to unroll stack
	46572	+ label = 3918LLU; // throw: begin to unroll stack
46499	46573	break;
46500	46574	}
46501	46575
46502		- label = 3914LLU; // alternative complete
	46576	+ label = 3923LLU; // alternative complete
46503	46577	break;
46504	46578	}
46505		- case 3914LLU: // completed if-then-else
	46579	+ case 3923LLU: // completed if-then-else
46506	46580	{
46507	46581	printf("%s", "\n if(");
46508	46582	// call emitvar from procblock
46509		- stack[base + 29LLU] = 3919LLU/throw to this address/;
	46583	+ stack[base + 29LLU] = 3928LLU/throw to this address/;
46510	46584	stack[base + 30LLU] = base;
46511		- stack[base + 31LLU] = 3920LLU;
	46585	+ stack[base + 31LLU] = 3929LLU;
46512	46586	// arguments for call to emitvar
46513	46587	stack[base + 32LLU] = stack[base + 8]/fnid/;
46514	46588	stack[base + 33LLU] = stack[base + 27]/loopid/;

		@@ -46519,26 +46593,26 @@
46519	46593	label = 749LLU; // emitvar
46520	46594	break;
46521	46595	}
46522		- case 3919LLU: // copy-back deleter (emitvar to procblock)
	46596	+ case 3928LLU: // copy-back deleter (emitvar to procblock)
46523	46597	{
46524	46598	// copy mutable arguments back from call to emitvar
46525		- label = 3909LLU; // continue to roll stack
	46599	+ label = 3918LLU; // continue to roll stack
46526	46600	break;
46527	46601	}
46528		- case 3920LLU: // return from emitvar to procblock
	46602	+ case 3929LLU: // return from emitvar to procblock
46529	46603	{
46530	46604	// copy mutable arguments back from call to emitvar
46531	46605	printf("%s", " > 0xFF)");
46532		- label = 3908LLU; // consequent complete
	46606	+ label = 3917LLU; // consequent complete
46533	46607	break;
46534	46608	}
46535		- case 3907LLU: // alternative
	46609	+ case 3916LLU: // alternative
46536	46610	{
46537	46611	printf("%s", "\n if(!");
46538	46612	// call emitvar from procblock
46539		- stack[base + 28LLU] = 3921LLU/throw to this address/;
	46613	+ stack[base + 28LLU] = 3930LLU/throw to this address/;
46540	46614	stack[base + 29LLU] = base;
46541		- stack[base + 30LLU] = 3922LLU;
	46615	+ stack[base + 30LLU] = 3931LLU;
46542	46616	// arguments for call to emitvar
46543	46617	stack[base + 31LLU] = stack[base + 8]/fnid/;
46544	46618	stack[base + 32LLU] = stack[base + 27]/loopid/;

		@@ -46549,21 +46623,21 @@
46549	46623	label = 749LLU; // emitvar
46550	46624	break;
46551	46625	}
46552		- case 3921LLU: // copy-back deleter (emitvar to procblock)
	46626	+ case 3930LLU: // copy-back deleter (emitvar to procblock)
46553	46627	{
46554	46628	// copy mutable arguments back from call to emitvar
46555		- label = 3847LLU; // continue to roll stack
	46629	+ label = 3856LLU; // continue to roll stack
46556	46630	break;
46557	46631	}
46558		- case 3922LLU: // return from emitvar to procblock
	46632	+ case 3931LLU: // return from emitvar to procblock
46559	46633	{
46560	46634	// copy mutable arguments back from call to emitvar
46561	46635	printf("%s", ")");
46562	46636	fprintf(stderr, "%s", "in function ");
46563	46637	// call reportid from procblock
46564		- stack[base + 28LLU] = 3923LLU/throw to this address/;
	46638	+ stack[base + 28LLU] = 3932LLU/throw to this address/;
46565	46639	stack[base + 29LLU] = base;
46566		- stack[base + 30LLU] = 3924LLU;
	46640	+ stack[base + 30LLU] = 3933LLU;
46567	46641	// arguments for call to reportid
46568	46642	stack[base + 31LLU] = stack[base + 8]/fnid/;
46569	46643	// set stack-base & callee-address

		@@ -46571,35 +46645,35 @@
46571	46645	label = 18446744073709551586LLU; // reportid
46572	46646	break;
46573	46647	}
46574		- case 3923LLU: // copy-back deleter (reportid to procblock)
	46648	+ case 3932LLU: // copy-back deleter (reportid to procblock)
46575	46649	{
46576	46650	// copy mutable arguments back from call to reportid
46577		- label = 3847LLU; // continue to roll stack
	46651	+ label = 3856LLU; // continue to roll stack
46578	46652	break;
46579	46653	}
46580		- case 3924LLU: // return from reportid to procblock
	46654	+ case 3933LLU: // return from reportid to procblock
46581	46655	{
46582	46656	// copy mutable arguments back from call to reportid
46583	46657	fprintf(stderr, "%s", ": plain while loop deactivated\n");
46584	46658	{
46585		- label = 3847LLU; // throw: begin to unroll stack
	46659	+ label = 3856LLU; // throw: begin to unroll stack
46586	46660	break;
46587	46661	}
46588	46662
46589		- label = 3908LLU; // alternative complete
	46663	+ label = 3917LLU; // alternative complete
46590	46664	break;
46591	46665	}
46592		- case 3908LLU: // completed if-then-else
	46666	+ case 3917LLU: // completed if-then-else
46593	46667	{
46594		- label = 3862LLU; // alternative complete
	46668	+ label = 3871LLU; // alternative complete
46595	46669	break;
46596	46670	}
46597		- case 3862LLU: // completed if-then-else
	46671	+ case 3871LLU: // completed if-then-else
46598	46672	{
46599	46673	// call matchsym from procblock
46600		- stack[base + 28LLU] = 3925LLU/throw to this address/;
	46674	+ stack[base + 28LLU] = 3934LLU/throw to this address/;
46601	46675	stack[base + 29LLU] = base;
46602		- stack[base + 30LLU] = 3926LLU;
	46676	+ stack[base + 30LLU] = 3935LLU;
46603	46677	// arguments for call to matchsym
46604	46678	stack[base + 31LLU] = stack[base + 8]/fnid/;
46605	46679	stack[base + 32LLU] = 123LLU;

		@@ -46609,14 +46683,14 @@
46609	46683	label = 246LLU; // matchsym
46610	46684	break;
46611	46685	}
46612		- case 3925LLU: // copy-back deleter (matchsym to procblock)
	46686	+ case 3934LLU: // copy-back deleter (matchsym to procblock)
46613	46687	{
46614	46688	// copy mutable arguments back from call to matchsym
46615	46689	stack[base + 19]/lookahead/ = stack[base + 33LLU];
46616		- label = 3847LLU; // continue to roll stack
	46690	+ label = 3856LLU; // continue to roll stack
46617	46691	break;
46618	46692	}
46619		- case 3926LLU: // return from matchsym to procblock
	46693	+ case 3935LLU: // return from matchsym to procblock
46620	46694	{
46621	46695	// copy mutable arguments back from call to matchsym
46622	46696	stack[base + 19]/lookahead/ = stack[base + 33LLU];

		@@ -46623,9 +46697,9 @@
46623	46697	printf("%s", "\n {");
46624	46698	printf("%s", "\n label = ");
46625	46699	// call printnr from procblock
46626		- stack[base + 28LLU] = 3927LLU/throw to this address/;
	46700	+ stack[base + 28LLU] = 3936LLU/throw to this address/;
46627	46701	stack[base + 29LLU] = base;
46628		- stack[base + 30LLU] = 3928LLU;
	46702	+ stack[base + 30LLU] = 3937LLU;
46629	46703	// arguments for call to printnr
46630	46704	stack[base + 31LLU] = stack[base + 24]/labelskip/;
46631	46705	// set stack-base & callee-address

		@@ -46633,13 +46707,13 @@
46633	46707	label = 18446744073709551590LLU; // printnr
46634	46708	break;
46635	46709	}
46636		- case 3927LLU: // copy-back deleter (printnr to procblock)
	46710	+ case 3936LLU: // copy-back deleter (printnr to procblock)
46637	46711	{
46638	46712	// copy mutable arguments back from call to printnr
46639		- label = 3847LLU; // continue to roll stack
	46713	+ label = 3856LLU; // continue to roll stack
46640	46714	break;
46641	46715	}
46642		- case 3928LLU: // return from printnr to procblock
	46716	+ case 3937LLU: // return from printnr to procblock
46643	46717	{
46644	46718	// copy mutable arguments back from call to printnr
46645	46719	printf("%s", "LLU; // break loop");

		@@ -46647,26 +46721,26 @@
46647	46721	printf("%s", "\n }");
46648	46722	printf("%s", "\n");
46649	46723	printf("%s", "\n // loop body");
46650		- label = 3930LLU; // skip deleter
	46724	+ label = 3939LLU; // skip deleter
46651	46725	break;
46652	46726	}
46653		- case 3929LLU: // deleter
	46727	+ case 3938LLU: // deleter
46654	46728	{
46655	46729	// throw from procblock
46656	46730	if(!stack[base + 28])
46657	46731	{
46658		- label = 3847LLU; // skip, variable already deleted/unscoped
	46732	+ label = 3856LLU; // skip, variable already deleted/unscoped
46659	46733	break;
46660	46734	}
46661	46735	// delete list
46662		- label = 3931LLU; // start to repeat
	46736	+ label = 3940LLU; // start to repeat
46663	46737	break;
46664	46738	}
46665		- case 3931LLU: // repeat from here
	46739	+ case 3940LLU: // repeat from here
46666	46740	{
46667	46741	if(!stack[base + 28])
46668	46742	{
46669		- label = 3932LLU; // break loop
	46743	+ label = 3941LLU; // break loop
46670	46744	break;
46671	46745	}
46672	46746

		@@ -46677,7 +46751,7 @@
46677	46751	newstack[0] = (uint64_t)stack; // backup stack location
46678	46752	newstack[1] = 1234567890;
46679	46753	newstack[2] = base;
46680		- newstack[3] = 3933LLU;
	46754	+ newstack[3] = 3942LLU;
46681	46755	stack = newstack;
46682	46756	// set stack-base & callee-address
46683	46757	base = 4/deloffset/;

		@@ -46684,7 +46758,7 @@
46684	46758	label = 399LLU; // ~typeidx
46685	46759	break;
46686	46760	}
46687		- case 3933LLU: // return from ~typeidx to procblock
	46761	+ case 3942LLU: // return from ~typeidx to procblock
46688	46762	{
46689	46763	stack = (uint64_t *)stack[0];
46690	46764	// releasing toplevel container

		@@ -46695,21 +46769,21 @@
46695	46769	stack[base + 28] = (uint64_t)list->next;
46696	46770	Free(1, sizeof(struct listnode), list);
46697	46771	}
46698		- label = 3931LLU; // repeat
	46772	+ label = 3940LLU; // repeat
46699	46773	break;
46700	46774	}
46701		- case 3932LLU: // loop finished
	46775	+ case 3941LLU: // loop finished
46702	46776	{
46703		- label = 3847LLU; // continue unrolling stack, delete next variable
	46777	+ label = 3856LLU; // continue unrolling stack, delete next variable
46704	46778	break;
46705	46779	}
46706		- case 3930LLU: // skipped deleter
	46780	+ case 3939LLU: // skipped deleter
46707	46781	{
46708	46782	stack[base + 28] = 0;
46709	46783	uint64_t newstack = (uint64_t )Calloc(160LLU + 1, sizeof(uint64_t));
46710	46784	if(!newstack)
46711	46785	{
46712		- label = 3929LLU; // throw: begin to unroll stack
	46786	+ label = 3938LLU; // throw: begin to unroll stack
46713	46787	break;
46714	46788	}
46715	46789

		@@ -46716,9 +46790,9 @@
46716	46790	newstack[160LLU] = 9876543210LLU; // overflow-marker
46717	46791	// call procblock from procblock
46718	46792	newstack[0] = (uint64_t)stack; // backup stack location
46719		- newstack[1] = 3934LLU;
	46793	+ newstack[1] = 3943LLU;
46720	46794	newstack[2] = base;
46721		- newstack[3] = 3935LLU;
	46795	+ newstack[3] = 3944LLU;
46722	46796	// arguments for call to procblock
46723	46797	newstack[4LLU] = stack[base + 0]/fndefs/;
46724	46798	newstack[5LLU] = stack[base + 1]/datadefs/;

		@@ -46741,10 +46815,10 @@
46741	46815	stack = newstack;
46742	46816	// set stack-base & callee-address
46743	46817	base = 4/deloffset/;
46744		- label = 3429LLU; // procblock
	46818	+ label = 3438LLU; // procblock
46745	46819	break;
46746	46820	}
46747		- case 3934LLU: // copy-back deleter (procblock to procblock)
	46821	+ case 3943LLU: // copy-back deleter (procblock to procblock)
46748	46822	{
46749	46823	uint64_t oldstack = (uint64_t )stack[0];
46750	46824	// copy mutable arguments back from call to procblock

		@@ -46761,10 +46835,10 @@
46761	46835	}
46762	46836	Free(160LLU + 1, sizeof(uint64_t), stack);
46763	46837	stack = oldstack;
46764		- label = 3929LLU; // continue to unroll stack
	46838	+ label = 3938LLU; // continue to unroll stack
46765	46839	break;
46766	46840	}
46767		- case 3935LLU: // return from procblock to procblock
	46841	+ case 3944LLU: // return from procblock to procblock
46768	46842	{
46769	46843	uint64_t oldstack = (uint64_t )stack[0];
46770	46844	// copy mutable arguments back from call to procblock

		@@ -46782,14 +46856,14 @@
46782	46856	Free(160LLU + 1, sizeof(uint64_t), stack);
46783	46857	stack = oldstack;
46784	46858	// delete list
46785		- label = 3936LLU; // start to repeat
	46859	+ label = 3945LLU; // start to repeat
46786	46860	break;
46787	46861	}
46788		- case 3936LLU: // repeat from here
	46862	+ case 3945LLU: // repeat from here
46789	46863	{
46790	46864	if(!stack[base + 28])
46791	46865	{
46792		- label = 3937LLU; // break loop
	46866	+ label = 3946LLU; // break loop
46793	46867	break;
46794	46868	}
46795	46869

		@@ -46800,7 +46874,7 @@
46800	46874	newstack[0] = (uint64_t)stack; // backup stack location
46801	46875	newstack[1] = 1234567890;
46802	46876	newstack[2] = base;
46803		- newstack[3] = 3938LLU;
	46877	+ newstack[3] = 3947LLU;
46804	46878	stack = newstack;
46805	46879	// set stack-base & callee-address
46806	46880	base = 4/deloffset/;

		@@ -46807,7 +46881,7 @@
46807	46881	label = 399LLU; // ~typeidx
46808	46882	break;
46809	46883	}
46810		- case 3938LLU: // return from ~typeidx to procblock
	46884	+ case 3947LLU: // return from ~typeidx to procblock
46811	46885	{
46812	46886	stack = (uint64_t *)stack[0];
46813	46887	// releasing toplevel container

		@@ -46818,14 +46892,14 @@
46818	46892	stack[base + 28] = (uint64_t)list->next;
46819	46893	Free(1, sizeof(struct listnode), list);
46820	46894	}
46821		- label = 3936LLU; // repeat
	46895	+ label = 3945LLU; // repeat
46822	46896	break;
46823	46897	}
46824		- case 3937LLU: // loop finished
	46898	+ case 3946LLU: // loop finished
46825	46899	{
46826	46900	if(!stack[base + 26]/inputflag/)
46827	46901	{
46828		- label = 3939LLU; // jump to alternative
	46902	+ label = 3948LLU; // jump to alternative
46829	46903	break;
46830	46904	}
46831	46905

		@@ -46832,9 +46906,9 @@
46832	46906	// consequent
46833	46907	printf("%s", "\n if(");
46834	46908	// call emitvar from procblock
46835		- stack[base + 28LLU] = 3941LLU/throw to this address/;
	46909	+ stack[base + 28LLU] = 3950LLU/throw to this address/;
46836	46910	stack[base + 29LLU] = base;
46837		- stack[base + 30LLU] = 3942LLU;
	46911	+ stack[base + 30LLU] = 3951LLU;
46838	46912	// arguments for call to emitvar
46839	46913	stack[base + 31LLU] = stack[base + 8]/fnid/;
46840	46914	stack[base + 32LLU] = stack[base + 27]/loopid/;

		@@ -46845,20 +46919,20 @@
46845	46919	label = 749LLU; // emitvar
46846	46920	break;
46847	46921	}
46848		- case 3941LLU: // copy-back deleter (emitvar to procblock)
	46922	+ case 3950LLU: // copy-back deleter (emitvar to procblock)
46849	46923	{
46850	46924	// copy mutable arguments back from call to emitvar
46851		- label = 3847LLU; // continue to roll stack
	46925	+ label = 3856LLU; // continue to roll stack
46852	46926	break;
46853	46927	}
46854		- case 3942LLU: // return from emitvar to procblock
	46928	+ case 3951LLU: // return from emitvar to procblock
46855	46929	{
46856	46930	// copy mutable arguments back from call to emitvar
46857	46931	printf("%s", " <= 0xFF) ");
46858	46932	// call emitvar from procblock
46859		- stack[base + 28LLU] = 3943LLU/throw to this address/;
	46933	+ stack[base + 28LLU] = 3952LLU/throw to this address/;
46860	46934	stack[base + 29LLU] = base;
46861		- stack[base + 30LLU] = 3944LLU;
	46935	+ stack[base + 30LLU] = 3953LLU;
46862	46936	// arguments for call to emitvar
46863	46937	stack[base + 31LLU] = stack[base + 8]/fnid/;
46864	46938	stack[base + 32LLU] = stack[base + 27]/loopid/;

		@@ -46869,31 +46943,31 @@
46869	46943	label = 749LLU; // emitvar
46870	46944	break;
46871	46945	}
46872		- case 3943LLU: // copy-back deleter (emitvar to procblock)
	46946	+ case 3952LLU: // copy-back deleter (emitvar to procblock)
46873	46947	{
46874	46948	// copy mutable arguments back from call to emitvar
46875		- label = 3847LLU; // continue to roll stack
	46949	+ label = 3856LLU; // continue to roll stack
46876	46950	break;
46877	46951	}
46878		- case 3944LLU: // return from emitvar to procblock
	46952	+ case 3953LLU: // return from emitvar to procblock
46879	46953	{
46880	46954	// copy mutable arguments back from call to emitvar
46881	46955	printf("%s", " = getchar();");
46882		- label = 3940LLU; // consequent complete
	46956	+ label = 3949LLU; // consequent complete
46883	46957	break;
46884	46958	}
46885		- case 3939LLU: // alternative
	46959	+ case 3948LLU: // alternative
46886	46960	{
46887		- label = 3940LLU; // alternative complete
	46961	+ label = 3949LLU; // alternative complete
46888	46962	break;
46889	46963	}
46890		- case 3940LLU: // completed if-then-else
	46964	+ case 3949LLU: // completed if-then-else
46891	46965	{
46892	46966	printf("%s", "\n label = ");
46893	46967	// call printnr from procblock
46894		- stack[base + 28LLU] = 3945LLU/throw to this address/;
	46968	+ stack[base + 28LLU] = 3954LLU/throw to this address/;
46895	46969	stack[base + 29LLU] = base;
46896		- stack[base + 30LLU] = 3946LLU;
	46970	+ stack[base + 30LLU] = 3955LLU;
46897	46971	// arguments for call to printnr
46898	46972	stack[base + 31LLU] = stack[base + 23]/labelloop/;
46899	46973	// set stack-base & callee-address

		@@ -46901,13 +46975,13 @@
46901	46975	label = 18446744073709551590LLU; // printnr
46902	46976	break;
46903	46977	}
46904		- case 3945LLU: // copy-back deleter (printnr to procblock)
	46978	+ case 3954LLU: // copy-back deleter (printnr to procblock)
46905	46979	{
46906	46980	// copy mutable arguments back from call to printnr
46907		- label = 3847LLU; // continue to roll stack
	46981	+ label = 3856LLU; // continue to roll stack
46908	46982	break;
46909	46983	}
46910		- case 3946LLU: // return from printnr to procblock
	46984	+ case 3955LLU: // return from printnr to procblock
46911	46985	{
46912	46986	// copy mutable arguments back from call to printnr
46913	46987	printf("%s", "LLU; // repeat");

		@@ -46915,9 +46989,9 @@
46915	46989	printf("%s", "\n }");
46916	46990	printf("%s", "\n case ");
46917	46991	// call printnr from procblock
46918		- stack[base + 28LLU] = 3947LLU/throw to this address/;
	46992	+ stack[base + 28LLU] = 3956LLU/throw to this address/;
46919	46993	stack[base + 29LLU] = base;
46920		- stack[base + 30LLU] = 3948LLU;
	46994	+ stack[base + 30LLU] = 3957LLU;
46921	46995	// arguments for call to printnr
46922	46996	stack[base + 31LLU] = stack[base + 24]/labelskip/;
46923	46997	// set stack-base & callee-address

		@@ -46925,25 +46999,25 @@
46925	46999	label = 18446744073709551590LLU; // printnr
46926	47000	break;
46927	47001	}
46928		- case 3947LLU: // copy-back deleter (printnr to procblock)
	47002	+ case 3956LLU: // copy-back deleter (printnr to procblock)
46929	47003	{
46930	47004	// copy mutable arguments back from call to printnr
46931		- label = 3847LLU; // continue to roll stack
	47005	+ label = 3856LLU; // continue to roll stack
46932	47006	break;
46933	47007	}
46934		- case 3948LLU: // return from printnr to procblock
	47008	+ case 3957LLU: // return from printnr to procblock
46935	47009	{
46936	47010	// copy mutable arguments back from call to printnr
46937	47011	printf("%s", "LLU: // loop finished");
46938	47012	printf("%s", "\n {");
46939		- label = 3840LLU; // consequent complete
	47013	+ label = 3849LLU; // consequent complete
46940	47014	break;
46941	47015	}
46942		- case 3839LLU: // alternative
	47016	+ case 3848LLU: // alternative
46943	47017	{
46944	47018	if(!stack[base + 25]/decflag/)
46945	47019	{
46946		- label = 3949LLU; // jump to alternative
	47020	+ label = 3958LLU; // jump to alternative
46947	47021	break;
46948	47022	}
46949	47023

		@@ -46950,9 +47024,9 @@
46950	47024	// consequent
46951	47025	fprintf(stderr, "%s", "in function ");
46952	47026	// call reportid from procblock
46953		- stack[base + 27LLU] = 3951LLU/throw to this address/;
	47027	+ stack[base + 27LLU] = 3960LLU/throw to this address/;
46954	47028	stack[base + 28LLU] = base;
46955		- stack[base + 29LLU] = 3952LLU;
	47029	+ stack[base + 29LLU] = 3961LLU;
46956	47030	// arguments for call to reportid
46957	47031	stack[base + 30LLU] = stack[base + 8]/fnid/;
46958	47032	// set stack-base & callee-address

		@@ -46960,20 +47034,20 @@
46960	47034	label = 18446744073709551586LLU; // reportid
46961	47035	break;
46962	47036	}
46963		- case 3951LLU: // copy-back deleter (reportid to procblock)
	47037	+ case 3960LLU: // copy-back deleter (reportid to procblock)
46964	47038	{
46965	47039	// copy mutable arguments back from call to reportid
46966		- label = 3807LLU; // continue to roll stack
	47040	+ label = 3816LLU; // continue to roll stack
46967	47041	break;
46968	47042	}
46969		- case 3952LLU: // return from reportid to procblock
	47043	+ case 3961LLU: // return from reportid to procblock
46970	47044	{
46971	47045	// copy mutable arguments back from call to reportid
46972	47046	fprintf(stderr, "%s", ": while dec expected '(' but found ");
46973	47047	// call reporttok from procblock
46974		- stack[base + 27LLU] = 3953LLU/throw to this address/;
	47048	+ stack[base + 27LLU] = 3962LLU/throw to this address/;
46975	47049	stack[base + 28LLU] = base;
46976		- stack[base + 29LLU] = 3954LLU;
	47050	+ stack[base + 29LLU] = 3963LLU;
46977	47051	// arguments for call to reporttok
46978	47052	stack[base + 30LLU] = stack[base + 15]/variant/;
46979	47053	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -46982,34 +47056,34 @@
46982	47056	label = 18446744073709551582LLU; // reporttok
46983	47057	break;
46984	47058	}
46985		- case 3953LLU: // copy-back deleter (reporttok to procblock)
	47059	+ case 3962LLU: // copy-back deleter (reporttok to procblock)
46986	47060	{
46987	47061	// copy mutable arguments back from call to reporttok
46988		- label = 3807LLU; // continue to roll stack
	47062	+ label = 3816LLU; // continue to roll stack
46989	47063	break;
46990	47064	}
46991		- case 3954LLU: // return from reporttok to procblock
	47065	+ case 3963LLU: // return from reporttok to procblock
46992	47066	{
46993	47067	// copy mutable arguments back from call to reporttok
46994	47068	fprintf(stderr, "%s", "\n");
46995	47069	{
46996		- label = 3807LLU; // throw: begin to unroll stack
	47070	+ label = 3816LLU; // throw: begin to unroll stack
46997	47071	break;
46998	47072	}
46999	47073
47000		- label = 3950LLU; // consequent complete
	47074	+ label = 3959LLU; // consequent complete
47001	47075	break;
47002	47076	}
47003		- case 3949LLU: // alternative
	47077	+ case 3958LLU: // alternative
47004	47078	{
47005		- label = 3950LLU; // alternative complete
	47079	+ label = 3959LLU; // alternative complete
47006	47080	break;
47007	47081	}
47008		- case 3950LLU: // completed if-then-else
	47082	+ case 3959LLU: // completed if-then-else
47009	47083	{
47010	47084	if(!stack[base + 26]/inputflag/)
47011	47085	{
47012		- label = 3955LLU; // jump to alternative
	47086	+ label = 3964LLU; // jump to alternative
47013	47087	break;
47014	47088	}
47015	47089

		@@ -47016,9 +47090,9 @@
47016	47090	// consequent
47017	47091	fprintf(stderr, "%s", "in function ");
47018	47092	// call reportid from procblock
47019		- stack[base + 27LLU] = 3957LLU/throw to this address/;
	47093	+ stack[base + 27LLU] = 3966LLU/throw to this address/;
47020	47094	stack[base + 28LLU] = base;
47021		- stack[base + 29LLU] = 3958LLU;
	47095	+ stack[base + 29LLU] = 3967LLU;
47022	47096	// arguments for call to reportid
47023	47097	stack[base + 30LLU] = stack[base + 8]/fnid/;
47024	47098	// set stack-base & callee-address

		@@ -47026,20 +47100,20 @@
47026	47100	label = 18446744073709551586LLU; // reportid
47027	47101	break;
47028	47102	}
47029		- case 3957LLU: // copy-back deleter (reportid to procblock)
	47103	+ case 3966LLU: // copy-back deleter (reportid to procblock)
47030	47104	{
47031	47105	// copy mutable arguments back from call to reportid
47032		- label = 3807LLU; // continue to roll stack
	47106	+ label = 3816LLU; // continue to roll stack
47033	47107	break;
47034	47108	}
47035		- case 3958LLU: // return from reportid to procblock
	47109	+ case 3967LLU: // return from reportid to procblock
47036	47110	{
47037	47111	// copy mutable arguments back from call to reportid
47038	47112	fprintf(stderr, "%s", ": while input expected '(' but found ");
47039	47113	// call reporttok from procblock
47040		- stack[base + 27LLU] = 3959LLU/throw to this address/;
	47114	+ stack[base + 27LLU] = 3968LLU/throw to this address/;
47041	47115	stack[base + 28LLU] = base;
47042		- stack[base + 29LLU] = 3960LLU;
	47116	+ stack[base + 29LLU] = 3969LLU;
47043	47117	// arguments for call to reporttok
47044	47118	stack[base + 30LLU] = stack[base + 15]/variant/;
47045	47119	stack[base + 31LLU] = stack[base + 16]/content/;

		@@ -47048,51 +47122,51 @@
47048	47122	label = 18446744073709551582LLU; // reporttok
47049	47123	break;
47050	47124	}
47051		- case 3959LLU: // copy-back deleter (reporttok to procblock)
	47125	+ case 3968LLU: // copy-back deleter (reporttok to procblock)
47052	47126	{
47053	47127	// copy mutable arguments back from call to reporttok
47054		- label = 3807LLU; // continue to roll stack
	47128	+ label = 3816LLU; // continue to roll stack
47055	47129	break;
47056	47130	}
47057		- case 3960LLU: // return from reporttok to procblock
	47131	+ case 3969LLU: // return from reporttok to procblock
47058	47132	{
47059	47133	// copy mutable arguments back from call to reporttok
47060	47134	fprintf(stderr, "%s", "\n");
47061	47135	{
47062		- label = 3807LLU; // throw: begin to unroll stack
	47136	+ label = 3816LLU; // throw: begin to unroll stack
47063	47137	break;
47064	47138	}
47065	47139
47066		- label = 3956LLU; // consequent complete
	47140	+ label = 3965LLU; // consequent complete
47067	47141	break;
47068	47142	}
47069		- case 3955LLU: // alternative
	47143	+ case 3964LLU: // alternative
47070	47144	{
47071		- label = 3956LLU; // alternative complete
	47145	+ label = 3965LLU; // alternative complete
47072	47146	break;
47073	47147	}
47074		- case 3956LLU: // completed if-then-else
	47148	+ case 3965LLU: // completed if-then-else
47075	47149	{
47076		- label = 3962LLU; // skip deleter
	47150	+ label = 3971LLU; // skip deleter
47077	47151	break;
47078	47152	}
47079		- case 3961LLU: // deleter
	47153	+ case 3970LLU: // deleter
47080	47154	{
47081	47155	// throw from procblock
47082	47156	if(!stack[base + 27])
47083	47157	{
47084		- label = 3807LLU; // skip, variable already deleted/unscoped
	47158	+ label = 3816LLU; // skip, variable already deleted/unscoped
47085	47159	break;
47086	47160	}
47087		- label = 3807LLU; // continue unrolling stack, delete next variable
	47161	+ label = 3816LLU; // continue unrolling stack, delete next variable
47088	47162	break;
47089	47163	}
47090		- case 3962LLU: // skipped deleter
	47164	+ case 3971LLU: // skipped deleter
47091	47165	{
47092	47166	// call getdeladdr from procblock
47093		- stack[base + 28LLU] = 3963LLU/throw to this address/;
	47167	+ stack[base + 28LLU] = 3972LLU/throw to this address/;
47094	47168	stack[base + 29LLU] = base;
47095		- stack[base + 30LLU] = 3964LLU;
	47169	+ stack[base + 30LLU] = 3973LLU;
47096	47170	// arguments for call to getdeladdr
47097	47171	stack[base + 32LLU] = stack[base + 3]/scope/;
47098	47172	// set stack-base & callee-address

		@@ -47100,21 +47174,21 @@
47100	47174	label = 596LLU; // getdeladdr
47101	47175	break;
47102	47176	}
47103		- case 3963LLU: // copy-back deleter (getdeladdr to procblock)
	47177	+ case 3972LLU: // copy-back deleter (getdeladdr to procblock)
47104	47178	{
47105	47179	// copy mutable arguments back from call to getdeladdr
47106		- label = 3807LLU; // continue to roll stack
	47180	+ label = 3816LLU; // continue to roll stack
47107	47181	break;
47108	47182	}
47109		- case 3964LLU: // return from getdeladdr to procblock
	47183	+ case 3973LLU: // return from getdeladdr to procblock
47110	47184	{
47111	47185	// copy mutable arguments back from call to getdeladdr
47112	47186	// copy back results provided by call to getdeladdr
47113	47187	stack[base + 27] = stack[base + 31LLU];
47114	47188	// call add from procblock
47115		- stack[base + 28LLU] = 3965LLU/throw to this address/;
	47189	+ stack[base + 28LLU] = 3974LLU/throw to this address/;
47116	47190	stack[base + 29LLU] = base;
47117		- stack[base + 30LLU] = 3966LLU;
	47191	+ stack[base + 30LLU] = 3975LLU;
47118	47192	// arguments for call to add
47119	47193	stack[base + 32LLU] = 1LLU;
47120	47194	stack[base + 33LLU] = stack[base + 17]/label/;

		@@ -47123,37 +47197,37 @@
47123	47197	label = 18446744073709551605LLU; // add
47124	47198	break;
47125	47199	}
47126		- case 3965LLU: // copy-back deleter (add to procblock)
	47200	+ case 3974LLU: // copy-back deleter (add to procblock)
47127	47201	{
47128	47202	// copy mutable arguments back from call to add
47129		- label = 3961LLU; // continue to roll stack
	47203	+ label = 3970LLU; // continue to roll stack
47130	47204	break;
47131	47205	}
47132		- case 3966LLU: // return from add to procblock
	47206	+ case 3975LLU: // return from add to procblock
47133	47207	{
47134	47208	// copy mutable arguments back from call to add
47135	47209	// copy back results provided by call to add
47136	47210	stack[base + 17] = stack[base + 31LLU];
47137		- label = 3968LLU; // skip deleter
	47211	+ label = 3977LLU; // skip deleter
47138	47212	break;
47139	47213	}
47140		- case 3967LLU: // deleter
	47214	+ case 3976LLU: // deleter
47141	47215	{
47142	47216	// throw from procblock
47143	47217	if(!stack[base + 28])
47144	47218	{
47145		- label = 3961LLU; // skip, variable already deleted/unscoped
	47219	+ label = 3970LLU; // skip, variable already deleted/unscoped
47146	47220	break;
47147	47221	}
47148		- label = 3961LLU; // continue unrolling stack, delete next variable
	47222	+ label = 3970LLU; // continue unrolling stack, delete next variable
47149	47223	break;
47150	47224	}
47151		- case 3968LLU: // skipped deleter
	47225	+ case 3977LLU: // skipped deleter
47152	47226	{
47153	47227	stack[base + 28] = stack[base + 17]/label/;
47154	47228	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
47155	47229	{
47156		- label = 3970LLU; // jump to alternative
	47230	+ label = 3979LLU; // jump to alternative
47157	47231	break;
47158	47232	}
47159	47233

		@@ -47164,60 +47238,60 @@
47164	47238	stack[base + 29]/deleteaddr/ = stack[base + 28]/labelfail/;
47165	47239	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 30];
47166	47240	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 29];
47167		- label = 3969LLU; // case complete
	47241	+ label = 3978LLU; // case complete
47168	47242	break;
47169	47243	}
47170		- case 3971LLU: // copy-back deleter (switch)
	47244	+ case 3980LLU: // copy-back deleter (switch)
47171	47245	{
47172	47246	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 30];
47173	47247	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 29];
47174		- label = 3967LLU; // continue to unroll stack
	47248	+ label = 3976LLU; // continue to unroll stack
47175	47249	break;
47176	47250	}
47177		- case 3970LLU: // try next case
	47251	+ case 3979LLU: // try next case
47178	47252	{
47179	47253	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
47180	47254	exit(-1);
47181	47255	}
47182		- case 3969LLU: // completed switch
	47256	+ case 3978LLU: // completed switch
47183	47257	{
47184		- label = 3973LLU; // skip deleter
	47258	+ label = 3982LLU; // skip deleter
47185	47259	break;
47186	47260	}
47187		- case 3972LLU: // deleter
	47261	+ case 3981LLU: // deleter
47188	47262	{
47189	47263	// throw from procblock
47190	47264	if(!stack[base + 29])
47191	47265	{
47192		- label = 3967LLU; // skip, variable already deleted/unscoped
	47266	+ label = 3976LLU; // skip, variable already deleted/unscoped
47193	47267	break;
47194	47268	}
47195		- label = 3967LLU; // continue unrolling stack, delete next variable
	47269	+ label = 3976LLU; // continue unrolling stack, delete next variable
47196	47270	break;
47197	47271	}
47198		- case 3973LLU: // skipped deleter
	47272	+ case 3982LLU: // skipped deleter
47199	47273	{
47200	47274	stack[base + 29] = 1;
47201		- label = 3975LLU; // skip deleter
	47275	+ label = 3984LLU; // skip deleter
47202	47276	break;
47203	47277	}
47204		- case 3974LLU: // deleter
	47278	+ case 3983LLU: // deleter
47205	47279	{
47206	47280	// throw from procblock
47207	47281	if(!stack[base + 30])
47208	47282	{
47209		- label = 3972LLU; // skip, variable already deleted/unscoped
	47283	+ label = 3981LLU; // skip, variable already deleted/unscoped
47210	47284	break;
47211	47285	}
47212	47286	// delete list
47213		- label = 3976LLU; // start to repeat
	47287	+ label = 3985LLU; // start to repeat
47214	47288	break;
47215	47289	}
47216		- case 3976LLU: // repeat from here
	47290	+ case 3985LLU: // repeat from here
47217	47291	{
47218	47292	if(!stack[base + 30])
47219	47293	{
47220		- label = 3977LLU; // break loop
	47294	+ label = 3986LLU; // break loop
47221	47295	break;
47222	47296	}
47223	47297

		@@ -47227,36 +47301,36 @@
47227	47301	stack[base + 30] = (uint64_t)list->next;
47228	47302	Free(1, sizeof(struct listnode), list);
47229	47303	}
47230		- label = 3976LLU; // repeat
	47304	+ label = 3985LLU; // repeat
47231	47305	break;
47232	47306	}
47233		- case 3977LLU: // loop finished
	47307	+ case 3986LLU: // loop finished
47234	47308	{
47235		- label = 3972LLU; // continue unrolling stack, delete next variable
	47309	+ label = 3981LLU; // continue unrolling stack, delete next variable
47236	47310	break;
47237	47311	}
47238		- case 3975LLU: // skipped deleter
	47312	+ case 3984LLU: // skipped deleter
47239	47313	{
47240		- label = 3979LLU; // skip deleter
	47314	+ label = 3988LLU; // skip deleter
47241	47315	break;
47242	47316	}
47243		- case 3978LLU: // deleter
	47317	+ case 3987LLU: // deleter
47244	47318	{
47245	47319	// throw from procblock
47246	47320	if(!stack[base + 31])
47247	47321	{
47248		- label = 3974LLU; // skip, variable already deleted/unscoped
	47322	+ label = 3983LLU; // skip, variable already deleted/unscoped
47249	47323	break;
47250	47324	}
47251	47325	// delete list
47252		- label = 3980LLU; // start to repeat
	47326	+ label = 3989LLU; // start to repeat
47253	47327	break;
47254	47328	}
47255		- case 3980LLU: // repeat from here
	47329	+ case 3989LLU: // repeat from here
47256	47330	{
47257	47331	if(!stack[base + 31])
47258	47332	{
47259		- label = 3981LLU; // break loop
	47333	+ label = 3990LLU; // break loop
47260	47334	break;
47261	47335	}
47262	47336

		@@ -47266,36 +47340,36 @@
47266	47340	stack[base + 31] = (uint64_t)list->next;
47267	47341	Free(1, sizeof(struct listnode), list);
47268	47342	}
47269		- label = 3980LLU; // repeat
	47343	+ label = 3989LLU; // repeat
47270	47344	break;
47271	47345	}
47272		- case 3981LLU: // loop finished
	47346	+ case 3990LLU: // loop finished
47273	47347	{
47274		- label = 3974LLU; // continue unrolling stack, delete next variable
	47348	+ label = 3983LLU; // continue unrolling stack, delete next variable
47275	47349	break;
47276	47350	}
47277		- case 3979LLU: // skipped deleter
	47351	+ case 3988LLU: // skipped deleter
47278	47352	{
47279		- label = 3983LLU; // skip deleter
	47353	+ label = 3992LLU; // skip deleter
47280	47354	break;
47281	47355	}
47282		- case 3982LLU: // deleter
	47356	+ case 3991LLU: // deleter
47283	47357	{
47284	47358	// throw from procblock
47285	47359	if(!stack[base + 30])
47286	47360	{
47287		- label = 3972LLU; // skip, variable already deleted/unscoped
	47361	+ label = 3981LLU; // skip, variable already deleted/unscoped
47288	47362	break;
47289	47363	}
47290	47364	// delete list
47291		- label = 3984LLU; // start to repeat
	47365	+ label = 3993LLU; // start to repeat
47292	47366	break;
47293	47367	}
47294		- case 3984LLU: // repeat from here
	47368	+ case 3993LLU: // repeat from here
47295	47369	{
47296	47370	if(!stack[base + 30])
47297	47371	{
47298		- label = 3985LLU; // break loop
	47372	+ label = 3994LLU; // break loop
47299	47373	break;
47300	47374	}
47301	47375

		@@ -47305,37 +47379,37 @@
47305	47379	stack[base + 30] = (uint64_t)list->next;
47306	47380	Free(1, sizeof(struct listnode), list);
47307	47381	}
47308		- label = 3984LLU; // repeat
	47382	+ label = 3993LLU; // repeat
47309	47383	break;
47310	47384	}
47311		- case 3985LLU: // loop finished
	47385	+ case 3994LLU: // loop finished
47312	47386	{
47313		- label = 3972LLU; // continue unrolling stack, delete next variable
	47387	+ label = 3981LLU; // continue unrolling stack, delete next variable
47314	47388	break;
47315	47389	}
47316		- case 3983LLU: // skipped deleter
	47390	+ case 3992LLU: // skipped deleter
47317	47391	{
47318	47392	stack[base + 30] = 0;
47319		- label = 3987LLU; // skip deleter
	47393	+ label = 3996LLU; // skip deleter
47320	47394	break;
47321	47395	}
47322		- case 3986LLU: // deleter
	47396	+ case 3995LLU: // deleter
47323	47397	{
47324	47398	// throw from procblock
47325	47399	if(!stack[base + 31])
47326	47400	{
47327		- label = 3982LLU; // skip, variable already deleted/unscoped
	47401	+ label = 3991LLU; // skip, variable already deleted/unscoped
47328	47402	break;
47329	47403	}
47330	47404	// delete list
47331		- label = 3988LLU; // start to repeat
	47405	+ label = 3997LLU; // start to repeat
47332	47406	break;
47333	47407	}
47334		- case 3988LLU: // repeat from here
	47408	+ case 3997LLU: // repeat from here
47335	47409	{
47336	47410	if(!stack[base + 31])
47337	47411	{
47338		- label = 3989LLU; // break loop
	47412	+ label = 3998LLU; // break loop
47339	47413	break;
47340	47414	}
47341	47415

		@@ -47345,37 +47419,37 @@
47345	47419	stack[base + 31] = (uint64_t)list->next;
47346	47420	Free(1, sizeof(struct listnode), list);
47347	47421	}
47348		- label = 3988LLU; // repeat
	47422	+ label = 3997LLU; // repeat
47349	47423	break;
47350	47424	}
47351		- case 3989LLU: // loop finished
	47425	+ case 3998LLU: // loop finished
47352	47426	{
47353		- label = 3982LLU; // continue unrolling stack, delete next variable
	47427	+ label = 3991LLU; // continue unrolling stack, delete next variable
47354	47428	break;
47355	47429	}
47356		- case 3987LLU: // skipped deleter
	47430	+ case 3996LLU: // skipped deleter
47357	47431	{
47358	47432	stack[base + 31] = 0;
47359		- label = 3991LLU; // skip deleter
	47433	+ label = 4000LLU; // skip deleter
47360	47434	break;
47361	47435	}
47362		- case 3990LLU: // deleter
	47436	+ case 3999LLU: // deleter
47363	47437	{
47364	47438	// throw from procblock
47365	47439	if(!stack[base + 32])
47366	47440	{
47367		- label = 3978LLU; // skip, variable already deleted/unscoped
	47441	+ label = 3987LLU; // skip, variable already deleted/unscoped
47368	47442	break;
47369	47443	}
47370	47444	// delete list
47371		- label = 3992LLU; // start to repeat
	47445	+ label = 4001LLU; // start to repeat
47372	47446	break;
47373	47447	}
47374		- case 3992LLU: // repeat from here
	47448	+ case 4001LLU: // repeat from here
47375	47449	{
47376	47450	if(!stack[base + 32])
47377	47451	{
47378		- label = 3993LLU; // break loop
	47452	+ label = 4002LLU; // break loop
47379	47453	break;
47380	47454	}
47381	47455

		@@ -47386,14 +47460,14 @@
47386	47460	newstack[0] = (uint64_t)stack; // backup stack location
47387	47461	newstack[1] = 1234567890;
47388	47462	newstack[2] = base;
47389		- newstack[3] = 3994LLU;
	47463	+ newstack[3] = 4003LLU;
47390	47464	stack = newstack;
47391	47465	// set stack-base & callee-address
47392	47466	base = 4/deloffset/;
47393		- label = 3310LLU; // ~listtoelem
	47467	+ label = 3319LLU; // ~listtoelem
47394	47468	break;
47395	47469	}
47396		- case 3994LLU: // return from ~listtoelem to procblock
	47470	+ case 4003LLU: // return from ~listtoelem to procblock
47397	47471	{
47398	47472	stack = (uint64_t *)stack[0];
47399	47473	// releasing toplevel container

		@@ -47404,25 +47478,25 @@
47404	47478	stack[base + 32] = (uint64_t)list->next;
47405	47479	Free(1, sizeof(struct listnode), list);
47406	47480	}
47407		- label = 3992LLU; // repeat
	47481	+ label = 4001LLU; // repeat
47408	47482	break;
47409	47483	}
47410		- case 3993LLU: // loop finished
	47484	+ case 4002LLU: // loop finished
47411	47485	{
47412		- label = 3978LLU; // continue unrolling stack, delete next variable
	47486	+ label = 3987LLU; // continue unrolling stack, delete next variable
47413	47487	break;
47414	47488	}
47415		- case 3991LLU: // skipped deleter
	47489	+ case 4000LLU: // skipped deleter
47416	47490	{
47417	47491	stack[base + 32] = 0;
47418		- label = 3995LLU; // start to repeat
	47492	+ label = 4004LLU; // start to repeat
47419	47493	break;
47420	47494	}
47421		- case 3995LLU: // repeat from here
	47495	+ case 4004LLU: // repeat from here
47422	47496	{
47423	47497	if(stack[base + 19]/lookahead/ > 0xFF)
47424	47498	{
47425		- label = 3996LLU; // break loop
	47499	+ label = 4005LLU; // break loop
47426	47500	break;
47427	47501	}
47428	47502

		@@ -47429,21 +47503,21 @@
47429	47503	// loop body
47430	47504	if(!stack[base + 29]/first/)
47431	47505	{
47432		- label = 3997LLU; // jump to alternative
	47506	+ label = 4006LLU; // jump to alternative
47433	47507	break;
47434	47508	}
47435	47509
47436	47510	// consequent
47437	47511	stack[base + 29]/first/ = 0;
47438		- label = 3998LLU; // consequent complete
	47512	+ label = 4007LLU; // consequent complete
47439	47513	break;
47440	47514	}
47441		- case 3997LLU: // alternative
	47515	+ case 4006LLU: // alternative
47442	47516	{
47443	47517	// call ParseToken from procblock
47444		- stack[base + 33LLU] = 3999LLU/throw to this address/;
	47518	+ stack[base + 33LLU] = 4008LLU/throw to this address/;
47445	47519	stack[base + 34LLU] = base;
47446		- stack[base + 35LLU] = 4000LLU;
	47520	+ stack[base + 35LLU] = 4009LLU;
47447	47521	// arguments for call to ParseToken
47448	47522	stack[base + 38LLU] = stack[base + 19]/lookahead/;
47449	47523	// set stack-base & callee-address

		@@ -47451,14 +47525,14 @@
47451	47525	label = 3LLU; // ParseToken
47452	47526	break;
47453	47527	}
47454		- case 3999LLU: // copy-back deleter (ParseToken to procblock)
	47528	+ case 4008LLU: // copy-back deleter (ParseToken to procblock)
47455	47529	{
47456	47530	// copy mutable arguments back from call to ParseToken
47457	47531	stack[base + 19]/lookahead/ = stack[base + 38LLU];
47458		- label = 3990LLU; // continue to roll stack
	47532	+ label = 3999LLU; // continue to roll stack
47459	47533	break;
47460	47534	}
47461		- case 4000LLU: // return from ParseToken to procblock
	47535	+ case 4009LLU: // return from ParseToken to procblock
47462	47536	{
47463	47537	// copy mutable arguments back from call to ParseToken
47464	47538	stack[base + 19]/lookahead/ = stack[base + 38LLU];

		@@ -47465,20 +47539,20 @@
47465	47539	// copy back results provided by call to ParseToken
47466	47540	stack[base + 15] = stack[base + 36LLU];
47467	47541	stack[base + 16] = stack[base + 37LLU];
47468		- label = 3998LLU; // alternative complete
	47542	+ label = 4007LLU; // alternative complete
47469	47543	break;
47470	47544	}
47471		- case 3998LLU: // completed if-then-else
	47545	+ case 4007LLU: // completed if-then-else
47472	47546	{
47473		- label = 4002LLU; // skip deleter
	47547	+ label = 4011LLU; // skip deleter
47474	47548	break;
47475	47549	}
47476		- case 4001LLU: // deleter
	47550	+ case 4010LLU: // deleter
47477	47551	{
47478	47552	// throw from procblock
47479	47553	if(!stack[base + 33])
47480	47554	{
47481		- label = 3990LLU; // skip, variable already deleted/unscoped
	47555	+ label = 3999LLU; // skip, variable already deleted/unscoped
47482	47556	break;
47483	47557	}
47484	47558

		@@ -47487,44 +47561,44 @@
47487	47561	newstack[0] = (uint64_t)stack; // backup stack location
47488	47562	newstack[1] = 1234567890;
47489	47563	newstack[2] = base;
47490		- newstack[3] = 4003LLU;
	47564	+ newstack[3] = 4012LLU;
47491	47565	stack = newstack;
47492	47566	// set stack-base & callee-address
47493	47567	base = 4/deloffset/;
47494		- label = 3310LLU; // ~listtoelem
	47568	+ label = 3319LLU; // ~listtoelem
47495	47569	break;
47496	47570	}
47497		- case 4003LLU: // return from ~listtoelem to procblock
	47571	+ case 4012LLU: // return from ~listtoelem to procblock
47498	47572	{
47499	47573	stack = (uint64_t *)stack[0];
47500	47574	// releasing toplevel container
47501	47575	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 33] - sizeof(uint64_t) 4));
47502	47576
47503		- label = 3990LLU; // continue unrolling stack, delete next variable
	47577	+ label = 3999LLU; // continue unrolling stack, delete next variable
47504	47578	break;
47505	47579	}
47506		- case 4002LLU: // skipped deleter
	47580	+ case 4011LLU: // skipped deleter
47507	47581	{
47508		- label = 4005LLU; // skip deleter
	47582	+ label = 4014LLU; // skip deleter
47509	47583	break;
47510	47584	}
47511		- case 4004LLU: // deleter
	47585	+ case 4013LLU: // deleter
47512	47586	{
47513	47587	// throw from procblock
47514	47588	if(!stack[base + 34])
47515	47589	{
47516		- label = 3990LLU; // skip, variable already deleted/unscoped
	47590	+ label = 3999LLU; // skip, variable already deleted/unscoped
47517	47591	break;
47518	47592	}
47519		- label = 3990LLU; // continue unrolling stack, delete next variable
	47593	+ label = 3999LLU; // continue unrolling stack, delete next variable
47520	47594	break;
47521	47595	}
47522		- case 4005LLU: // skipped deleter
	47596	+ case 4014LLU: // skipped deleter
47523	47597	{
47524	47598	// call equ from procblock
47525		- stack[base + 35LLU] = 4006LLU/throw to this address/;
	47599	+ stack[base + 35LLU] = 4015LLU/throw to this address/;
47526	47600	stack[base + 36LLU] = base;
47527		- stack[base + 37LLU] = 4007LLU;
	47601	+ stack[base + 37LLU] = 4016LLU;
47528	47602	// arguments for call to equ
47529	47603	stack[base + 39LLU] = stack[base + 16]/content/;
47530	47604	stack[base + 40LLU] = 747825068330975232LLU;

		@@ -47533,13 +47607,13 @@
47533	47607	label = 18446744073709551600LLU; // equ
47534	47608	break;
47535	47609	}
47536		- case 4006LLU: // copy-back deleter (equ to procblock)
	47610	+ case 4015LLU: // copy-back deleter (equ to procblock)
47537	47611	{
47538	47612	// copy mutable arguments back from call to equ
47539		- label = 3990LLU; // continue to roll stack
	47613	+ label = 3999LLU; // continue to roll stack
47540	47614	break;
47541	47615	}
47542		- case 4007LLU: // return from equ to procblock
	47616	+ case 4016LLU: // return from equ to procblock
47543	47617	{
47544	47618	// copy mutable arguments back from call to equ
47545	47619	// copy back results provided by call to equ

		@@ -47546,37 +47620,37 @@
47546	47620	stack[base + 20] = stack[base + 38LLU];
47547	47621	if(!stack[base + 20]/isequal/)
47548	47622	{
47549		- label = 4008LLU; // jump to alternative
	47623	+ label = 4017LLU; // jump to alternative
47550	47624	break;
47551	47625	}
47552	47626
47553	47627	// consequent
47554		- label = 4011LLU; // skip deleter
	47628	+ label = 4020LLU; // skip deleter
47555	47629	break;
47556	47630	}
47557		- case 4010LLU: // deleter
	47631	+ case 4019LLU: // deleter
47558	47632	{
47559	47633	// throw from procblock
47560	47634	if(!stack[base + 34])
47561	47635	{
47562		- label = 3990LLU; // skip, variable already deleted/unscoped
	47636	+ label = 3999LLU; // skip, variable already deleted/unscoped
47563	47637	break;
47564	47638	}
47565		- label = 3990LLU; // continue unrolling stack, delete next variable
	47639	+ label = 3999LLU; // continue unrolling stack, delete next variable
47566	47640	break;
47567	47641	}
47568		- case 4011LLU: // skipped deleter
	47642	+ case 4020LLU: // skipped deleter
47569	47643	{
47570	47644	stack[base + 34] = 0;
47571		- label = 4009LLU; // consequent complete
	47645	+ label = 4018LLU; // consequent complete
47572	47646	break;
47573	47647	}
47574		- case 4008LLU: // alternative
	47648	+ case 4017LLU: // alternative
47575	47649	{
47576	47650	// call equ from procblock
47577		- stack[base + 35LLU] = 4012LLU/throw to this address/;
	47651	+ stack[base + 35LLU] = 4021LLU/throw to this address/;
47578	47652	stack[base + 36LLU] = base;
47579		- stack[base + 37LLU] = 4013LLU;
	47653	+ stack[base + 37LLU] = 4022LLU;
47580	47654	// arguments for call to equ
47581	47655	stack[base + 39LLU] = stack[base + 16]/content/;
47582	47656	stack[base + 40LLU] = 786630200929550336LLU;

		@@ -47585,13 +47659,13 @@
47585	47659	label = 18446744073709551600LLU; // equ
47586	47660	break;
47587	47661	}
47588		- case 4012LLU: // copy-back deleter (equ to procblock)
	47662	+ case 4021LLU: // copy-back deleter (equ to procblock)
47589	47663	{
47590	47664	// copy mutable arguments back from call to equ
47591		- label = 3990LLU; // continue to roll stack
	47665	+ label = 3999LLU; // continue to roll stack
47592	47666	break;
47593	47667	}
47594		- case 4013LLU: // return from equ to procblock
	47668	+ case 4022LLU: // return from equ to procblock
47595	47669	{
47596	47670	// copy mutable arguments back from call to equ
47597	47671	// copy back results provided by call to equ

		@@ -47598,38 +47672,38 @@
47598	47672	stack[base + 20] = stack[base + 38LLU];
47599	47673	if(!stack[base + 20]/isequal/)
47600	47674	{
47601		- label = 4014LLU; // jump to alternative
	47675	+ label = 4023LLU; // jump to alternative
47602	47676	break;
47603	47677	}
47604	47678
47605	47679	// consequent
47606		- label = 4017LLU; // skip deleter
	47680	+ label = 4026LLU; // skip deleter
47607	47681	break;
47608	47682	}
47609		- case 4016LLU: // deleter
	47683	+ case 4025LLU: // deleter
47610	47684	{
47611	47685	// throw from procblock
47612	47686	if(!stack[base + 34])
47613	47687	{
47614		- label = 3990LLU; // skip, variable already deleted/unscoped
	47688	+ label = 3999LLU; // skip, variable already deleted/unscoped
47615	47689	break;
47616	47690	}
47617		- label = 3990LLU; // continue unrolling stack, delete next variable
	47691	+ label = 3999LLU; // continue unrolling stack, delete next variable
47618	47692	break;
47619	47693	}
47620		- case 4017LLU: // skipped deleter
	47694	+ case 4026LLU: // skipped deleter
47621	47695	{
47622	47696	stack[base + 34] = 1;
47623		- label = 4015LLU; // consequent complete
	47697	+ label = 4024LLU; // consequent complete
47624	47698	break;
47625	47699	}
47626		- case 4014LLU: // alternative
	47700	+ case 4023LLU: // alternative
47627	47701	{
47628	47702	fprintf(stderr, "%s", "in function ");
47629	47703	// call reportid from procblock
47630		- stack[base + 35LLU] = 4018LLU/throw to this address/;
	47704	+ stack[base + 35LLU] = 4027LLU/throw to this address/;
47631	47705	stack[base + 36LLU] = base;
47632		- stack[base + 37LLU] = 4019LLU;
	47706	+ stack[base + 37LLU] = 4028LLU;
47633	47707	// arguments for call to reportid
47634	47708	stack[base + 38LLU] = stack[base + 8]/fnid/;
47635	47709	// set stack-base & callee-address

		@@ -47637,21 +47711,21 @@
47637	47711	label = 18446744073709551586LLU; // reportid
47638	47712	break;
47639	47713	}
47640		- case 4018LLU: // copy-back deleter (reportid to procblock)
	47714	+ case 4027LLU: // copy-back deleter (reportid to procblock)
47641	47715	{
47642	47716	// copy mutable arguments back from call to reportid
47643		- label = 3990LLU; // continue to roll stack
	47717	+ label = 3999LLU; // continue to roll stack
47644	47718	break;
47645	47719	}
47646		- case 4019LLU: // return from reportid to procblock
	47720	+ case 4028LLU: // return from reportid to procblock
47647	47721	{
47648	47722	// copy mutable arguments back from call to reportid
47649	47723	fprintf(stderr, "%s", ": ");
47650	47724	fprintf(stderr, "%s", "expected next but found token ");
47651	47725	// call reporttok from procblock
47652		- stack[base + 35LLU] = 4020LLU/throw to this address/;
	47726	+ stack[base + 35LLU] = 4029LLU/throw to this address/;
47653	47727	stack[base + 36LLU] = base;
47654		- stack[base + 37LLU] = 4021LLU;
	47728	+ stack[base + 37LLU] = 4030LLU;
47655	47729	// arguments for call to reporttok
47656	47730	stack[base + 38LLU] = stack[base + 15]/variant/;
47657	47731	stack[base + 39LLU] = stack[base + 16]/content/;

		@@ -47660,83 +47734,83 @@
47660	47734	label = 18446744073709551582LLU; // reporttok
47661	47735	break;
47662	47736	}
47663		- case 4020LLU: // copy-back deleter (reporttok to procblock)
	47737	+ case 4029LLU: // copy-back deleter (reporttok to procblock)
47664	47738	{
47665	47739	// copy mutable arguments back from call to reporttok
47666		- label = 3990LLU; // continue to roll stack
	47740	+ label = 3999LLU; // continue to roll stack
47667	47741	break;
47668	47742	}
47669		- case 4021LLU: // return from reporttok to procblock
	47743	+ case 4030LLU: // return from reporttok to procblock
47670	47744	{
47671	47745	// copy mutable arguments back from call to reporttok
47672	47746	fprintf(stderr, "%s", "\n");
47673	47747	{
47674		- label = 3990LLU; // throw: begin to unroll stack
	47748	+ label = 3999LLU; // throw: begin to unroll stack
47675	47749	break;
47676	47750	}
47677	47751
47678		- label = 4015LLU; // alternative complete
	47752	+ label = 4024LLU; // alternative complete
47679	47753	break;
47680	47754	}
47681		- case 4015LLU: // completed if-then-else
	47755	+ case 4024LLU: // completed if-then-else
47682	47756	{
47683		- label = 4009LLU; // alternative complete
	47757	+ label = 4018LLU; // alternative complete
47684	47758	break;
47685	47759	}
47686		- case 4009LLU: // completed if-then-else
	47760	+ case 4018LLU: // completed if-then-else
47687	47761	{
47688		- label = 4023LLU; // skip deleter
	47762	+ label = 4032LLU; // skip deleter
47689	47763	break;
47690	47764	}
47691		- case 4022LLU: // deleter
	47765	+ case 4031LLU: // deleter
47692	47766	{
47693	47767	// throw from procblock
47694	47768	if(!stack[base + 35])
47695	47769	{
47696		- label = 4004LLU; // skip, variable already deleted/unscoped
	47770	+ label = 4013LLU; // skip, variable already deleted/unscoped
47697	47771	break;
47698	47772	}
47699		- label = 4004LLU; // continue unrolling stack, delete next variable
	47773	+ label = 4013LLU; // continue unrolling stack, delete next variable
47700	47774	break;
47701	47775	}
47702		- case 4023LLU: // skipped deleter
	47776	+ case 4032LLU: // skipped deleter
47703	47777	{
47704		- label = 4025LLU; // skip deleter
	47778	+ label = 4034LLU; // skip deleter
47705	47779	break;
47706	47780	}
47707		- case 4024LLU: // deleter
	47781	+ case 4033LLU: // deleter
47708	47782	{
47709	47783	// throw from procblock
47710	47784	if(!stack[base + 36])
47711	47785	{
47712		- label = 4022LLU; // skip, variable already deleted/unscoped
	47786	+ label = 4031LLU; // skip, variable already deleted/unscoped
47713	47787	break;
47714	47788	}
47715		- label = 4022LLU; // continue unrolling stack, delete next variable
	47789	+ label = 4031LLU; // continue unrolling stack, delete next variable
47716	47790	break;
47717	47791	}
47718		- case 4025LLU: // skipped deleter
	47792	+ case 4034LLU: // skipped deleter
47719	47793	{
47720	47794	// call listtoelem from procblock
47721		- stack[base + 37LLU] = 4026LLU/throw to this address/;
	47795	+ stack[base + 37LLU] = 4035LLU/throw to this address/;
47722	47796	stack[base + 38LLU] = base;
47723		- stack[base + 39LLU] = 4027LLU;
	47797	+ stack[base + 39LLU] = 4036LLU;
47724	47798	// arguments for call to listtoelem
47725	47799	stack[base + 42LLU] = stack[base + 8]/fnid/;
47726	47800	stack[base + 43LLU] = stack[base + 19]/lookahead/;
47727	47801	// set stack-base & callee-address
47728	47802	base += 40LLU;
47729		- label = 3263LLU; // listtoelem
	47803	+ label = 3272LLU; // listtoelem
47730	47804	break;
47731	47805	}
47732		- case 4026LLU: // copy-back deleter (listtoelem to procblock)
	47806	+ case 4035LLU: // copy-back deleter (listtoelem to procblock)
47733	47807	{
47734	47808	// copy mutable arguments back from call to listtoelem
47735	47809	stack[base + 19]/lookahead/ = stack[base + 43LLU];
47736		- label = 4004LLU; // continue to roll stack
	47810	+ label = 4013LLU; // continue to roll stack
47737	47811	break;
47738	47812	}
47739		- case 4027LLU: // return from listtoelem to procblock
	47813	+ case 4036LLU: // return from listtoelem to procblock
47740	47814	{
47741	47815	// copy mutable arguments back from call to listtoelem
47742	47816	stack[base + 19]/lookahead/ = stack[base + 43LLU];

		@@ -47744,9 +47818,9 @@
47744	47818	stack[base + 35] = stack[base + 40LLU];
47745	47819	stack[base + 36] = stack[base + 41LLU];
47746	47820	// call existsid from procblock
47747		- stack[base + 37LLU] = 4028LLU/throw to this address/;
	47821	+ stack[base + 37LLU] = 4037LLU/throw to this address/;
47748	47822	stack[base + 38LLU] = base;
47749		- stack[base + 39LLU] = 4029LLU;
	47823	+ stack[base + 39LLU] = 4038LLU;
47750	47824	// arguments for call to existsid
47751	47825	stack[base + 41LLU] = stack[base + 30]/listids/;
47752	47826	stack[base + 42LLU] = stack[base + 35]/listid/;

		@@ -47755,13 +47829,13 @@
47755	47829	label = 153LLU; // existsid
47756	47830	break;
47757	47831	}
47758		- case 4028LLU: // copy-back deleter (existsid to procblock)
	47832	+ case 4037LLU: // copy-back deleter (existsid to procblock)
47759	47833	{
47760	47834	// copy mutable arguments back from call to existsid
47761		- label = 4024LLU; // continue to roll stack
	47835	+ label = 4033LLU; // continue to roll stack
47762	47836	break;
47763	47837	}
47764		- case 4029LLU: // return from existsid to procblock
	47838	+ case 4038LLU: // return from existsid to procblock
47765	47839	{
47766	47840	// copy mutable arguments back from call to existsid
47767	47841	// copy back results provided by call to existsid

		@@ -47768,7 +47842,7 @@
47768	47842	stack[base + 20] = stack[base + 40LLU];
47769	47843	if(!stack[base + 20]/isequal/)
47770	47844	{
47771		- label = 4030LLU; // jump to alternative
	47845	+ label = 4039LLU; // jump to alternative
47772	47846	break;
47773	47847	}
47774	47848

		@@ -47775,9 +47849,9 @@
47775	47849	// consequent
47776	47850	fprintf(stderr, "%s", "in function ");
47777	47851	// call reportid from procblock
47778		- stack[base + 37LLU] = 4032LLU/throw to this address/;
	47852	+ stack[base + 37LLU] = 4041LLU/throw to this address/;
47779	47853	stack[base + 38LLU] = base;
47780		- stack[base + 39LLU] = 4033LLU;
	47854	+ stack[base + 39LLU] = 4042LLU;
47781	47855	// arguments for call to reportid
47782	47856	stack[base + 40LLU] = stack[base + 8]/fnid/;
47783	47857	// set stack-base & callee-address

		@@ -47785,20 +47859,20 @@
47785	47859	label = 18446744073709551586LLU; // reportid
47786	47860	break;
47787	47861	}
47788		- case 4032LLU: // copy-back deleter (reportid to procblock)
	47862	+ case 4041LLU: // copy-back deleter (reportid to procblock)
47789	47863	{
47790	47864	// copy mutable arguments back from call to reportid
47791		- label = 4024LLU; // continue to roll stack
	47865	+ label = 4033LLU; // continue to roll stack
47792	47866	break;
47793	47867	}
47794		- case 4033LLU: // return from reportid to procblock
	47868	+ case 4042LLU: // return from reportid to procblock
47795	47869	{
47796	47870	// copy mutable arguments back from call to reportid
47797	47871	fprintf(stderr, "%s", ": duplicate list ");
47798	47872	// call printid from procblock
47799		- stack[base + 37LLU] = 4034LLU/throw to this address/;
	47873	+ stack[base + 37LLU] = 4043LLU/throw to this address/;
47800	47874	stack[base + 38LLU] = base;
47801		- stack[base + 39LLU] = 4035LLU;
	47875	+ stack[base + 39LLU] = 4044LLU;
47802	47876	// arguments for call to printid
47803	47877	stack[base + 40LLU] = stack[base + 35]/listid/;
47804	47878	// set stack-base & callee-address

		@@ -47806,30 +47880,30 @@
47806	47880	label = 18446744073709551587LLU; // printid
47807	47881	break;
47808	47882	}
47809		- case 4034LLU: // copy-back deleter (printid to procblock)
	47883	+ case 4043LLU: // copy-back deleter (printid to procblock)
47810	47884	{
47811	47885	// copy mutable arguments back from call to printid
47812		- label = 4024LLU; // continue to roll stack
	47886	+ label = 4033LLU; // continue to roll stack
47813	47887	break;
47814	47888	}
47815		- case 4035LLU: // return from printid to procblock
	47889	+ case 4044LLU: // return from printid to procblock
47816	47890	{
47817	47891	// copy mutable arguments back from call to printid
47818	47892	printf("%s", " in while-loop\n");
47819	47893	{
47820		- label = 4024LLU; // throw: begin to unroll stack
	47894	+ label = 4033LLU; // throw: begin to unroll stack
47821	47895	break;
47822	47896	}
47823	47897
47824		- label = 4031LLU; // consequent complete
	47898	+ label = 4040LLU; // consequent complete
47825	47899	break;
47826	47900	}
47827		- case 4030LLU: // alternative
	47901	+ case 4039LLU: // alternative
47828	47902	{
47829		- label = 4031LLU; // alternative complete
	47903	+ label = 4040LLU; // alternative complete
47830	47904	break;
47831	47905	}
47832		- case 4031LLU: // completed if-then-else
	47906	+ case 4040LLU: // completed if-then-else
47833	47907	{
47834	47908	{
47835	47909	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));

		@@ -47845,9 +47919,9 @@
47845	47919	list->data = stack[base + 35]/listid/;
47846	47920	}
47847	47921	// call existsid from procblock
47848		- stack[base + 37LLU] = 4036LLU/throw to this address/;
	47922	+ stack[base + 37LLU] = 4045LLU/throw to this address/;
47849	47923	stack[base + 38LLU] = base;
47850		- stack[base + 39LLU] = 4037LLU;
	47924	+ stack[base + 39LLU] = 4046LLU;
47851	47925	// arguments for call to existsid
47852	47926	stack[base + 41LLU] = stack[base + 31]/elemids/;
47853	47927	stack[base + 42LLU] = stack[base + 36]/elemid/;

		@@ -47856,13 +47930,13 @@
47856	47930	label = 153LLU; // existsid
47857	47931	break;
47858	47932	}
47859		- case 4036LLU: // copy-back deleter (existsid to procblock)
	47933	+ case 4045LLU: // copy-back deleter (existsid to procblock)
47860	47934	{
47861	47935	// copy mutable arguments back from call to existsid
47862		- label = 4024LLU; // continue to roll stack
	47936	+ label = 4033LLU; // continue to roll stack
47863	47937	break;
47864	47938	}
47865		- case 4037LLU: // return from existsid to procblock
	47939	+ case 4046LLU: // return from existsid to procblock
47866	47940	{
47867	47941	// copy mutable arguments back from call to existsid
47868	47942	// copy back results provided by call to existsid

		@@ -47869,7 +47943,7 @@
47869	47943	stack[base + 20] = stack[base + 40LLU];
47870	47944	if(!stack[base + 20]/isequal/)
47871	47945	{
47872		- label = 4038LLU; // jump to alternative
	47946	+ label = 4047LLU; // jump to alternative
47873	47947	break;
47874	47948	}
47875	47949

		@@ -47876,9 +47950,9 @@
47876	47950	// consequent
47877	47951	fprintf(stderr, "%s", "in function ");
47878	47952	// call reportid from procblock
47879		- stack[base + 37LLU] = 4040LLU/throw to this address/;
	47953	+ stack[base + 37LLU] = 4049LLU/throw to this address/;
47880	47954	stack[base + 38LLU] = base;
47881		- stack[base + 39LLU] = 4041LLU;
	47955	+ stack[base + 39LLU] = 4050LLU;
47882	47956	// arguments for call to reportid
47883	47957	stack[base + 40LLU] = stack[base + 8]/fnid/;
47884	47958	// set stack-base & callee-address

		@@ -47886,20 +47960,20 @@
47886	47960	label = 18446744073709551586LLU; // reportid
47887	47961	break;
47888	47962	}
47889		- case 4040LLU: // copy-back deleter (reportid to procblock)
	47963	+ case 4049LLU: // copy-back deleter (reportid to procblock)
47890	47964	{
47891	47965	// copy mutable arguments back from call to reportid
47892		- label = 4024LLU; // continue to roll stack
	47966	+ label = 4033LLU; // continue to roll stack
47893	47967	break;
47894	47968	}
47895		- case 4041LLU: // return from reportid to procblock
	47969	+ case 4050LLU: // return from reportid to procblock
47896	47970	{
47897	47971	// copy mutable arguments back from call to reportid
47898	47972	fprintf(stderr, "%s", ": duplicate list-element ");
47899	47973	// call printid from procblock
47900		- stack[base + 37LLU] = 4042LLU/throw to this address/;
	47974	+ stack[base + 37LLU] = 4051LLU/throw to this address/;
47901	47975	stack[base + 38LLU] = base;
47902		- stack[base + 39LLU] = 4043LLU;
	47976	+ stack[base + 39LLU] = 4052LLU;
47903	47977	// arguments for call to printid
47904	47978	stack[base + 40LLU] = stack[base + 36]/elemid/;
47905	47979	// set stack-base & callee-address

		@@ -47907,30 +47981,30 @@
47907	47981	label = 18446744073709551587LLU; // printid
47908	47982	break;
47909	47983	}
47910		- case 4042LLU: // copy-back deleter (printid to procblock)
	47984	+ case 4051LLU: // copy-back deleter (printid to procblock)
47911	47985	{
47912	47986	// copy mutable arguments back from call to printid
47913		- label = 4024LLU; // continue to roll stack
	47987	+ label = 4033LLU; // continue to roll stack
47914	47988	break;
47915	47989	}
47916		- case 4043LLU: // return from printid to procblock
	47990	+ case 4052LLU: // return from printid to procblock
47917	47991	{
47918	47992	// copy mutable arguments back from call to printid
47919	47993	printf("%s", " in while-loop\n");
47920	47994	{
47921		- label = 4024LLU; // throw: begin to unroll stack
	47995	+ label = 4033LLU; // throw: begin to unroll stack
47922	47996	break;
47923	47997	}
47924	47998
47925		- label = 4039LLU; // consequent complete
	47999	+ label = 4048LLU; // consequent complete
47926	48000	break;
47927	48001	}
47928		- case 4038LLU: // alternative
	48002	+ case 4047LLU: // alternative
47929	48003	{
47930		- label = 4039LLU; // alternative complete
	48004	+ label = 4048LLU; // alternative complete
47931	48005	break;
47932	48006	}
47933		- case 4039LLU: // completed if-then-else
	48007	+ case 4048LLU: // completed if-then-else
47934	48008	{
47935	48009	{
47936	48010	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));

		@@ -47946,9 +48020,9 @@
47946	48020	list->data = stack[base + 36]/elemid/;
47947	48021	}
47948	48022	// call shadowlock from procblock
47949		- stack[base + 37LLU] = 4044LLU/throw to this address/;
	48023	+ stack[base + 37LLU] = 4053LLU/throw to this address/;
47950	48024	stack[base + 38LLU] = base;
47951		- stack[base + 39LLU] = 4045LLU;
	48025	+ stack[base + 39LLU] = 4054LLU;
47952	48026	// arguments for call to shadowlock
47953	48027	stack[base + 41LLU] = stack[base + 8]/fnid/;
47954	48028	stack[base + 42LLU] = stack[base + 2]/scopes/;

		@@ -47963,10 +48037,10 @@
47963	48037	stack[base + 51LLU] = stack[base + 34]/consume/;
47964	48038	// set stack-base & callee-address
47965	48039	base += 40LLU;
47966		- label = 3314LLU; // shadowlock
	48040	+ label = 3323LLU; // shadowlock
47967	48041	break;
47968	48042	}
47969		- case 4044LLU: // copy-back deleter (shadowlock to procblock)
	48043	+ case 4053LLU: // copy-back deleter (shadowlock to procblock)
47970	48044	{
47971	48045	// copy mutable arguments back from call to shadowlock
47972	48046	stack[base + 17]/label/ = stack[base + 48LLU];

		@@ -47973,10 +48047,10 @@
47973	48047	stack[base + 18]/varcount/ = stack[base + 47LLU];
47974	48048	stack[base + 12]/fnmaxcount/ = stack[base + 46LLU];
47975	48049	stack[base + 3]/scope/ = stack[base + 43LLU];
47976		- label = 4024LLU; // continue to roll stack
	48050	+ label = 4033LLU; // continue to roll stack
47977	48051	break;
47978	48052	}
47979		- case 4045LLU: // return from shadowlock to procblock
	48053	+ case 4054LLU: // return from shadowlock to procblock
47980	48054	{
47981	48055	// copy mutable arguments back from call to shadowlock
47982	48056	stack[base + 17]/label/ = stack[base + 48LLU];

		@@ -47999,9 +48073,9 @@
47999	48073	MOVE(&list->data, &stack[base + 33]/state/);
48000	48074	}
48001	48075	// call skipwscmnt from procblock
48002		- stack[base + 34LLU] = 4046LLU/throw to this address/;
	48076	+ stack[base + 34LLU] = 4055LLU/throw to this address/;
48003	48077	stack[base + 35LLU] = base;
48004		- stack[base + 36LLU] = 4047LLU;
	48078	+ stack[base + 36LLU] = 4056LLU;
48005	48079	// arguments for call to skipwscmnt
48006	48080	stack[base + 38LLU] = stack[base + 19]/lookahead/;
48007	48081	// set stack-base & callee-address

		@@ -48009,21 +48083,21 @@
48009	48083	label = 18446744073709551580LLU; // skipwscmnt
48010	48084	break;
48011	48085	}
48012		- case 4046LLU: // copy-back deleter (skipwscmnt to procblock)
	48086	+ case 4055LLU: // copy-back deleter (skipwscmnt to procblock)
48013	48087	{
48014	48088	// copy mutable arguments back from call to skipwscmnt
48015		- label = 4001LLU; // continue to roll stack
	48089	+ label = 4010LLU; // continue to roll stack
48016	48090	break;
48017	48091	}
48018		- case 4047LLU: // return from skipwscmnt to procblock
	48092	+ case 4056LLU: // return from skipwscmnt to procblock
48019	48093	{
48020	48094	// copy mutable arguments back from call to skipwscmnt
48021	48095	// copy back results provided by call to skipwscmnt
48022	48096	stack[base + 19] = stack[base + 37LLU];
48023	48097	// call equ from procblock
48024		- stack[base + 34LLU] = 4048LLU/throw to this address/;
	48098	+ stack[base + 34LLU] = 4057LLU/throw to this address/;
48025	48099	stack[base + 35LLU] = base;
48026		- stack[base + 36LLU] = 4049LLU;
	48100	+ stack[base + 36LLU] = 4058LLU;
48027	48101	// arguments for call to equ
48028	48102	stack[base + 38LLU] = 123LLU;
48029	48103	stack[base + 39LLU] = stack[base + 19]/lookahead/;

		@@ -48032,13 +48106,13 @@
48032	48106	label = 18446744073709551600LLU; // equ
48033	48107	break;
48034	48108	}
48035		- case 4048LLU: // copy-back deleter (equ to procblock)
	48109	+ case 4057LLU: // copy-back deleter (equ to procblock)
48036	48110	{
48037	48111	// copy mutable arguments back from call to equ
48038		- label = 4001LLU; // continue to roll stack
	48112	+ label = 4010LLU; // continue to roll stack
48039	48113	break;
48040	48114	}
48041		- case 4049LLU: // return from equ to procblock
	48115	+ case 4058LLU: // return from equ to procblock
48042	48116	{
48043	48117	// copy mutable arguments back from call to equ
48044	48118	// copy back results provided by call to equ

		@@ -48045,15 +48119,15 @@
48045	48119	stack[base + 20] = stack[base + 37LLU];
48046	48120	if(!stack[base + 20]/isequal/)
48047	48121	{
48048		- label = 4050LLU; // jump to alternative
	48122	+ label = 4059LLU; // jump to alternative
48049	48123	break;
48050	48124	}
48051	48125
48052	48126	// consequent
48053	48127	// call EOSbyte from procblock
48054		- stack[base + 34LLU] = 4052LLU/throw to this address/;
	48128	+ stack[base + 34LLU] = 4061LLU/throw to this address/;
48055	48129	stack[base + 35LLU] = base;
48056		- stack[base + 36LLU] = 4053LLU;
	48130	+ stack[base + 36LLU] = 4062LLU;
48057	48131	// arguments for call to EOSbyte
48058	48132	// set stack-base & callee-address
48059	48133	base += 37LLU;

		@@ -48060,26 +48134,26 @@
48060	48134	label = 77LLU; // EOSbyte
48061	48135	break;
48062	48136	}
48063		- case 4052LLU: // copy-back deleter (EOSbyte to procblock)
	48137	+ case 4061LLU: // copy-back deleter (EOSbyte to procblock)
48064	48138	{
48065	48139	// copy mutable arguments back from call to EOSbyte
48066		- label = 4001LLU; // continue to roll stack
	48140	+ label = 4010LLU; // continue to roll stack
48067	48141	break;
48068	48142	}
48069		- case 4053LLU: // return from EOSbyte to procblock
	48143	+ case 4062LLU: // return from EOSbyte to procblock
48070	48144	{
48071	48145	// copy mutable arguments back from call to EOSbyte
48072	48146	// copy back results provided by call to EOSbyte
48073	48147	stack[base + 19] = stack[base + 37LLU];
48074		- label = 4051LLU; // consequent complete
	48148	+ label = 4060LLU; // consequent complete
48075	48149	break;
48076	48150	}
48077		- case 4050LLU: // alternative
	48151	+ case 4059LLU: // alternative
48078	48152	{
48079	48153	// call MATCHPEEK from procblock
48080		- stack[base + 34LLU] = 4054LLU/throw to this address/;
	48154	+ stack[base + 34LLU] = 4063LLU/throw to this address/;
48081	48155	stack[base + 35LLU] = base;
48082		- stack[base + 36LLU] = 4055LLU;
	48156	+ stack[base + 36LLU] = 4064LLU;
48083	48157	// arguments for call to MATCHPEEK
48084	48158	stack[base + 37LLU] = stack[base + 8]/fnid/;
48085	48159	stack[base + 38LLU] = 44LLU;

		@@ -48089,32 +48163,32 @@
48089	48163	label = 206LLU; // MATCHPEEK
48090	48164	break;
48091	48165	}
48092		- case 4054LLU: // copy-back deleter (MATCHPEEK to procblock)
	48166	+ case 4063LLU: // copy-back deleter (MATCHPEEK to procblock)
48093	48167	{
48094	48168	// copy mutable arguments back from call to MATCHPEEK
48095	48169	stack[base + 19]/lookahead/ = stack[base + 39LLU];
48096		- label = 4001LLU; // continue to roll stack
	48170	+ label = 4010LLU; // continue to roll stack
48097	48171	break;
48098	48172	}
48099		- case 4055LLU: // return from MATCHPEEK to procblock
	48173	+ case 4064LLU: // return from MATCHPEEK to procblock
48100	48174	{
48101	48175	// copy mutable arguments back from call to MATCHPEEK
48102	48176	stack[base + 19]/lookahead/ = stack[base + 39LLU];
48103		- label = 4051LLU; // alternative complete
	48177	+ label = 4060LLU; // alternative complete
48104	48178	break;
48105	48179	}
48106		- case 4051LLU: // completed if-then-else
	48180	+ case 4060LLU: // completed if-then-else
48107	48181	{
48108	48182	if(stack[base + 19]/lookahead/ <= 0xFF) stack[base + 19]/lookahead/ = getchar();
48109		- label = 3995LLU; // repeat
	48183	+ label = 4004LLU; // repeat
48110	48184	break;
48111	48185	}
48112		- case 3996LLU: // loop finished
	48186	+ case 4005LLU: // loop finished
48113	48187	{
48114	48188	// call getbyte from procblock
48115		- stack[base + 33LLU] = 4056LLU/throw to this address/;
	48189	+ stack[base + 33LLU] = 4065LLU/throw to this address/;
48116	48190	stack[base + 34LLU] = base;
48117		- stack[base + 35LLU] = 4057LLU;
	48191	+ stack[base + 35LLU] = 4066LLU;
48118	48192	// arguments for call to getbyte
48119	48193	// set stack-base & callee-address
48120	48194	base += 36LLU;

		@@ -48121,13 +48195,13 @@
48121	48195	label = 18446744073709551593LLU; // getbyte
48122	48196	break;
48123	48197	}
48124		- case 4056LLU: // copy-back deleter (getbyte to procblock)
	48198	+ case 4065LLU: // copy-back deleter (getbyte to procblock)
48125	48199	{
48126	48200	// copy mutable arguments back from call to getbyte
48127		- label = 3990LLU; // continue to roll stack
	48201	+ label = 3999LLU; // continue to roll stack
48128	48202	break;
48129	48203	}
48130		- case 4057LLU: // return from getbyte to procblock
	48204	+ case 4066LLU: // return from getbyte to procblock
48131	48205	{
48132	48206	// copy mutable arguments back from call to getbyte
48133	48207	// copy back results provided by call to getbyte

		@@ -48134,9 +48208,9 @@
48134	48208	stack[base + 19] = stack[base + 36LLU];
48135	48209	printf("%s", "\n label = ");
48136	48210	// call printnr from procblock
48137		- stack[base + 33LLU] = 4058LLU/throw to this address/;
	48211	+ stack[base + 33LLU] = 4067LLU/throw to this address/;
48138	48212	stack[base + 34LLU] = base;
48139		- stack[base + 35LLU] = 4059LLU;
	48213	+ stack[base + 35LLU] = 4068LLU;
48140	48214	// arguments for call to printnr
48141	48215	stack[base + 36LLU] = stack[base + 23]/labelloop/;
48142	48216	// set stack-base & callee-address

		@@ -48144,13 +48218,13 @@
48144	48218	label = 18446744073709551590LLU; // printnr
48145	48219	break;
48146	48220	}
48147		- case 4058LLU: // copy-back deleter (printnr to procblock)
	48221	+ case 4067LLU: // copy-back deleter (printnr to procblock)
48148	48222	{
48149	48223	// copy mutable arguments back from call to printnr
48150		- label = 3990LLU; // continue to roll stack
	48224	+ label = 3999LLU; // continue to roll stack
48151	48225	break;
48152	48226	}
48153		- case 4059LLU: // return from printnr to procblock
	48227	+ case 4068LLU: // return from printnr to procblock
48154	48228	{
48155	48229	// copy mutable arguments back from call to printnr
48156	48230	printf("%s", "LLU; // start to repeat");

		@@ -48158,9 +48232,9 @@
48158	48232	printf("%s", "\n }");
48159	48233	printf("%s", "\n case ");
48160	48234	// call printnr from procblock
48161		- stack[base + 33LLU] = 4060LLU/throw to this address/;
	48235	+ stack[base + 33LLU] = 4069LLU/throw to this address/;
48162	48236	stack[base + 34LLU] = base;
48163		- stack[base + 35LLU] = 4061LLU;
	48237	+ stack[base + 35LLU] = 4070LLU;
48164	48238	// arguments for call to printnr
48165	48239	stack[base + 36LLU] = stack[base + 23]/labelloop/;
48166	48240	// set stack-base & callee-address

		@@ -48168,13 +48242,13 @@
48168	48242	label = 18446744073709551590LLU; // printnr
48169	48243	break;
48170	48244	}
48171		- case 4060LLU: // copy-back deleter (printnr to procblock)
	48245	+ case 4069LLU: // copy-back deleter (printnr to procblock)
48172	48246	{
48173	48247	// copy mutable arguments back from call to printnr
48174		- label = 3990LLU; // continue to roll stack
	48248	+ label = 3999LLU; // continue to roll stack
48175	48249	break;
48176	48250	}
48177		- case 4061LLU: // return from printnr to procblock
	48251	+ case 4070LLU: // return from printnr to procblock
48178	48252	{
48179	48253	// copy mutable arguments back from call to printnr
48180	48254	printf("%s", "LLU: // repeat from here");

		@@ -48181,14 +48255,14 @@
48181	48255	printf("%s", "\n {");
48182	48256	printf("%s", "\n if(");
48183	48257	flippedassign(stack[base + 32]/states/, &stack[base + 33]);
48184		- label = 4062LLU; // start to repeat
	48258	+ label = 4071LLU; // start to repeat
48185	48259	break;
48186	48260	}
48187		- case 4062LLU: // repeat from here
	48261	+ case 4071LLU: // repeat from here
48188	48262	{
48189	48263	if(!stack[base + 33])
48190	48264	{
48191		- label = 4063LLU; // break loop
	48265	+ label = 4072LLU; // break loop
48192	48266	break;
48193	48267	}
48194	48268

		@@ -48198,7 +48272,7 @@
48198	48272	stack[base + 33] = (uint64_t)(((const struct listnode *)(stack[base + 33]))->next);
48199	48273	if(/listtoelem/0 != ((uint64_t )(stack[base + 34]/state*/))[0])
48200	48274	{
48201		- label = 4066LLU; // jump to alternative
	48275	+ label = 4075LLU; // jump to alternative
48202	48276	break;
48203	48277	}
48204	48278

		@@ -48210,9 +48284,9 @@
48210	48284	// case
48211	48285	printf("%s", "!");
48212	48286	// call emitvaridx from procblock
48213		- stack[base + 40LLU] = 4068LLU/throw to this address/;
	48287	+ stack[base + 40LLU] = 4077LLU/throw to this address/;
48214	48288	stack[base + 41LLU] = base;
48215		- stack[base + 42LLU] = 4069LLU;
	48289	+ stack[base + 42LLU] = 4078LLU;
48216	48290	// arguments for call to emitvaridx
48217	48291	stack[base + 43LLU] = stack[base + 36]/listindex/;
48218	48292	// set stack-base & callee-address

		@@ -48220,13 +48294,13 @@
48220	48294	label = 745LLU; // emitvaridx
48221	48295	break;
48222	48296	}
48223		- case 4068LLU: // copy-back deleter (emitvaridx to procblock)
	48297	+ case 4077LLU: // copy-back deleter (emitvaridx to procblock)
48224	48298	{
48225	48299	// copy mutable arguments back from call to emitvaridx
48226		- label = 4067LLU; // continue to roll stack
	48300	+ label = 4076LLU; // continue to roll stack
48227	48301	break;
48228	48302	}
48229		- case 4069LLU: // return from emitvaridx to procblock
	48303	+ case 4078LLU: // return from emitvaridx to procblock
48230	48304	{
48231	48305	// copy mutable arguments back from call to emitvaridx
48232	48306	((uint64_t **)(stack[base + 34]))[1][3] = stack[base + 39];

		@@ -48233,62 +48307,62 @@
48233	48307	((uint64_t **)(stack[base + 34]))[1][2] = stack[base + 38];
48234	48308	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
48235	48309	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
48236		- label = 4065LLU; // case complete
	48310	+ label = 4074LLU; // case complete
48237	48311	break;
48238	48312	}
48239		- case 4067LLU: // copy-back deleter (switch)
	48313	+ case 4076LLU: // copy-back deleter (switch)
48240	48314	{
48241	48315	((uint64_t **)(stack[base + 34]))[1][3] = stack[base + 39];
48242	48316	((uint64_t **)(stack[base + 34]))[1][2] = stack[base + 38];
48243	48317	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 37];
48244	48318	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 36];
48245		- label = 4064LLU; // continue to unroll stack
	48319	+ label = 4073LLU; // continue to unroll stack
48246	48320	break;
48247	48321	}
48248		- case 4066LLU: // try next case
	48322	+ case 4075LLU: // try next case
48249	48323	{
48250	48324	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
48251	48325	exit(-1);
48252	48326	}
48253		- case 4065LLU: // completed switch
	48327	+ case 4074LLU: // completed switch
48254	48328	{
48255	48329	if(!stack[base + 33]/states/)
48256	48330	{
48257		- label = 4070LLU; // jump to alternative
	48331	+ label = 4079LLU; // jump to alternative
48258	48332	break;
48259	48333	}
48260	48334
48261	48335	// consequent
48262	48336	printf("%s", " \|\| ");
48263		- label = 4071LLU; // consequent complete
	48337	+ label = 4080LLU; // consequent complete
48264	48338	break;
48265	48339	}
48266		- case 4070LLU: // alternative
	48340	+ case 4079LLU: // alternative
48267	48341	{
48268		- label = 4071LLU; // alternative complete
	48342	+ label = 4080LLU; // alternative complete
48269	48343	break;
48270	48344	}
48271		- case 4071LLU: // completed if-then-else
	48345	+ case 4080LLU: // completed if-then-else
48272	48346	{
48273	48347	((struct listnode )(stack[base + 35]/previous*/))->data = stack[base + 34];
48274		- label = 4062LLU; // repeat
	48348	+ label = 4071LLU; // repeat
48275	48349	break;
48276	48350	}
48277		- case 4064LLU: // copy-back deleter for while next
	48351	+ case 4073LLU: // copy-back deleter for while next
48278	48352	{
48279	48353	((struct listnode )(stack[base + 35]/previous*/))->data = stack[base + 34];
48280		- label = 3990LLU; // continue to unroll stack
	48354	+ label = 3999LLU; // continue to unroll stack
48281	48355	break;
48282	48356	}
48283		- case 4063LLU: // loop finished
	48357	+ case 4072LLU: // loop finished
48284	48358	{
48285	48359	printf("%s", ")");
48286	48360	printf("%s", "\n {");
48287	48361	printf("%s", "\n label = ");
48288	48362	// call printnr from procblock
48289		- stack[base + 36LLU] = 4072LLU/throw to this address/;
	48363	+ stack[base + 36LLU] = 4081LLU/throw to this address/;
48290	48364	stack[base + 37LLU] = base;
48291		- stack[base + 38LLU] = 4073LLU;
	48365	+ stack[base + 38LLU] = 4082LLU;
48292	48366	// arguments for call to printnr
48293	48367	stack[base + 39LLU] = stack[base + 24]/labelskip/;
48294	48368	// set stack-base & callee-address

		@@ -48296,13 +48370,13 @@
48296	48370	label = 18446744073709551590LLU; // printnr
48297	48371	break;
48298	48372	}
48299		- case 4072LLU: // copy-back deleter (printnr to procblock)
	48373	+ case 4081LLU: // copy-back deleter (printnr to procblock)
48300	48374	{
48301	48375	// copy mutable arguments back from call to printnr
48302		- label = 3990LLU; // continue to roll stack
	48376	+ label = 3999LLU; // continue to roll stack
48303	48377	break;
48304	48378	}
48305		- case 4073LLU: // return from printnr to procblock
	48379	+ case 4082LLU: // return from printnr to procblock
48306	48380	{
48307	48381	// copy mutable arguments back from call to printnr
48308	48382	printf("%s", "LLU; // break loop");

		@@ -48311,14 +48385,14 @@
48311	48385	printf("%s", "\n");
48312	48386	printf("%s", "\n // loop body");
48313	48387	flippedassign(stack[base + 32]/states/, &stack[base + 36]);
48314		- label = 4074LLU; // start to repeat
	48388	+ label = 4083LLU; // start to repeat
48315	48389	break;
48316	48390	}
48317		- case 4074LLU: // repeat from here
	48391	+ case 4083LLU: // repeat from here
48318	48392	{
48319	48393	if(!stack[base + 36])
48320	48394	{
48321		- label = 4075LLU; // break loop
	48395	+ label = 4084LLU; // break loop
48322	48396	break;
48323	48397	}
48324	48398

		@@ -48328,7 +48402,7 @@
48328	48402	stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
48329	48403	if(/listtoelem/0 != ((uint64_t )(stack[base + 37]/state*/))[0])
48330	48404	{
48331		- label = 4078LLU; // jump to alternative
	48405	+ label = 4087LLU; // jump to alternative
48332	48406	break;
48333	48407	}
48334	48408

		@@ -48340,9 +48414,9 @@
48340	48414	// case
48341	48415	printf("%s", "\n ");
48342	48416	// call emitvaridx from procblock
48343		- stack[base + 43LLU] = 4080LLU/throw to this address/;
	48417	+ stack[base + 43LLU] = 4089LLU/throw to this address/;
48344	48418	stack[base + 44LLU] = base;
48345		- stack[base + 45LLU] = 4081LLU;
	48419	+ stack[base + 45LLU] = 4090LLU;
48346	48420	// arguments for call to emitvaridx
48347	48421	stack[base + 46LLU] = stack[base + 42]/elemindex/;
48348	48422	// set stack-base & callee-address

		@@ -48350,20 +48424,20 @@
48350	48424	label = 745LLU; // emitvaridx
48351	48425	break;
48352	48426	}
48353		- case 4080LLU: // copy-back deleter (emitvaridx to procblock)
	48427	+ case 4089LLU: // copy-back deleter (emitvaridx to procblock)
48354	48428	{
48355	48429	// copy mutable arguments back from call to emitvaridx
48356		- label = 4079LLU; // continue to roll stack
	48430	+ label = 4088LLU; // continue to roll stack
48357	48431	break;
48358	48432	}
48359		- case 4081LLU: // return from emitvaridx to procblock
	48433	+ case 4090LLU: // return from emitvaridx to procblock
48360	48434	{
48361	48435	// copy mutable arguments back from call to emitvaridx
48362	48436	printf("%s", " = (uint64_t)(((const struct listnode *)(");
48363	48437	// call emitvaridx from procblock
48364		- stack[base + 43LLU] = 4082LLU/throw to this address/;
	48438	+ stack[base + 43LLU] = 4091LLU/throw to this address/;
48365	48439	stack[base + 44LLU] = base;
48366		- stack[base + 45LLU] = 4083LLU;
	48440	+ stack[base + 45LLU] = 4092LLU;
48367	48441	// arguments for call to emitvaridx
48368	48442	stack[base + 46LLU] = stack[base + 39]/listindex/;
48369	48443	// set stack-base & callee-address

		@@ -48371,13 +48445,13 @@
48371	48445	label = 745LLU; // emitvaridx
48372	48446	break;
48373	48447	}
48374		- case 4082LLU: // copy-back deleter (emitvaridx to procblock)
	48448	+ case 4091LLU: // copy-back deleter (emitvaridx to procblock)
48375	48449	{
48376	48450	// copy mutable arguments back from call to emitvaridx
48377		- label = 4079LLU; // continue to roll stack
	48451	+ label = 4088LLU; // continue to roll stack
48378	48452	break;
48379	48453	}
48380		- case 4083LLU: // return from emitvaridx to procblock
	48454	+ case 4092LLU: // return from emitvaridx to procblock
48381	48455	{
48382	48456	// copy mutable arguments back from call to emitvaridx
48383	48457	printf("%s", "))->data);");

		@@ -48385,46 +48459,46 @@
48385	48459	((uint64_t **)(stack[base + 37]))[1][2] = stack[base + 41];
48386	48460	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
48387	48461	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
48388		- label = 4077LLU; // case complete
	48462	+ label = 4086LLU; // case complete
48389	48463	break;
48390	48464	}
48391		- case 4079LLU: // copy-back deleter (switch)
	48465	+ case 4088LLU: // copy-back deleter (switch)
48392	48466	{
48393	48467	((uint64_t **)(stack[base + 37]))[1][3] = stack[base + 42];
48394	48468	((uint64_t **)(stack[base + 37]))[1][2] = stack[base + 41];
48395	48469	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
48396	48470	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
48397		- label = 4076LLU; // continue to unroll stack
	48471	+ label = 4085LLU; // continue to unroll stack
48398	48472	break;
48399	48473	}
48400		- case 4078LLU: // try next case
	48474	+ case 4087LLU: // try next case
48401	48475	{
48402	48476	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
48403	48477	exit(-1);
48404	48478	}
48405		- case 4077LLU: // completed switch
	48479	+ case 4086LLU: // completed switch
48406	48480	{
48407	48481	((struct listnode )(stack[base + 38]/previous*/))->data = stack[base + 37];
48408		- label = 4074LLU; // repeat
	48482	+ label = 4083LLU; // repeat
48409	48483	break;
48410	48484	}
48411		- case 4076LLU: // copy-back deleter for while next
	48485	+ case 4085LLU: // copy-back deleter for while next
48412	48486	{
48413	48487	((struct listnode )(stack[base + 38]/previous*/))->data = stack[base + 37];
48414		- label = 3990LLU; // continue to unroll stack
	48488	+ label = 3999LLU; // continue to unroll stack
48415	48489	break;
48416	48490	}
48417		- case 4075LLU: // loop finished
	48491	+ case 4084LLU: // loop finished
48418	48492	{
48419	48493	flippedassign(stack[base + 32]/states/, &stack[base + 39]);
48420		- label = 4084LLU; // start to repeat
	48494	+ label = 4093LLU; // start to repeat
48421	48495	break;
48422	48496	}
48423		- case 4084LLU: // repeat from here
	48497	+ case 4093LLU: // repeat from here
48424	48498	{
48425	48499	if(!stack[base + 39])
48426	48500	{
48427		- label = 4085LLU; // break loop
	48501	+ label = 4094LLU; // break loop
48428	48502	break;
48429	48503	}
48430	48504

		@@ -48434,7 +48508,7 @@
48434	48508	stack[base + 39] = (uint64_t)(((const struct listnode *)(stack[base + 39]))->next);
48435	48509	if(/listtoelem/0 != ((uint64_t )(stack[base + 40]/state*/))[0])
48436	48510	{
48437		- label = 4088LLU; // jump to alternative
	48511	+ label = 4097LLU; // jump to alternative
48438	48512	break;
48439	48513	}
48440	48514

		@@ -48446,7 +48520,7 @@
48446	48520	// case
48447	48521	if(/pop/0 != ((uint64_t )(stack[base + 43]/popnext*/))[0])
48448	48522	{
48449		- label = 4091LLU; // jump to alternative
	48523	+ label = 4100LLU; // jump to alternative
48450	48524	break;
48451	48525	}
48452	48526

		@@ -48455,9 +48529,9 @@
48455	48529	printf("%s", "\n {");
48456	48530	printf("%s", "\n struct listnode list = (struct listnode )(");
48457	48531	// call emitvaridx from procblock
48458		- stack[base + 46LLU] = 4093LLU/throw to this address/;
	48532	+ stack[base + 46LLU] = 4102LLU/throw to this address/;
48459	48533	stack[base + 47LLU] = base;
48460		- stack[base + 48LLU] = 4094LLU;
	48534	+ stack[base + 48LLU] = 4103LLU;
48461	48535	// arguments for call to emitvaridx
48462	48536	stack[base + 49LLU] = stack[base + 42]/listindex/;
48463	48537	// set stack-base & callee-address

		@@ -48465,21 +48539,21 @@
48465	48539	label = 745LLU; // emitvaridx
48466	48540	break;
48467	48541	}
48468		- case 4093LLU: // copy-back deleter (emitvaridx to procblock)
	48542	+ case 4102LLU: /

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

Show on old repository browser