OSDN > Trouver un logiciel > Développement de logiciels > Compilers > JPL > SCM > SVN > Commit

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Révision	1081 (tree)
l'heure	2021-01-20 05:01:36
Auteur	jakobthomsen

Message de Log

shutdown program when construction fails

Change Summary

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

Modification

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

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

		@@ -16942,9 +16942,9 @@
16942	16942	}
16943	16943
16944	16944	// consequent
16945		-//#define dummy 30
16946		- stack[base + 30/dummy/] = 0; // init
16947		- stack[base + 30]/dummy/ = ((uint64_t *)(stack[base + 29]/constr*/))[1][0];
	16945	+//#define variantid 30
	16946	+ stack[base + 30/variantid/] = 0; // init
	16947	+ stack[base + 30]/variantid/ = ((uint64_t *)(stack[base + 29]/constr*/))[1][0];
16948	16948	//#define TYPEIDS 31
16949	16949	stack[base + 31/TYPEIDS/] = 0; // init
16950	16950	stack[base + 31]/TYPEIDS/ = ((uint64_t *)(stack[base + 29]/constr*/))[1][1];

		@@ -18160,10 +18160,67 @@
18160	18160	}
18161	18161	Free(119LLU + 1, sizeof(uint64_t), stack);
18162	18162	stack = oldstack;
	18163	+ if(!stack[base + 19]/constrflag/)
	18164	+ {
	18165	+ label = 1181LLU; // jump to alternative
	18166	+ break;
	18167	+ }
	18168	+
	18169	+ // consequent
	18170	+ printf("%s", "\n fprintf(stderr, \"%s\", \"ERROR: failed to construct ");
	18171	+ // call printid from procblock
	18172	+ stack[base + 34LLU] = base;
	18173	+ stack[base + 35LLU] = 1183LLU;
	18174	+ // arguments for call to printid
	18175	+ stack[base + 36LLU] = stack[base + 25]/name/;
	18176	+ // set stack-base & callee-address
	18177	+ base += 36LLU;
	18178	+ label = 18446744073709551588LLU; // printid
	18179	+ break;
	18180	+ }
	18181	+ case 1183LLU: // return from printid to procblock
	18182	+ {
	18183	+ // copy mutable arguments back from call to printid
	18184	+ printf("%s", ".");
	18185	+ // call printid from procblock
	18186	+ stack[base + 34LLU] = base;
	18187	+ stack[base + 35LLU] = 1184LLU;
	18188	+ // arguments for call to printid
	18189	+ stack[base + 36LLU] = stack[base + 30]/variantid/;
	18190	+ // set stack-base & callee-address
	18191	+ base += 36LLU;
	18192	+ label = 18446744073709551588LLU; // printid
	18193	+ break;
	18194	+ }
	18195	+ case 1184LLU: // return from printid to procblock
	18196	+ {
	18197	+ // copy mutable arguments back from call to printid
	18198	+ printf("%s", " into ");
	18199	+ // call printid from procblock
	18200	+ stack[base + 34LLU] = base;
	18201	+ stack[base + 35LLU] = 1185LLU;
	18202	+ // arguments for call to printid
	18203	+ stack[base + 36LLU] = stack[base + 21]/variableid/;
	18204	+ // set stack-base & callee-address
	18205	+ base += 36LLU;
	18206	+ label = 18446744073709551588LLU; // printid
	18207	+ break;
	18208	+ }
	18209	+ case 1185LLU: // return from printid to procblock
	18210	+ {
	18211	+ // copy mutable arguments back from call to printid
	18212	+ printf("%s", "\\n\");");
	18213	+ printf("%s", "\n label = 0; // alternative complete");
	18214	+ printf("%s", "\n exit(-1); // couldn't construct object so program must shut down here rather than crashing unexpectedly later down the line");
	18215	+ label = 1182LLU; // consequent complete
	18216	+ break;
	18217	+ }
	18218	+ case 1181LLU: // alternative
	18219	+ {
18163	18220	printf("%s", "\n label = ");
18164	18221	// call printnr from procblock
18165	18222	stack[base + 34LLU] = base;
18166		- stack[base + 35LLU] = 1181LLU;
	18223	+ stack[base + 35LLU] = 1186LLU;
18167	18224	// arguments for call to printnr
18168	18225	stack[base + 36LLU] = stack[base + 33]/labelskip/;
18169	18226	// set stack-base & callee-address

		@@ -18171,16 +18228,21 @@
18171	18228	label = 18446744073709551591LLU; // printnr
18172	18229	break;
18173	18230	}
18174		- case 1181LLU: // return from printnr to procblock
	18231	+ case 1186LLU: // return from printnr to procblock
18175	18232	{
18176	18233	// copy mutable arguments back from call to printnr
18177	18234	printf("%s", "LLU; // alternative complete");
18178	18235	printf("%s", "\n break;");
	18236	+ label = 1182LLU; // alternative complete
	18237	+ break;
	18238	+ }
	18239	+ case 1182LLU: // completed if-then-else
	18240	+ {
18179	18241	printf("%s", "\n }");
18180	18242	printf("%s", "\n case ");
18181	18243	// call printnr from procblock
18182	18244	stack[base + 34LLU] = base;
18183		- stack[base + 35LLU] = 1182LLU;
	18245	+ stack[base + 35LLU] = 1187LLU;
18184	18246	// arguments for call to printnr
18185	18247	stack[base + 36LLU] = stack[base + 33]/labelskip/;
18186	18248	// set stack-base & callee-address

		@@ -18188,13 +18250,13 @@
18188	18250	label = 18446744073709551591LLU; // printnr
18189	18251	break;
18190	18252	}
18191		- case 1182LLU: // return from printnr to procblock
	18253	+ case 1187LLU: // return from printnr to procblock
18192	18254	{
18193	18255	// copy mutable arguments back from call to printnr
18194	18256	printf("%s", "LLU: // completed if-then-else");
18195	18257	printf("%s", "\n {");
18196	18258	((uint64_t *)(stack[base + 29]/constr/))[1][1] = stack[base + 31]/TYPEIDS*/;
18197		- ((uint64_t *)(stack[base + 29]/constr/))[1][0] = stack[base + 30]/dummy*/;
	18259	+ ((uint64_t *)(stack[base + 29]/constr/))[1][0] = stack[base + 30]/variantid*/;
18198	18260	label = 1103LLU; // consequent complete
18199	18261	break;
18200	18262	}

		@@ -18229,7 +18291,7 @@
18229	18291	{
18230	18292	if(/typelist/1 != ((uint64_t )(stack[base + 23]/type*/))[0])
18231	18293	{
18232		- label = 1183LLU; // jump to alternative
	18294	+ label = 1188LLU; // jump to alternative
18233	18295	break;
18234	18296	}
18235	18297

		@@ -18239,7 +18301,7 @@
18239	18301	stack[base + 25]/subtype/ = ((uint64_t *)(stack[base + 23]/type*/))[1][0];
18240	18302	if(!stack[base + 20]/destrflag/)
18241	18303	{
18242		- label = 1185LLU; // jump to alternative
	18304	+ label = 1190LLU; // jump to alternative
18243	18305	break;
18244	18306	}
18245	18307

		@@ -18248,7 +18310,7 @@
18248	18310	fprintf(stderr, "%s", "(at ");
18249	18311	// call reportid from procblock
18250	18312	stack[base + 26LLU] = base;
18251		- stack[base + 27LLU] = 1187LLU;
	18313	+ stack[base + 27LLU] = 1192LLU;
18252	18314	// arguments for call to reportid
18253	18315	stack[base + 28LLU] = stack[base + 21]/variableid/;
18254	18316	// set stack-base & callee-address

		@@ -18256,25 +18318,25 @@
18256	18318	label = 18446744073709551587LLU; // reportid
18257	18319	break;
18258	18320	}
18259		- case 1187LLU: // return from reportid to procblock
	18321	+ case 1192LLU: // return from reportid to procblock
18260	18322	{
18261	18323	// copy mutable arguments back from call to reportid
18262	18324	fprintf(stderr, "%s", "\n");
18263	18325	exit(-1);
18264		- label = 1186LLU; // consequent complete
	18326	+ label = 1191LLU; // consequent complete
18265	18327	break;
18266	18328	}
18267		- case 1185LLU: // alternative
	18329	+ case 1190LLU: // alternative
18268	18330	{
18269		- label = 1186LLU; // alternative complete
	18331	+ label = 1191LLU; // alternative complete
18270	18332	break;
18271	18333	}
18272		- case 1186LLU: // completed if-then-else
	18334	+ case 1191LLU: // completed if-then-else
18273	18335	{
18274	18336	printf("%s", "\n if(!");
18275	18337	// call emitvar from procblock
18276	18338	stack[base + 26LLU] = base;
18277		- stack[base + 27LLU] = 1188LLU;
	18339	+ stack[base + 27LLU] = 1193LLU;
18278	18340	// arguments for call to emitvar
18279	18341	stack[base + 28LLU] = stack[base + 21]/variableid/;
18280	18342	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -18284,13 +18346,13 @@
18284	18346	label = 224LLU; // emitvar
18285	18347	break;
18286	18348	}
18287		- case 1188LLU: // return from emitvar to procblock
	18349	+ case 1193LLU: // return from emitvar to procblock
18288	18350	{
18289	18351	// copy mutable arguments back from call to emitvar
18290	18352	printf("%s", ")");
18291	18353	// call add from procblock
18292	18354	stack[base + 26LLU] = base;
18293		- stack[base + 27LLU] = 1189LLU;
	18355	+ stack[base + 27LLU] = 1194LLU;
18294	18356	// arguments for call to add
18295	18357	stack[base + 29LLU] = 1LLU;
18296	18358	stack[base + 30LLU] = stack[base + 14]/label/;

		@@ -18299,7 +18361,7 @@
18299	18361	label = 18446744073709551605LLU; // add
18300	18362	break;
18301	18363	}
18302		- case 1189LLU: // return from add to procblock
	18364	+ case 1194LLU: // return from add to procblock
18303	18365	{
18304	18366	// copy mutable arguments back from call to add
18305	18367	// copy back results provided by call to add

		@@ -18309,7 +18371,7 @@
18309	18371	stack[base + 26]/labelalt/ = stack[base + 14]/label/;
18310	18372	// call add from procblock
18311	18373	stack[base + 27LLU] = base;
18312		- stack[base + 28LLU] = 1190LLU;
	18374	+ stack[base + 28LLU] = 1195LLU;
18313	18375	// arguments for call to add
18314	18376	stack[base + 30LLU] = 1LLU;
18315	18377	stack[base + 31LLU] = stack[base + 14]/label/;

		@@ -18318,7 +18380,7 @@
18318	18380	label = 18446744073709551605LLU; // add
18319	18381	break;
18320	18382	}
18321		- case 1190LLU: // return from add to procblock
	18383	+ case 1195LLU: // return from add to procblock
18322	18384	{
18323	18385	// copy mutable arguments back from call to add
18324	18386	// copy back results provided by call to add

		@@ -18330,7 +18392,7 @@
18330	18392	printf("%s", "\n label = ");
18331	18393	// call printnr from procblock
18332	18394	stack[base + 28LLU] = base;
18333		- stack[base + 29LLU] = 1191LLU;
	18395	+ stack[base + 29LLU] = 1196LLU;
18334	18396	// arguments for call to printnr
18335	18397	stack[base + 30LLU] = stack[base + 26]/labelalt/;
18336	18398	// set stack-base & callee-address

		@@ -18338,7 +18400,7 @@
18338	18400	label = 18446744073709551591LLU; // printnr
18339	18401	break;
18340	18402	}
18341		- case 1191LLU: // return from printnr to procblock
	18403	+ case 1196LLU: // return from printnr to procblock
18342	18404	{
18343	18405	// copy mutable arguments back from call to printnr
18344	18406	printf("%s", "LLU; // jump to alternative");

		@@ -18354,7 +18416,7 @@
18354	18416	stack[base + 30/index/] = 0; // init
18355	18417	// call FINDLET from procblock
18356	18418	stack[base + 31LLU] = base;
18357		- stack[base + 32LLU] = 1192LLU;
	18419	+ stack[base + 32LLU] = 1197LLU;
18358	18420	// arguments for call to FINDLET
18359	18421	stack[base + 36LLU] = stack[base + 21]/variableid/;
18360	18422	stack[base + 37LLU] = stack[base + 2]/scopes/;

		@@ -18364,7 +18426,7 @@
18364	18426	label = 186LLU; // FINDLET
18365	18427	break;
18366	18428	}
18367		- case 1192LLU: // return from FINDLET to procblock
	18429	+ case 1197LLU: // return from FINDLET to procblock
18368	18430	{
18369	18431	// copy mutable arguments back from call to FINDLET
18370	18432	// copy back results provided by call to FINDLET

		@@ -18386,7 +18448,7 @@
18386	18448	stack[base + 3]/scope/ = 0;
18387	18449	// call matchsym from procblock
18388	18450	stack[base + 31LLU] = base;
18389		- stack[base + 32LLU] = 1193LLU;
	18451	+ stack[base + 32LLU] = 1198LLU;
18390	18452	// arguments for call to matchsym
18391	18453	stack[base + 33LLU] = 123LLU;
18392	18454	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18395,13 +18457,13 @@
18395	18457	label = 27LLU; // matchsym
18396	18458	break;
18397	18459	}
18398		- case 1193LLU: // return from matchsym to procblock
	18460	+ case 1198LLU: // return from matchsym to procblock
18399	18461	{
18400	18462	// copy mutable arguments back from call to matchsym
18401	18463	stack[base + 11]/lookahead/ = stack[base + 34LLU];
18402	18464	// call matchid from procblock
18403	18465	stack[base + 31LLU] = base;
18404		- stack[base + 32LLU] = 1194LLU;
	18466	+ stack[base + 32LLU] = 1199LLU;
18405	18467	// arguments for call to matchid
18406	18468	stack[base + 33LLU] = stack[base + 21]/variableid/;
18407	18469	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18410,13 +18472,13 @@
18410	18472	label = 39LLU; // matchid
18411	18473	break;
18412	18474	}
18413		- case 1194LLU: // return from matchid to procblock
	18475	+ case 1199LLU: // return from matchid to procblock
18414	18476	{
18415	18477	// copy mutable arguments back from call to matchid
18416	18478	stack[base + 11]/lookahead/ = stack[base + 34LLU];
18417	18479	// call matchsym from procblock
18418	18480	stack[base + 31LLU] = base;
18419		- stack[base + 32LLU] = 1195LLU;
	18481	+ stack[base + 32LLU] = 1200LLU;
18420	18482	// arguments for call to matchsym
18421	18483	stack[base + 33LLU] = 46LLU;
18422	18484	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18425,13 +18487,13 @@
18425	18487	label = 27LLU; // matchsym
18426	18488	break;
18427	18489	}
18428		- case 1195LLU: // return from matchsym to procblock
	18490	+ case 1200LLU: // return from matchsym to procblock
18429	18491	{
18430	18492	// copy mutable arguments back from call to matchsym
18431	18493	stack[base + 11]/lookahead/ = stack[base + 34LLU];
18432	18494	// call matchid from procblock
18433	18495	stack[base + 31LLU] = base;
18434		- stack[base + 32LLU] = 1196LLU;
	18496	+ stack[base + 32LLU] = 1201LLU;
18435	18497	// arguments for call to matchid
18436	18498	stack[base + 33LLU] = 566536285473210368LLU;
18437	18499	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18440,13 +18502,13 @@
18440	18502	label = 39LLU; // matchid
18441	18503	break;
18442	18504	}
18443		- case 1196LLU: // return from matchid to procblock
	18505	+ case 1201LLU: // return from matchid to procblock
18444	18506	{
18445	18507	// copy mutable arguments back from call to matchid
18446	18508	stack[base + 11]/lookahead/ = stack[base + 34LLU];
18447	18509	// call matchsym from procblock
18448	18510	stack[base + 31LLU] = base;
18449		- stack[base + 32LLU] = 1197LLU;
	18511	+ stack[base + 32LLU] = 1202LLU;
18450	18512	// arguments for call to matchsym
18451	18513	stack[base + 33LLU] = 45LLU;
18452	18514	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18455,13 +18517,13 @@
18455	18517	label = 27LLU; // matchsym
18456	18518	break;
18457	18519	}
18458		- case 1197LLU: // return from matchsym to procblock
	18520	+ case 1202LLU: // return from matchsym to procblock
18459	18521	{
18460	18522	// copy mutable arguments back from call to matchsym
18461	18523	stack[base + 11]/lookahead/ = stack[base + 34LLU];
18462	18524	// call matchsym from procblock
18463	18525	stack[base + 31LLU] = base;
18464		- stack[base + 32LLU] = 1198LLU;
	18526	+ stack[base + 32LLU] = 1203LLU;
18465	18527	// arguments for call to matchsym
18466	18528	stack[base + 33LLU] = 62LLU;
18467	18529	stack[base + 34LLU] = stack[base + 11]/lookahead/;

		@@ -18470,7 +18532,7 @@
18470	18532	label = 27LLU; // matchsym
18471	18533	break;
18472	18534	}
18473		- case 1198LLU: // return from matchsym to procblock
	18535	+ case 1203LLU: // return from matchsym to procblock
18474	18536	{
18475	18537	// copy mutable arguments back from call to matchsym
18476	18538	stack[base + 11]/lookahead/ = stack[base + 34LLU];

		@@ -18478,7 +18540,7 @@
18478	18540	stack[base + 31/datavarid/] = 0; // init
18479	18541	// call parsetoken from procblock
18480	18542	stack[base + 32LLU] = base;
18481		- stack[base + 33LLU] = 1199LLU;
	18543	+ stack[base + 33LLU] = 1204LLU;
18482	18544	// arguments for call to parsetoken
18483	18545	stack[base + 37LLU] = stack[base + 11]/lookahead/;
18484	18546	// set stack-base & callee-address

		@@ -18486,7 +18548,7 @@
18486	18548	label = 18446744073709551585LLU; // parsetoken
18487	18549	break;
18488	18550	}
18489		- case 1199LLU: // return from parsetoken to procblock
	18551	+ case 1204LLU: // return from parsetoken to procblock
18490	18552	{
18491	18553	// copy mutable arguments back from call to parsetoken
18492	18554	// copy back results provided by call to parsetoken

		@@ -18495,7 +18557,7 @@
18495	18557	stack[base + 11] = stack[base + 36LLU];
18496	18558	// call equ from procblock
18497	18559	stack[base + 32LLU] = base;
18498		- stack[base + 33LLU] = 1200LLU;
	18560	+ stack[base + 33LLU] = 1205LLU;
18499	18561	// arguments for call to equ
18500	18562	stack[base + 35LLU] = stack[base + 12]/variant/;
18501	18563	stack[base + 36LLU] = 4LLU;

		@@ -18504,7 +18566,7 @@
18504	18566	label = 18446744073709551600LLU; // equ
18505	18567	break;
18506	18568	}
18507		- case 1200LLU: // return from equ to procblock
	18569	+ case 1205LLU: // return from equ to procblock
18508	18570	{
18509	18571	// copy mutable arguments back from call to equ
18510	18572	// copy back results provided by call to equ

		@@ -18511,7 +18573,7 @@
18511	18573	stack[base + 18] = stack[base + 34LLU];
18512	18574	if(!stack[base + 18]/isequal/)
18513	18575	{
18514		- label = 1201LLU; // jump to alternative
	18576	+ label = 1206LLU; // jump to alternative
18515	18577	break;
18516	18578	}
18517	18579

		@@ -18523,7 +18585,7 @@
18523	18585	// call copytype from procblock
18524	18586	newstack[0] = (uint64_t)stack; // backup stack location
18525	18587	newstack[1] = base;
18526		- newstack[2] = 1203LLU;
	18588	+ newstack[2] = 1208LLU;
18527	18589	// arguments for call to copytype
18528	18590	newstack[4LLU] = stack[base + 25]/subtype/;
18529	18591	stack = newstack;

		@@ -18532,7 +18594,7 @@
18532	18594	label = 82LLU; // copytype
18533	18595	break;
18534	18596	}
18535		- case 1203LLU: // return from copytype to procblock
	18597	+ case 1208LLU: // return from copytype to procblock
18536	18598	{
18537	18599	uint64_t oldstack = (uint64_t )stack[0];
18538	18600	// copy mutable arguments back from call to copytype

		@@ -18547,7 +18609,7 @@
18547	18609	stack = oldstack;
18548	18610	// call newvar from procblock
18549	18611	stack[base + 33LLU] = base;
18550		- stack[base + 34LLU] = 1204LLU;
	18612	+ stack[base + 34LLU] = 1209LLU;
18551	18613	// arguments for call to newvar
18552	18614	stack[base + 35LLU] = stack[base + 32]/copy/;
18553	18615	stack[base + 36LLU] = stack[base + 31]/datavarid/;

		@@ -18562,7 +18624,7 @@
18562	18624	label = 235LLU; // newvar
18563	18625	break;
18564	18626	}
18565		- case 1204LLU: // return from newvar to procblock
	18627	+ case 1209LLU: // return from newvar to procblock
18566	18628	{
18567	18629	// copy mutable arguments back from call to newvar
18568	18630	stack[base + 3]/scope/ = stack[base + 42LLU];

		@@ -18571,7 +18633,7 @@
18571	18633	printf("%s", "\n ");
18572	18634	// call emitvar from procblock
18573	18635	stack[base + 32LLU] = base;
18574		- stack[base + 33LLU] = 1205LLU;
	18636	+ stack[base + 33LLU] = 1210LLU;
18575	18637	// arguments for call to emitvar
18576	18638	stack[base + 34LLU] = stack[base + 31]/datavarid/;
18577	18639	stack[base + 35LLU] = stack[base + 2]/scopes/;

		@@ -18581,13 +18643,13 @@
18581	18643	label = 224LLU; // emitvar
18582	18644	break;
18583	18645	}
18584		- case 1205LLU: // return from emitvar to procblock
	18646	+ case 1210LLU: // return from emitvar to procblock
18585	18647	{
18586	18648	// copy mutable arguments back from call to emitvar
18587	18649	printf("%s", " = ((struct listnode *)(");
18588	18650	// call emitvar from procblock
18589	18651	stack[base + 32LLU] = base;
18590		- stack[base + 33LLU] = 1206LLU;
	18652	+ stack[base + 33LLU] = 1211LLU;
18591	18653	// arguments for call to emitvar
18592	18654	stack[base + 34LLU] = stack[base + 21]/variableid/;
18593	18655	stack[base + 35LLU] = stack[base + 2]/scopes/;

		@@ -18597,19 +18659,19 @@
18597	18659	label = 224LLU; // emitvar
18598	18660	break;
18599	18661	}
18600		- case 1206LLU: // return from emitvar to procblock
	18662	+ case 1211LLU: // return from emitvar to procblock
18601	18663	{
18602	18664	// copy mutable arguments back from call to emitvar
18603	18665	printf("%s", "))->data;");
18604		- label = 1202LLU; // consequent complete
	18666	+ label = 1207LLU; // consequent complete
18605	18667	break;
18606	18668	}
18607		- case 1201LLU: // alternative
	18669	+ case 1206LLU: // alternative
18608	18670	{
18609	18671	fprintf(stderr, "%s", "ACCESS list requires variable but found ");
18610	18672	// call reporttok from procblock
18611	18673	stack[base + 32LLU] = base;
18612		- stack[base + 33LLU] = 1207LLU;
	18674	+ stack[base + 33LLU] = 1212LLU;
18613	18675	// arguments for call to reporttok
18614	18676	stack[base + 34LLU] = stack[base + 12]/variant/;
18615	18677	stack[base + 35LLU] = stack[base + 31]/datavarid/;

		@@ -18618,19 +18680,19 @@
18618	18680	label = 18446744073709551583LLU; // reporttok
18619	18681	break;
18620	18682	}
18621		- case 1207LLU: // return from reporttok to procblock
	18683	+ case 1212LLU: // return from reporttok to procblock
18622	18684	{
18623	18685	// copy mutable arguments back from call to reporttok
18624	18686	fprintf(stderr, "%s", "\n");
18625	18687	exit(-1);
18626		- label = 1202LLU; // alternative complete
	18688	+ label = 1207LLU; // alternative complete
18627	18689	break;
18628	18690	}
18629		- case 1202LLU: // completed if-then-else
	18691	+ case 1207LLU: // completed if-then-else
18630	18692	{
18631	18693	// call matchid from procblock
18632	18694	stack[base + 32LLU] = base;
18633		- stack[base + 33LLU] = 1208LLU;
	18695	+ stack[base + 33LLU] = 1213LLU;
18634	18696	// arguments for call to matchid
18635	18697	stack[base + 34LLU] = stack[base + 21]/variableid/;
18636	18698	stack[base + 35LLU] = stack[base + 11]/lookahead/;

		@@ -18639,13 +18701,13 @@
18639	18701	label = 39LLU; // matchid
18640	18702	break;
18641	18703	}
18642		- case 1208LLU: // return from matchid to procblock
	18704	+ case 1213LLU: // return from matchid to procblock
18643	18705	{
18644	18706	// copy mutable arguments back from call to matchid
18645	18707	stack[base + 11]/lookahead/ = stack[base + 35LLU];
18646	18708	// call matchsym from procblock
18647	18709	stack[base + 32LLU] = base;
18648		- stack[base + 33LLU] = 1209LLU;
	18710	+ stack[base + 33LLU] = 1214LLU;
18649	18711	// arguments for call to matchsym
18650	18712	stack[base + 34LLU] = 46LLU;
18651	18713	stack[base + 35LLU] = stack[base + 11]/lookahead/;

		@@ -18654,13 +18716,13 @@
18654	18716	label = 27LLU; // matchsym
18655	18717	break;
18656	18718	}
18657		- case 1209LLU: // return from matchsym to procblock
	18719	+ case 1214LLU: // return from matchsym to procblock
18658	18720	{
18659	18721	// copy mutable arguments back from call to matchsym
18660	18722	stack[base + 11]/lookahead/ = stack[base + 35LLU];
18661	18723	// call matchid from procblock
18662	18724	stack[base + 32LLU] = base;
18663		- stack[base + 33LLU] = 1210LLU;
	18725	+ stack[base + 33LLU] = 1215LLU;
18664	18726	// arguments for call to matchid
18665	18727	stack[base + 34LLU] = 747825068330975232LLU;
18666	18728	stack[base + 35LLU] = stack[base + 11]/lookahead/;

		@@ -18669,13 +18731,13 @@
18669	18731	label = 39LLU; // matchid
18670	18732	break;
18671	18733	}
18672		- case 1210LLU: // return from matchid to procblock
	18734	+ case 1215LLU: // return from matchid to procblock
18673	18735	{
18674	18736	// copy mutable arguments back from call to matchid
18675	18737	stack[base + 11]/lookahead/ = stack[base + 35LLU];
18676	18738	// call matchsym from procblock
18677	18739	stack[base + 32LLU] = base;
18678		- stack[base + 33LLU] = 1211LLU;
	18740	+ stack[base + 33LLU] = 1216LLU;
18679	18741	// arguments for call to matchsym
18680	18742	stack[base + 34LLU] = 45LLU;
18681	18743	stack[base + 35LLU] = stack[base + 11]/lookahead/;

		@@ -18684,13 +18746,13 @@
18684	18746	label = 27LLU; // matchsym
18685	18747	break;
18686	18748	}
18687		- case 1211LLU: // return from matchsym to procblock
	18749	+ case 1216LLU: // return from matchsym to procblock
18688	18750	{
18689	18751	// copy mutable arguments back from call to matchsym
18690	18752	stack[base + 11]/lookahead/ = stack[base + 35LLU];
18691	18753	// call matchsym from procblock
18692	18754	stack[base + 32LLU] = base;
18693		- stack[base + 33LLU] = 1212LLU;
	18755	+ stack[base + 33LLU] = 1217LLU;
18694	18756	// arguments for call to matchsym
18695	18757	stack[base + 34LLU] = 62LLU;
18696	18758	stack[base + 35LLU] = stack[base + 11]/lookahead/;

		@@ -18699,7 +18761,7 @@
18699	18761	label = 27LLU; // matchsym
18700	18762	break;
18701	18763	}
18702		- case 1212LLU: // return from matchsym to procblock
	18764	+ case 1217LLU: // return from matchsym to procblock
18703	18765	{
18704	18766	// copy mutable arguments back from call to matchsym
18705	18767	stack[base + 11]/lookahead/ = stack[base + 35LLU];

		@@ -18707,7 +18769,7 @@
18707	18769	stack[base + 32/nextvarid/] = 0; // init
18708	18770	// call parsetoken from procblock
18709	18771	stack[base + 33LLU] = base;
18710		- stack[base + 34LLU] = 1213LLU;
	18772	+ stack[base + 34LLU] = 1218LLU;
18711	18773	// arguments for call to parsetoken
18712	18774	stack[base + 38LLU] = stack[base + 11]/lookahead/;
18713	18775	// set stack-base & callee-address

		@@ -18715,7 +18777,7 @@
18715	18777	label = 18446744073709551585LLU; // parsetoken
18716	18778	break;
18717	18779	}
18718		- case 1213LLU: // return from parsetoken to procblock
	18780	+ case 1218LLU: // return from parsetoken to procblock
18719	18781	{
18720	18782	// copy mutable arguments back from call to parsetoken
18721	18783	// copy back results provided by call to parsetoken

		@@ -18724,7 +18786,7 @@
18724	18786	stack[base + 11] = stack[base + 37LLU];
18725	18787	// call equ from procblock
18726	18788	stack[base + 33LLU] = base;
18727		- stack[base + 34LLU] = 1214LLU;
	18789	+ stack[base + 34LLU] = 1219LLU;
18728	18790	// arguments for call to equ
18729	18791	stack[base + 36LLU] = stack[base + 12]/variant/;
18730	18792	stack[base + 37LLU] = 4LLU;

		@@ -18733,7 +18795,7 @@
18733	18795	label = 18446744073709551600LLU; // equ
18734	18796	break;
18735	18797	}
18736		- case 1214LLU: // return from equ to procblock
	18798	+ case 1219LLU: // return from equ to procblock
18737	18799	{
18738	18800	// copy mutable arguments back from call to equ
18739	18801	// copy back results provided by call to equ

		@@ -18740,7 +18802,7 @@
18740	18802	stack[base + 18] = stack[base + 35LLU];
18741	18803	if(!stack[base + 18]/isequal/)
18742	18804	{
18743		- label = 1215LLU; // jump to alternative
	18805	+ label = 1220LLU; // jump to alternative
18744	18806	break;
18745	18807	}
18746	18808

		@@ -18752,7 +18814,7 @@
18752	18814	// call copytype from procblock
18753	18815	newstack[0] = (uint64_t)stack; // backup stack location
18754	18816	newstack[1] = base;
18755		- newstack[2] = 1217LLU;
	18817	+ newstack[2] = 1222LLU;
18756	18818	// arguments for call to copytype
18757	18819	newstack[4LLU] = stack[base + 23]/type/;
18758	18820	stack = newstack;

		@@ -18761,7 +18823,7 @@
18761	18823	label = 82LLU; // copytype
18762	18824	break;
18763	18825	}
18764		- case 1217LLU: // return from copytype to procblock
	18826	+ case 1222LLU: // return from copytype to procblock
18765	18827	{
18766	18828	uint64_t oldstack = (uint64_t )stack[0];
18767	18829	// copy mutable arguments back from call to copytype

		@@ -18776,7 +18838,7 @@
18776	18838	stack = oldstack;
18777	18839	// call newvar from procblock
18778	18840	stack[base + 34LLU] = base;
18779		- stack[base + 35LLU] = 1218LLU;
	18841	+ stack[base + 35LLU] = 1223LLU;
18780	18842	// arguments for call to newvar
18781	18843	stack[base + 36LLU] = stack[base + 33]/copy/;
18782	18844	stack[base + 37LLU] = stack[base + 32]/nextvarid/;

		@@ -18791,7 +18853,7 @@
18791	18853	label = 235LLU; // newvar
18792	18854	break;
18793	18855	}
18794		- case 1218LLU: // return from newvar to procblock
	18856	+ case 1223LLU: // return from newvar to procblock
18795	18857	{
18796	18858	// copy mutable arguments back from call to newvar
18797	18859	stack[base + 3]/scope/ = stack[base + 43LLU];

		@@ -18800,7 +18862,7 @@
18800	18862	printf("%s", "\n ");
18801	18863	// call emitvar from procblock
18802	18864	stack[base + 33LLU] = base;
18803		- stack[base + 34LLU] = 1219LLU;
	18865	+ stack[base + 34LLU] = 1224LLU;
18804	18866	// arguments for call to emitvar
18805	18867	stack[base + 35LLU] = stack[base + 32]/nextvarid/;
18806	18868	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18810,13 +18872,13 @@
18810	18872	label = 224LLU; // emitvar
18811	18873	break;
18812	18874	}
18813		- case 1219LLU: // return from emitvar to procblock
	18875	+ case 1224LLU: // return from emitvar to procblock
18814	18876	{
18815	18877	// copy mutable arguments back from call to emitvar
18816	18878	printf("%s", " = (uint64_t)(((struct listnode *)(");
18817	18879	// call emitvar from procblock
18818	18880	stack[base + 33LLU] = base;
18819		- stack[base + 34LLU] = 1220LLU;
	18881	+ stack[base + 34LLU] = 1225LLU;
18820	18882	// arguments for call to emitvar
18821	18883	stack[base + 35LLU] = stack[base + 21]/variableid/;
18822	18884	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18826,19 +18888,19 @@
18826	18888	label = 224LLU; // emitvar
18827	18889	break;
18828	18890	}
18829		- case 1220LLU: // return from emitvar to procblock
	18891	+ case 1225LLU: // return from emitvar to procblock
18830	18892	{
18831	18893	// copy mutable arguments back from call to emitvar
18832	18894	printf("%s", "))->next);");
18833		- label = 1216LLU; // consequent complete
	18895	+ label = 1221LLU; // consequent complete
18834	18896	break;
18835	18897	}
18836		- case 1215LLU: // alternative
	18898	+ case 1220LLU: // alternative
18837	18899	{
18838	18900	fprintf(stderr, "%s", "ACCESS list requires variable but found ");
18839	18901	// call reporttok from procblock
18840	18902	stack[base + 33LLU] = base;
18841		- stack[base + 34LLU] = 1221LLU;
	18903	+ stack[base + 34LLU] = 1226LLU;
18842	18904	// arguments for call to reporttok
18843	18905	stack[base + 35LLU] = stack[base + 12]/variant/;
18844	18906	stack[base + 36LLU] = stack[base + 32]/nextvarid/;

		@@ -18847,15 +18909,15 @@
18847	18909	label = 18446744073709551583LLU; // reporttok
18848	18910	break;
18849	18911	}
18850		- case 1221LLU: // return from reporttok to procblock
	18912	+ case 1226LLU: // return from reporttok to procblock
18851	18913	{
18852	18914	// copy mutable arguments back from call to reporttok
18853	18915	fprintf(stderr, "%s", "\n");
18854	18916	exit(-1);
18855		- label = 1216LLU; // alternative complete
	18917	+ label = 1221LLU; // alternative complete
18856	18918	break;
18857	18919	}
18858		- case 1216LLU: // completed if-then-else
	18920	+ case 1221LLU: // completed if-then-else
18859	18921	{
18860	18922	{
18861	18923	struct listnode list = (struct listnode )Calloc(1, sizeof(struct listnode));

		@@ -18869,7 +18931,7 @@
18869	18931	// call procblock from procblock
18870	18932	newstack[0] = (uint64_t)stack; // backup stack location
18871	18933	newstack[1] = base;
18872		- newstack[2] = 1222LLU;
	18934	+ newstack[2] = 1227LLU;
18873	18935	// arguments for call to procblock
18874	18936	newstack[3LLU] = stack[base + 0]/fndefs/;
18875	18937	newstack[4LLU] = stack[base + 1]/typedefs/;

		@@ -18892,7 +18954,7 @@
18892	18954	label = 961LLU; // procblock
18893	18955	break;
18894	18956	}
18895		- case 1222LLU: // return from procblock to procblock
	18957	+ case 1227LLU: // return from procblock to procblock
18896	18958	{
18897	18959	uint64_t oldstack = (uint64_t )stack[0];
18898	18960	// copy mutable arguments back from call to procblock

		@@ -18912,7 +18974,7 @@
18912	18974	printf("%s", "\n ((struct listnode *)(");
18913	18975	// call emitvar from procblock
18914	18976	stack[base + 33LLU] = base;
18915		- stack[base + 34LLU] = 1223LLU;
	18977	+ stack[base + 34LLU] = 1228LLU;
18916	18978	// arguments for call to emitvar
18917	18979	stack[base + 35LLU] = stack[base + 21]/variableid/;
18918	18980	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18922,13 +18984,13 @@
18922	18984	label = 224LLU; // emitvar
18923	18985	break;
18924	18986	}
18925		- case 1223LLU: // return from emitvar to procblock
	18987	+ case 1228LLU: // return from emitvar to procblock
18926	18988	{
18927	18989	// copy mutable arguments back from call to emitvar
18928	18990	printf("%s", "))->data = ");
18929	18991	// call emitvar from procblock
18930	18992	stack[base + 33LLU] = base;
18931		- stack[base + 34LLU] = 1224LLU;
	18993	+ stack[base + 34LLU] = 1229LLU;
18932	18994	// arguments for call to emitvar
18933	18995	stack[base + 35LLU] = stack[base + 31]/datavarid/;
18934	18996	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18938,7 +19000,7 @@
18938	19000	label = 224LLU; // emitvar
18939	19001	break;
18940	19002	}
18941		- case 1224LLU: // return from emitvar to procblock
	19003	+ case 1229LLU: // return from emitvar to procblock
18942	19004	{
18943	19005	// copy mutable arguments back from call to emitvar
18944	19006	printf("%s", ";");

		@@ -18945,7 +19007,7 @@
18945	19007	printf("%s", "\n ((struct listnode *)(");
18946	19008	// call emitvar from procblock
18947	19009	stack[base + 33LLU] = base;
18948		- stack[base + 34LLU] = 1225LLU;
	19010	+ stack[base + 34LLU] = 1230LLU;
18949	19011	// arguments for call to emitvar
18950	19012	stack[base + 35LLU] = stack[base + 21]/variableid/;
18951	19013	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18955,13 +19017,13 @@
18955	19017	label = 224LLU; // emitvar
18956	19018	break;
18957	19019	}
18958		- case 1225LLU: // return from emitvar to procblock
	19020	+ case 1230LLU: // return from emitvar to procblock
18959	19021	{
18960	19022	// copy mutable arguments back from call to emitvar
18961	19023	printf("%s", "))->next = (struct listnode *)(");
18962	19024	// call emitvar from procblock
18963	19025	stack[base + 33LLU] = base;
18964		- stack[base + 34LLU] = 1226LLU;
	19026	+ stack[base + 34LLU] = 1231LLU;
18965	19027	// arguments for call to emitvar
18966	19028	stack[base + 35LLU] = stack[base + 32]/nextvarid/;
18967	19029	stack[base + 36LLU] = stack[base + 2]/scopes/;

		@@ -18971,13 +19033,13 @@
18971	19033	label = 224LLU; // emitvar
18972	19034	break;
18973	19035	}
18974		- case 1226LLU: // return from emitvar to procblock
	19036	+ case 1231LLU: // return from emitvar to procblock
18975	19037	{
18976	19038	// copy mutable arguments back from call to emitvar
18977	19039	printf("%s", ");");
18978	19040	if(!stack[base + 3]/scope/)
18979	19041	{
18980		- label = 1227LLU; // jump to alternative
	19042	+ label = 1232LLU; // jump to alternative
18981	19043	break;
18982	19044	}
18983	19045

		@@ -18984,21 +19046,21 @@
18984	19046	// consequent
18985	19047	fprintf(stderr, "%s", "INTERNAL ERROR: scope not empty\n");
18986	19048	exit(-1);
18987		- label = 1228LLU; // consequent complete
	19049	+ label = 1233LLU; // consequent complete
18988	19050	break;
18989	19051	}
18990		- case 1227LLU: // alternative
	19052	+ case 1232LLU: // alternative
18991	19053	{
18992		- label = 1228LLU; // alternative complete
	19054	+ label = 1233LLU; // alternative complete
18993	19055	break;
18994	19056	}
18995		- case 1228LLU: // completed if-then-else
	19057	+ case 1233LLU: // completed if-then-else
18996	19058	{
18997	19059	{ // if pop
18998	19060	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
18999	19061	if(!list)
19000	19062	{
19001		- label = 1229LLU; // jump to alternative
	19063	+ label = 1234LLU; // jump to alternative
19002	19064	break;
19003	19065	}
19004	19066

		@@ -19008,26 +19070,26 @@
19008	19070	Free(1, sizeof(struct listnode), list);
19009	19071	stack[base + 2]/scopes/ = (uint64_t)next;
19010	19072	}
19011		- label = 1230LLU; // consequent complete
	19073	+ label = 1235LLU; // consequent complete
19012	19074	break;
19013	19075	}
19014		- case 1229LLU: // alternative
	19076	+ case 1234LLU: // alternative
19015	19077	{
19016	19078	fprintf(stderr, "%s", "internal error poping scope in block\n");
19017	19079	exit(-1);
19018		- label = 1230LLU; // alternative complete
	19080	+ label = 1235LLU; // alternative complete
19019	19081	break;
19020	19082	}
19021		- case 1230LLU: // completed if-then-else
	19083	+ case 1235LLU: // completed if-then-else
19022	19084	{
19023		- label = 1231LLU; // start to repeat
	19085	+ label = 1236LLU; // start to repeat
19024	19086	break;
19025	19087	}
19026		- case 1231LLU: // repeat from here
	19088	+ case 1236LLU: // repeat from here
19027	19089	{
19028	19090	if(!stack[base + 3]/scope/)
19029	19091	{
19030		- label = 1232LLU; // break loop
	19092	+ label = 1237LLU; // break loop
19031	19093	break;
19032	19094	}
19033	19095

		@@ -19038,7 +19100,7 @@
19038	19100	struct listnode list = (struct listnode )stack[base + 3]/scope/;
19039	19101	if(!list)
19040	19102	{
19041		- label = 1233LLU; // jump to alternative
	19103	+ label = 1238LLU; // jump to alternative
19042	19104	break;
19043	19105	}
19044	19106

		@@ -19050,7 +19112,7 @@
19050	19112	}
19051	19113	// call dellet from procblock
19052	19114	stack[base + 34LLU] = base;
19053		- stack[base + 35LLU] = 1235LLU;
	19115	+ stack[base + 35LLU] = 1240LLU;
19054	19116	// arguments for call to dellet
19055	19117	stack[base + 36LLU] = stack[base + 33]/current/;
19056	19118	// set stack-base & callee-address

		@@ -19058,31 +19120,31 @@
19058	19120	label = 166LLU; // dellet
19059	19121	break;
19060	19122	}
19061		- case 1235LLU: // return from dellet to procblock
	19123	+ case 1240LLU: // return from dellet to procblock
19062	19124	{
19063	19125	// copy mutable arguments back from call to dellet
19064		- label = 1234LLU; // consequent complete
	19126	+ label = 1239LLU; // consequent complete
19065	19127	break;
19066	19128	}
19067		- case 1233LLU: // alternative
	19129	+ case 1238LLU: // alternative
19068	19130	{
19069	19131	fprintf(stderr, "%s", "internal error releasing references to struct elements\n");
19070	19132	exit(-1);
19071		- label = 1234LLU; // alternative complete
	19133	+ label = 1239LLU; // alternative complete
19072	19134	break;
19073	19135	}
19074		- case 1234LLU: // completed if-then-else
	19136	+ case 1239LLU: // completed if-then-else
19075	19137	{
19076		- label = 1231LLU; // repeat
	19138	+ label = 1236LLU; // repeat
19077	19139	break;
19078	19140	}
19079		- case 1232LLU: // loop finished
	19141	+ case 1237LLU: // loop finished
19080	19142	{
19081	19143	{ // if pop
19082	19144	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
19083	19145	if(!list)
19084	19146	{
19085		- label = 1236LLU; // jump to alternative
	19147	+ label = 1241LLU; // jump to alternative
19086	19148	break;
19087	19149	}
19088	19150

		@@ -19092,22 +19154,22 @@
19092	19154	Free(1, sizeof(struct listnode), list);
19093	19155	stack[base + 2]/scopes/ = (uint64_t)next;
19094	19156	}
19095		- label = 1237LLU; // consequent complete
	19157	+ label = 1242LLU; // consequent complete
19096	19158	break;
19097	19159	}
19098		- case 1236LLU: // alternative
	19160	+ case 1241LLU: // alternative
19099	19161	{
19100	19162	fprintf(stderr, "%s", "internal error poping scope in block\n");
19101	19163	exit(-1);
19102		- label = 1237LLU; // alternative complete
	19164	+ label = 1242LLU; // alternative complete
19103	19165	break;
19104	19166	}
19105		- case 1237LLU: // completed if-then-else
	19167	+ case 1242LLU: // completed if-then-else
19106	19168	{
19107	19169	printf("%s", "\n label = ");
19108	19170	// call printnr from procblock
19109	19171	stack[base + 28LLU] = base;
19110		- stack[base + 29LLU] = 1238LLU;
	19172	+ stack[base + 29LLU] = 1243LLU;
19111	19173	// arguments for call to printnr
19112	19174	stack[base + 30LLU] = stack[base + 27]/labelskip/;
19113	19175	// set stack-base & callee-address

		@@ -19115,7 +19177,7 @@
19115	19177	label = 18446744073709551591LLU; // printnr
19116	19178	break;
19117	19179	}
19118		- case 1238LLU: // return from printnr to procblock
	19180	+ case 1243LLU: // return from printnr to procblock
19119	19181	{
19120	19182	// copy mutable arguments back from call to printnr
19121	19183	printf("%s", "LLU; // consequent complete");

		@@ -19124,7 +19186,7 @@
19124	19186	printf("%s", "\n case ");
19125	19187	// call printnr from procblock
19126	19188	stack[base + 28LLU] = base;
19127		- stack[base + 29LLU] = 1239LLU;
	19189	+ stack[base + 29LLU] = 1244LLU;
19128	19190	// arguments for call to printnr
19129	19191	stack[base + 30LLU] = stack[base + 26]/labelalt/;
19130	19192	// set stack-base & callee-address

		@@ -19132,7 +19194,7 @@
19132	19194	label = 18446744073709551591LLU; // printnr
19133	19195	break;
19134	19196	}
19135		- case 1239LLU: // return from printnr to procblock
	19197	+ case 1244LLU: // return from printnr to procblock
19136	19198	{
19137	19199	// copy mutable arguments back from call to printnr
19138	19200	printf("%s", "LLU: // alternative");

		@@ -19139,7 +19201,7 @@
19139	19201	printf("%s", "\n {");
19140	19202	// call matchid from procblock
19141	19203	stack[base + 28LLU] = base;
19142		- stack[base + 29LLU] = 1240LLU;
	19204	+ stack[base + 29LLU] = 1245LLU;
19143	19205	// arguments for call to matchid
19144	19206	stack[base + 30LLU] = 587642785557905408LLU;
19145	19207	stack[base + 31LLU] = stack[base + 11]/lookahead/;

		@@ -19148,13 +19210,13 @@
19148	19210	label = 39LLU; // matchid
19149	19211	break;
19150	19212	}
19151		- case 1240LLU: // return from matchid to procblock
	19213	+ case 1245LLU: // return from matchid to procblock
19152	19214	{
19153	19215	// copy mutable arguments back from call to matchid
19154	19216	stack[base + 11]/lookahead/ = stack[base + 31LLU];
19155	19217	// call matchsym from procblock
19156	19218	stack[base + 28LLU] = base;
19157		- stack[base + 29LLU] = 1241LLU;
	19219	+ stack[base + 29LLU] = 1246LLU;
19158	19220	// arguments for call to matchsym
19159	19221	stack[base + 30LLU] = 123LLU;
19160	19222	stack[base + 31LLU] = stack[base + 11]/lookahead/;

		@@ -19163,7 +19225,7 @@
19163	19225	label = 27LLU; // matchsym
19164	19226	break;
19165	19227	}
19166		- case 1241LLU: // return from matchsym to procblock
	19228	+ case 1246LLU: // return from matchsym to procblock
19167	19229	{
19168	19230	// copy mutable arguments back from call to matchsym
19169	19231	stack[base + 11]/lookahead/ = stack[base + 31LLU];

		@@ -19172,7 +19234,7 @@
19172	19234	// call procblock from procblock
19173	19235	newstack[0] = (uint64_t)stack; // backup stack location
19174	19236	newstack[1] = base;
19175		- newstack[2] = 1242LLU;
	19237	+ newstack[2] = 1247LLU;
19176	19238	// arguments for call to procblock
19177	19239	newstack[3LLU] = stack[base + 0]/fndefs/;
19178	19240	newstack[4LLU] = stack[base + 1]/typedefs/;

		@@ -19195,7 +19257,7 @@
19195	19257	label = 961LLU; // procblock
19196	19258	break;
19197	19259	}
19198		- case 1242LLU: // return from procblock to procblock
	19260	+ case 1247LLU: // return from procblock to procblock
19199	19261	{
19200	19262	uint64_t oldstack = (uint64_t )stack[0];
19201	19263	// copy mutable arguments back from call to procblock

		@@ -19215,7 +19277,7 @@
19215	19277	printf("%s", "\n label = ");
19216	19278	// call printnr from procblock
19217	19279	stack[base + 28LLU] = base;
19218		- stack[base + 29LLU] = 1243LLU;
	19280	+ stack[base + 29LLU] = 1248LLU;
19219	19281	// arguments for call to printnr
19220	19282	stack[base + 30LLU] = stack[base + 27]/labelskip/;
19221	19283	// set stack-base & callee-address

		@@ -19223,7 +19285,7 @@
19223	19285	label = 18446744073709551591LLU; // printnr
19224	19286	break;
19225	19287	}
19226		- case 1243LLU: // return from printnr to procblock
	19288	+ case 1248LLU: // return from printnr to procblock
19227	19289	{
19228	19290	// copy mutable arguments back from call to printnr
19229	19291	printf("%s", "LLU; // alternative complete");

		@@ -19232,7 +19294,7 @@
19232	19294	printf("%s", "\n case ");
19233	19295	// call printnr from procblock
19234	19296	stack[base + 28LLU] = base;
19235		- stack[base + 29LLU] = 1244LLU;
	19297	+ stack[base + 29LLU] = 1249LLU;
19236	19298	// arguments for call to printnr
19237	19299	stack[base + 30LLU] = stack[base + 27]/labelskip/;
19238	19300	// set stack-base & callee-address

		@@ -19240,36 +19302,36 @@
19240	19302	label = 18446744073709551591LLU; // printnr
19241	19303	break;
19242	19304	}
19243		- case 1244LLU: // return from printnr to procblock
	19305	+ case 1249LLU: // return from printnr to procblock
19244	19306	{
19245	19307	// copy mutable arguments back from call to printnr
19246	19308	printf("%s", "LLU: // completed if-then-else");
19247	19309	printf("%s", "\n {");
19248	19310	((uint64_t *)(stack[base + 23]/type/))[1][0] = stack[base + 25]/subtype*/;
19249		- label = 1184LLU; // consequent complete
	19311	+ label = 1189LLU; // consequent complete
19250	19312	break;
19251	19313	}
19252		- case 1183LLU: // alternative
	19314	+ case 1188LLU: // alternative
19253	19315	{
19254	19316	fprintf(stderr, "%s", "INTERNAL ERROR: unimplemented case in ");
19255	19317	if(!stack[base + 20]/destrflag/)
19256	19318	{
19257		- label = 1245LLU; // jump to alternative
	19319	+ label = 1250LLU; // jump to alternative
19258	19320	break;
19259	19321	}
19260	19322
19261	19323	// consequent
19262	19324	fprintf(stderr, "%s", "destroy type ");
19263		- label = 1246LLU; // consequent complete
	19325	+ label = 1251LLU; // consequent complete
19264	19326	break;
19265	19327	}
19266		- case 1245LLU: // alternative
	19328	+ case 1250LLU: // alternative
19267	19329	{
19268	19330	fprintf(stderr, "%s", "access type ");
19269		- label = 1246LLU; // alternative complete
	19331	+ label = 1251LLU; // alternative complete
19270	19332	break;
19271	19333	}
19272		- case 1246LLU: // completed if-then-else
	19334	+ case 1251LLU: // completed if-then-else
19273	19335	{
19274	19336	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));
19275	19337	newstack[8LLU] = 9876543210LLU; // overflow-marker

		@@ -19276,7 +19338,7 @@
19276	19338	// call reporttype from procblock
19277	19339	newstack[0] = (uint64_t)stack; // backup stack location
19278	19340	newstack[1] = base;
19279		- newstack[2] = 1247LLU;
	19341	+ newstack[2] = 1252LLU;
19280	19342	// arguments for call to reporttype
19281	19343	newstack[3LLU] = stack[base + 23]/type/;
19282	19344	stack = newstack;

		@@ -19285,7 +19347,7 @@
19285	19347	label = 75LLU; // reporttype
19286	19348	break;
19287	19349	}
19288		- case 1247LLU: // return from reporttype to procblock
	19350	+ case 1252LLU: // return from reporttype to procblock
19289	19351	{
19290	19352	uint64_t oldstack = (uint64_t )stack[0];
19291	19353	// copy mutable arguments back from call to reporttype

		@@ -19298,10 +19360,10 @@
19298	19360	stack = oldstack;
19299	19361	fprintf(stderr, "%s", "\n");
19300	19362	exit(-1);
19301		- label = 1184LLU; // alternative complete
	19363	+ label = 1189LLU; // alternative complete
19302	19364	break;
19303	19365	}
19304		- case 1184LLU: // completed if-then-else
	19366	+ case 1189LLU: // completed if-then-else
19305	19367	{
19306	19368	label = 1092LLU; // alternative complete
19307	19369	break;

		@@ -19316,7 +19378,7 @@
19316	19378	fprintf(stderr, "%s", "expected '(' but found token ");
19317	19379	// call reporttok from procblock
19318	19380	stack[base + 21LLU] = base;
19319		- stack[base + 22LLU] = 1248LLU;
	19381	+ stack[base + 22LLU] = 1253LLU;
19320	19382	// arguments for call to reporttok
19321	19383	stack[base + 23LLU] = stack[base + 12]/variant/;
19322	19384	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -19325,7 +19387,7 @@
19325	19387	label = 18446744073709551583LLU; // reporttok
19326	19388	break;
19327	19389	}
19328		- case 1248LLU: // return from reporttok to procblock
	19390	+ case 1253LLU: // return from reporttok to procblock
19329	19391	{
19330	19392	// copy mutable arguments back from call to reporttok
19331	19393	fprintf(stderr, "%s", "\n");

		@@ -19352,7 +19414,7 @@
19352	19414	{
19353	19415	// call equ from procblock
19354	19416	stack[base + 19LLU] = base;
19355		- stack[base + 20LLU] = 1249LLU;
	19417	+ stack[base + 20LLU] = 1254LLU;
19356	19418	// arguments for call to equ
19357	19419	stack[base + 22LLU] = stack[base + 13]/content/;
19358	19420	stack[base + 23LLU] = 910732593752702976LLU;

		@@ -19361,7 +19423,7 @@
19361	19423	label = 18446744073709551600LLU; // equ
19362	19424	break;
19363	19425	}
19364		- case 1249LLU: // return from equ to procblock
	19426	+ case 1254LLU: // return from equ to procblock
19365	19427	{
19366	19428	// copy mutable arguments back from call to equ
19367	19429	// copy back results provided by call to equ

		@@ -19368,7 +19430,7 @@
19368	19430	stack[base + 18] = stack[base + 21LLU];
19369	19431	if(!stack[base + 18]/isequal/)
19370	19432	{
19371		- label = 1250LLU; // jump to alternative
	19433	+ label = 1255LLU; // jump to alternative
19372	19434	break;
19373	19435	}
19374	19436

		@@ -19382,7 +19444,7 @@
19382	19444	stack[base + 3]/scope/ = 0;
19383	19445	// call add from procblock
19384	19446	stack[base + 19LLU] = base;
19385		- stack[base + 20LLU] = 1252LLU;
	19447	+ stack[base + 20LLU] = 1257LLU;
19386	19448	// arguments for call to add
19387	19449	stack[base + 22LLU] = 1LLU;
19388	19450	stack[base + 23LLU] = stack[base + 14]/label/;

		@@ -19391,7 +19453,7 @@
19391	19453	label = 18446744073709551605LLU; // add
19392	19454	break;
19393	19455	}
19394		- case 1252LLU: // return from add to procblock
	19456	+ case 1257LLU: // return from add to procblock
19395	19457	{
19396	19458	// copy mutable arguments back from call to add
19397	19459	// copy back results provided by call to add

		@@ -19401,7 +19463,7 @@
19401	19463	stack[base + 19]/labelloop/ = stack[base + 14]/label/;
19402	19464	// call add from procblock
19403	19465	stack[base + 20LLU] = base;
19404		- stack[base + 21LLU] = 1253LLU;
	19466	+ stack[base + 21LLU] = 1258LLU;
19405	19467	// arguments for call to add
19406	19468	stack[base + 23LLU] = 1LLU;
19407	19469	stack[base + 24LLU] = stack[base + 14]/label/;

		@@ -19410,7 +19472,7 @@
19410	19472	label = 18446744073709551605LLU; // add
19411	19473	break;
19412	19474	}
19413		- case 1253LLU: // return from add to procblock
	19475	+ case 1258LLU: // return from add to procblock
19414	19476	{
19415	19477	// copy mutable arguments back from call to add
19416	19478	// copy back results provided by call to add

		@@ -19420,7 +19482,7 @@
19420	19482	stack[base + 20]/labelskip/ = stack[base + 14]/label/;
19421	19483	// call parsetoken from procblock
19422	19484	stack[base + 21LLU] = base;
19423		- stack[base + 22LLU] = 1254LLU;
	19485	+ stack[base + 22LLU] = 1259LLU;
19424	19486	// arguments for call to parsetoken
19425	19487	stack[base + 26LLU] = stack[base + 11]/lookahead/;
19426	19488	// set stack-base & callee-address

		@@ -19428,7 +19490,7 @@
19428	19490	label = 18446744073709551585LLU; // parsetoken
19429	19491	break;
19430	19492	}
19431		- case 1254LLU: // return from parsetoken to procblock
	19493	+ case 1259LLU: // return from parsetoken to procblock
19432	19494	{
19433	19495	// copy mutable arguments back from call to parsetoken
19434	19496	// copy back results provided by call to parsetoken

		@@ -19437,7 +19499,7 @@
19437	19499	stack[base + 11] = stack[base + 25LLU];
19438	19500	// call equ from procblock
19439	19501	stack[base + 21LLU] = base;
19440		- stack[base + 22LLU] = 1255LLU;
	19502	+ stack[base + 22LLU] = 1260LLU;
19441	19503	// arguments for call to equ
19442	19504	stack[base + 24LLU] = stack[base + 12]/variant/;
19443	19505	stack[base + 25LLU] = 0LLU;

		@@ -19446,7 +19508,7 @@
19446	19508	label = 18446744073709551600LLU; // equ
19447	19509	break;
19448	19510	}
19449		- case 1255LLU: // return from equ to procblock
	19511	+ case 1260LLU: // return from equ to procblock
19450	19512	{
19451	19513	// copy mutable arguments back from call to equ
19452	19514	// copy back results provided by call to equ

		@@ -19453,7 +19515,7 @@
19453	19515	stack[base + 18] = stack[base + 23LLU];
19454	19516	if(!stack[base + 18]/isequal/)
19455	19517	{
19456		- label = 1256LLU; // jump to alternative
	19518	+ label = 1261LLU; // jump to alternative
19457	19519	break;
19458	19520	}
19459	19521

		@@ -19461,7 +19523,7 @@
19461	19523	printf("%s", "\n label = ");
19462	19524	// call printnr from procblock
19463	19525	stack[base + 21LLU] = base;
19464		- stack[base + 22LLU] = 1258LLU;
	19526	+ stack[base + 22LLU] = 1263LLU;
19465	19527	// arguments for call to printnr
19466	19528	stack[base + 23LLU] = stack[base + 19]/labelloop/;
19467	19529	// set stack-base & callee-address

		@@ -19469,7 +19531,7 @@
19469	19531	label = 18446744073709551591LLU; // printnr
19470	19532	break;
19471	19533	}
19472		- case 1258LLU: // return from printnr to procblock
	19534	+ case 1263LLU: // return from printnr to procblock
19473	19535	{
19474	19536	// copy mutable arguments back from call to printnr
19475	19537	printf("%s", "LLU; // start to repeat");

		@@ -19478,7 +19540,7 @@
19478	19540	printf("%s", "\n case ");
19479	19541	// call printnr from procblock
19480	19542	stack[base + 21LLU] = base;
19481		- stack[base + 22LLU] = 1259LLU;
	19543	+ stack[base + 22LLU] = 1264LLU;
19482	19544	// arguments for call to printnr
19483	19545	stack[base + 23LLU] = stack[base + 19]/labelloop/;
19484	19546	// set stack-base & callee-address

		@@ -19486,7 +19548,7 @@
19486	19548	label = 18446744073709551591LLU; // printnr
19487	19549	break;
19488	19550	}
19489		- case 1259LLU: // return from printnr to procblock
	19551	+ case 1264LLU: // return from printnr to procblock
19490	19552	{
19491	19553	// copy mutable arguments back from call to printnr
19492	19554	printf("%s", "LLU: // repeat from here");

		@@ -19493,7 +19555,7 @@
19493	19555	printf("%s", "\n {");
19494	19556	// call equ from procblock
19495	19557	stack[base + 21LLU] = base;
19496		- stack[base + 22LLU] = 1260LLU;
	19558	+ stack[base + 22LLU] = 1265LLU;
19497	19559	// arguments for call to equ
19498	19560	stack[base + 24LLU] = stack[base + 13]/content/;
19499	19561	stack[base + 25LLU] = 40LLU;

		@@ -19502,7 +19564,7 @@
19502	19564	label = 18446744073709551600LLU; // equ
19503	19565	break;
19504	19566	}
19505		- case 1260LLU: // return from equ to procblock
	19567	+ case 1265LLU: // return from equ to procblock
19506	19568	{
19507	19569	// copy mutable arguments back from call to equ
19508	19570	// copy back results provided by call to equ

		@@ -19509,20 +19571,20 @@
19509	19571	stack[base + 18] = stack[base + 23LLU];
19510	19572	if(!stack[base + 18]/isequal/)
19511	19573	{
19512		- label = 1261LLU; // jump to alternative
	19574	+ label = 1266LLU; // jump to alternative
19513	19575	break;
19514	19576	}
19515	19577
19516	19578	// consequent
19517		- label = 1262LLU; // consequent complete
	19579	+ label = 1267LLU; // consequent complete
19518	19580	break;
19519	19581	}
19520		- case 1261LLU: // alternative
	19582	+ case 1266LLU: // alternative
19521	19583	{
19522	19584	fprintf(stderr, "%s", "expected '(' but found token ");
19523	19585	// call reporttok from procblock
19524	19586	stack[base + 21LLU] = base;
19525		- stack[base + 22LLU] = 1263LLU;
	19587	+ stack[base + 22LLU] = 1268LLU;
19526	19588	// arguments for call to reporttok
19527	19589	stack[base + 23LLU] = stack[base + 12]/variant/;
19528	19590	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -19531,15 +19593,15 @@
19531	19593	label = 18446744073709551583LLU; // reporttok
19532	19594	break;
19533	19595	}
19534		- case 1263LLU: // return from reporttok to procblock
	19596	+ case 1268LLU: // return from reporttok to procblock
19535	19597	{
19536	19598	// copy mutable arguments back from call to reporttok
19537	19599	fprintf(stderr, "%s", "\n");
19538	19600	exit(-1);
19539		- label = 1262LLU; // alternative complete
	19601	+ label = 1267LLU; // alternative complete
19540	19602	break;
19541	19603	}
19542		- case 1262LLU: // completed if-then-else
	19604	+ case 1267LLU: // completed if-then-else
19543	19605	{
19544	19606	printf("%s", "\n if(!");
19545	19607	//#define loopid 21

		@@ -19546,7 +19608,7 @@
19546	19608	stack[base + 21/loopid/] = 0; // init
19547	19609	// call parsetoken from procblock
19548	19610	stack[base + 22LLU] = base;
19549		- stack[base + 23LLU] = 1264LLU;
	19611	+ stack[base + 23LLU] = 1269LLU;
19550	19612	// arguments for call to parsetoken
19551	19613	stack[base + 27LLU] = stack[base + 11]/lookahead/;
19552	19614	// set stack-base & callee-address

		@@ -19554,7 +19616,7 @@
19554	19616	label = 18446744073709551585LLU; // parsetoken
19555	19617	break;
19556	19618	}
19557		- case 1264LLU: // return from parsetoken to procblock
	19619	+ case 1269LLU: // return from parsetoken to procblock
19558	19620	{
19559	19621	// copy mutable arguments back from call to parsetoken
19560	19622	// copy back results provided by call to parsetoken

		@@ -19563,7 +19625,7 @@
19563	19625	stack[base + 11] = stack[base + 26LLU];
19564	19626	// call equ from procblock
19565	19627	stack[base + 22LLU] = base;
19566		- stack[base + 23LLU] = 1265LLU;
	19628	+ stack[base + 23LLU] = 1270LLU;
19567	19629	// arguments for call to equ
19568	19630	stack[base + 25LLU] = stack[base + 12]/variant/;
19569	19631	stack[base + 26LLU] = 4LLU;

		@@ -19572,7 +19634,7 @@
19572	19634	label = 18446744073709551600LLU; // equ
19573	19635	break;
19574	19636	}
19575		- case 1265LLU: // return from equ to procblock
	19637	+ case 1270LLU: // return from equ to procblock
19576	19638	{
19577	19639	// copy mutable arguments back from call to equ
19578	19640	// copy back results provided by call to equ

		@@ -19579,7 +19641,7 @@
19579	19641	stack[base + 18] = stack[base + 24LLU];
19580	19642	if(!stack[base + 18]/isequal/)
19581	19643	{
19582		- label = 1266LLU; // jump to alternative
	19644	+ label = 1271LLU; // jump to alternative
19583	19645	break;
19584	19646	}
19585	19647

		@@ -19586,7 +19648,7 @@
19586	19648	// consequent
19587	19649	// call assertUorL from procblock
19588	19650	stack[base + 22LLU] = base;
19589		- stack[base + 23LLU] = 1268LLU;
	19651	+ stack[base + 23LLU] = 1273LLU;
19590	19652	// arguments for call to assertUorL
19591	19653	stack[base + 24LLU] = 910732593752702976LLU;
19592	19654	stack[base + 25LLU] = stack[base + 2]/scopes/;

		@@ -19597,12 +19659,12 @@
19597	19659	label = 793LLU; // assertUorL
19598	19660	break;
19599	19661	}
19600		- case 1268LLU: // return from assertUorL to procblock
	19662	+ case 1273LLU: // return from assertUorL to procblock
19601	19663	{
19602	19664	// copy mutable arguments back from call to assertUorL
19603	19665	// call emitvar from procblock
19604	19666	stack[base + 22LLU] = base;
19605		- stack[base + 23LLU] = 1269LLU;
	19667	+ stack[base + 23LLU] = 1274LLU;
19606	19668	// arguments for call to emitvar
19607	19669	stack[base + 24LLU] = stack[base + 21]/loopid/;
19608	19670	stack[base + 25LLU] = stack[base + 2]/scopes/;

		@@ -19612,18 +19674,18 @@
19612	19674	label = 224LLU; // emitvar
19613	19675	break;
19614	19676	}
19615		- case 1269LLU: // return from emitvar to procblock
	19677	+ case 1274LLU: // return from emitvar to procblock
19616	19678	{
19617	19679	// copy mutable arguments back from call to emitvar
19618		- label = 1267LLU; // consequent complete
	19680	+ label = 1272LLU; // consequent complete
19619	19681	break;
19620	19682	}
19621		- case 1266LLU: // alternative
	19683	+ case 1271LLU: // alternative
19622	19684	{
19623	19685	fprintf(stderr, "%s", "expected identifier in while but found ");
19624	19686	// call reporttok from procblock
19625	19687	stack[base + 22LLU] = base;
19626		- stack[base + 23LLU] = 1270LLU;
	19688	+ stack[base + 23LLU] = 1275LLU;
19627	19689	// arguments for call to reporttok
19628	19690	stack[base + 24LLU] = stack[base + 12]/variant/;
19629	19691	stack[base + 25LLU] = stack[base + 21]/loopid/;

		@@ -19632,19 +19694,19 @@
19632	19694	label = 18446744073709551583LLU; // reporttok
19633	19695	break;
19634	19696	}
19635		- case 1270LLU: // return from reporttok to procblock
	19697	+ case 1275LLU: // return from reporttok to procblock
19636	19698	{
19637	19699	// copy mutable arguments back from call to reporttok
19638	19700	fprintf(stderr, "%s", "\n");
19639	19701	exit(-1);
19640		- label = 1267LLU; // alternative complete
	19702	+ label = 1272LLU; // alternative complete
19641	19703	break;
19642	19704	}
19643		- case 1267LLU: // completed if-then-else
	19705	+ case 1272LLU: // completed if-then-else
19644	19706	{
19645	19707	// call matchsym from procblock
19646	19708	stack[base + 22LLU] = base;
19647		- stack[base + 23LLU] = 1271LLU;
	19709	+ stack[base + 23LLU] = 1276LLU;
19648	19710	// arguments for call to matchsym
19649	19711	stack[base + 24LLU] = 41LLU;
19650	19712	stack[base + 25LLU] = stack[base + 11]/lookahead/;

		@@ -19653,7 +19715,7 @@
19653	19715	label = 27LLU; // matchsym
19654	19716	break;
19655	19717	}
19656		- case 1271LLU: // return from matchsym to procblock
	19718	+ case 1276LLU: // return from matchsym to procblock
19657	19719	{
19658	19720	// copy mutable arguments back from call to matchsym
19659	19721	stack[base + 11]/lookahead/ = stack[base + 25LLU];

		@@ -19660,7 +19722,7 @@
19660	19722	printf("%s", ")");
19661	19723	// call matchsym from procblock
19662	19724	stack[base + 22LLU] = base;
19663		- stack[base + 23LLU] = 1272LLU;
	19725	+ stack[base + 23LLU] = 1277LLU;
19664	19726	// arguments for call to matchsym
19665	19727	stack[base + 24LLU] = 123LLU;
19666	19728	stack[base + 25LLU] = stack[base + 11]/lookahead/;

		@@ -19669,7 +19731,7 @@
19669	19731	label = 27LLU; // matchsym
19670	19732	break;
19671	19733	}
19672		- case 1272LLU: // return from matchsym to procblock
	19734	+ case 1277LLU: // return from matchsym to procblock
19673	19735	{
19674	19736	// copy mutable arguments back from call to matchsym
19675	19737	stack[base + 11]/lookahead/ = stack[base + 25LLU];

		@@ -19677,7 +19739,7 @@
19677	19739	printf("%s", "\n label = ");
19678	19740	// call printnr from procblock
19679	19741	stack[base + 22LLU] = base;
19680		- stack[base + 23LLU] = 1273LLU;
	19742	+ stack[base + 23LLU] = 1278LLU;
19681	19743	// arguments for call to printnr
19682	19744	stack[base + 24LLU] = stack[base + 20]/labelskip/;
19683	19745	// set stack-base & callee-address

		@@ -19685,7 +19747,7 @@
19685	19747	label = 18446744073709551591LLU; // printnr
19686	19748	break;
19687	19749	}
19688		- case 1273LLU: // return from printnr to procblock
	19750	+ case 1278LLU: // return from printnr to procblock
19689	19751	{
19690	19752	// copy mutable arguments back from call to printnr
19691	19753	printf("%s", "LLU; // break loop");

		@@ -19698,7 +19760,7 @@
19698	19760	// call procblock from procblock
19699	19761	newstack[0] = (uint64_t)stack; // backup stack location
19700	19762	newstack[1] = base;
19701		- newstack[2] = 1274LLU;
	19763	+ newstack[2] = 1279LLU;
19702	19764	// arguments for call to procblock
19703	19765	newstack[3LLU] = stack[base + 0]/fndefs/;
19704	19766	newstack[4LLU] = stack[base + 1]/typedefs/;

		@@ -19721,7 +19783,7 @@
19721	19783	label = 961LLU; // procblock
19722	19784	break;
19723	19785	}
19724		- case 1274LLU: // return from procblock to procblock
	19786	+ case 1279LLU: // return from procblock to procblock
19725	19787	{
19726	19788	uint64_t oldstack = (uint64_t )stack[0];
19727	19789	// copy mutable arguments back from call to procblock

		@@ -19738,14 +19800,14 @@
19738	19800	}
19739	19801	Free(119LLU + 1, sizeof(uint64_t), stack);
19740	19802	stack = oldstack;
19741		- label = 1257LLU; // consequent complete
	19803	+ label = 1262LLU; // consequent complete
19742	19804	break;
19743	19805	}
19744		- case 1256LLU: // alternative
	19806	+ case 1261LLU: // alternative
19745	19807	{
19746	19808	// call equ from procblock
19747	19809	stack[base + 21LLU] = base;
19748		- stack[base + 22LLU] = 1275LLU;
	19810	+ stack[base + 22LLU] = 1280LLU;
19749	19811	// arguments for call to equ
19750	19812	stack[base + 24LLU] = stack[base + 13]/content/;
19751	19813	stack[base + 25LLU] = 747825068330975232LLU;

		@@ -19754,7 +19816,7 @@
19754	19816	label = 18446744073709551600LLU; // equ
19755	19817	break;
19756	19818	}
19757		- case 1275LLU: // return from equ to procblock
	19819	+ case 1280LLU: // return from equ to procblock
19758	19820	{
19759	19821	// copy mutable arguments back from call to equ
19760	19822	// copy back results provided by call to equ

		@@ -19761,20 +19823,20 @@
19761	19823	stack[base + 18] = stack[base + 23LLU];
19762	19824	if(!stack[base + 18]/isequal/)
19763	19825	{
19764		- label = 1276LLU; // jump to alternative
	19826	+ label = 1281LLU; // jump to alternative
19765	19827	break;
19766	19828	}
19767	19829
19768	19830	// consequent
19769		- label = 1277LLU; // consequent complete
	19831	+ label = 1282LLU; // consequent complete
19770	19832	break;
19771	19833	}
19772		- case 1276LLU: // alternative
	19834	+ case 1281LLU: // alternative
19773	19835	{
19774	19836	fprintf(stderr, "%s", "expected next but found token ");
19775	19837	// call reporttok from procblock
19776	19838	stack[base + 21LLU] = base;
19777		- stack[base + 22LLU] = 1278LLU;
	19839	+ stack[base + 22LLU] = 1283LLU;
19778	19840	// arguments for call to reporttok
19779	19841	stack[base + 23LLU] = stack[base + 12]/variant/;
19780	19842	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -19783,19 +19845,19 @@
19783	19845	label = 18446744073709551583LLU; // reporttok
19784	19846	break;
19785	19847	}
19786		- case 1278LLU: // return from reporttok to procblock
	19848	+ case 1283LLU: // return from reporttok to procblock
19787	19849	{
19788	19850	// copy mutable arguments back from call to reporttok
19789	19851	fprintf(stderr, "%s", "\n");
19790	19852	exit(-1);
19791		- label = 1277LLU; // alternative complete
	19853	+ label = 1282LLU; // alternative complete
19792	19854	break;
19793	19855	}
19794		- case 1277LLU: // completed if-then-else
	19856	+ case 1282LLU: // completed if-then-else
19795	19857	{
19796	19858	// call matchsym from procblock
19797	19859	stack[base + 21LLU] = base;
19798		- stack[base + 22LLU] = 1279LLU;
	19860	+ stack[base + 22LLU] = 1284LLU;
19799	19861	// arguments for call to matchsym
19800	19862	stack[base + 23LLU] = 40LLU;
19801	19863	stack[base + 24LLU] = stack[base + 11]/lookahead/;

		@@ -19804,7 +19866,7 @@
19804	19866	label = 27LLU; // matchsym
19805	19867	break;
19806	19868	}
19807		- case 1279LLU: // return from matchsym to procblock
	19869	+ case 1284LLU: // return from matchsym to procblock
19808	19870	{
19809	19871	// copy mutable arguments back from call to matchsym
19810	19872	stack[base + 11]/lookahead/ = stack[base + 24LLU];

		@@ -19812,7 +19874,7 @@
19812	19874	stack[base + 21/listid/] = 0; // init
19813	19875	// call parsetoken from procblock
19814	19876	stack[base + 22LLU] = base;
19815		- stack[base + 23LLU] = 1280LLU;
	19877	+ stack[base + 23LLU] = 1285LLU;
19816	19878	// arguments for call to parsetoken
19817	19879	stack[base + 27LLU] = stack[base + 11]/lookahead/;
19818	19880	// set stack-base & callee-address

		@@ -19820,7 +19882,7 @@
19820	19882	label = 18446744073709551585LLU; // parsetoken
19821	19883	break;
19822	19884	}
19823		- case 1280LLU: // return from parsetoken to procblock
	19885	+ case 1285LLU: // return from parsetoken to procblock
19824	19886	{
19825	19887	// copy mutable arguments back from call to parsetoken
19826	19888	// copy back results provided by call to parsetoken

		@@ -19829,7 +19891,7 @@
19829	19891	stack[base + 11] = stack[base + 26LLU];
19830	19892	// call equ from procblock
19831	19893	stack[base + 22LLU] = base;
19832		- stack[base + 23LLU] = 1281LLU;
	19894	+ stack[base + 23LLU] = 1286LLU;
19833	19895	// arguments for call to equ
19834	19896	stack[base + 25LLU] = stack[base + 12]/variant/;
19835	19897	stack[base + 26LLU] = 4LLU;

		@@ -19838,7 +19900,7 @@
19838	19900	label = 18446744073709551600LLU; // equ
19839	19901	break;
19840	19902	}
19841		- case 1281LLU: // return from equ to procblock
	19903	+ case 1286LLU: // return from equ to procblock
19842	19904	{
19843	19905	// copy mutable arguments back from call to equ
19844	19906	// copy back results provided by call to equ

		@@ -19845,20 +19907,20 @@
19845	19907	stack[base + 18] = stack[base + 24LLU];
19846	19908	if(!stack[base + 18]/isequal/)
19847	19909	{
19848		- label = 1282LLU; // jump to alternative
	19910	+ label = 1287LLU; // jump to alternative
19849	19911	break;
19850	19912	}
19851	19913
19852	19914	// consequent
19853		- label = 1283LLU; // consequent complete
	19915	+ label = 1288LLU; // consequent complete
19854	19916	break;
19855	19917	}
19856		- case 1282LLU: // alternative
	19918	+ case 1287LLU: // alternative
19857	19919	{
19858	19920	fprintf(stderr, "%s", "expected identifier in while next but found ");
19859	19921	// call reporttok from procblock
19860	19922	stack[base + 22LLU] = base;
19861		- stack[base + 23LLU] = 1284LLU;
	19923	+ stack[base + 23LLU] = 1289LLU;
19862	19924	// arguments for call to reporttok
19863	19925	stack[base + 24LLU] = stack[base + 12]/variant/;
19864	19926	stack[base + 25LLU] = stack[base + 21]/listid/;

		@@ -19867,15 +19929,15 @@
19867	19929	label = 18446744073709551583LLU; // reporttok
19868	19930	break;
19869	19931	}
19870		- case 1284LLU: // return from reporttok to procblock
	19932	+ case 1289LLU: // return from reporttok to procblock
19871	19933	{
19872	19934	// copy mutable arguments back from call to reporttok
19873	19935	fprintf(stderr, "%s", "\n");
19874	19936	exit(-1);
19875		- label = 1283LLU; // alternative complete
	19937	+ label = 1288LLU; // alternative complete
19876	19938	break;
19877	19939	}
19878		- case 1283LLU: // completed if-then-else
	19940	+ case 1288LLU: // completed if-then-else
19879	19941	{
19880	19942	//#define listtype 22
19881	19943	stack[base + 22/listtype/] = 0; // init

		@@ -19885,7 +19947,7 @@
19885	19947	stack[base + 24/index/] = 0; // init
19886	19948	// call FINDLET from procblock
19887	19949	stack[base + 25LLU] = base;
19888		- stack[base + 26LLU] = 1285LLU;
	19950	+ stack[base + 26LLU] = 1290LLU;
19889	19951	// arguments for call to FINDLET
19890	19952	stack[base + 30LLU] = stack[base + 21]/listid/;
19891	19953	stack[base + 31LLU] = stack[base + 2]/scopes/;

		@@ -19895,7 +19957,7 @@
19895	19957	label = 186LLU; // FINDLET
19896	19958	break;
19897	19959	}
19898		- case 1285LLU: // return from FINDLET to procblock
	19960	+ case 1290LLU: // return from FINDLET to procblock
19899	19961	{
19900	19962	// copy mutable arguments back from call to FINDLET
19901	19963	// copy back results provided by call to FINDLET

		@@ -19905,7 +19967,7 @@
19905	19967	printf("%s", "\n assign(");
19906	19968	// call emitvar from procblock
19907	19969	stack[base + 24LLU] = base;
19908		- stack[base + 25LLU] = 1286LLU;
	19970	+ stack[base + 25LLU] = 1291LLU;
19909	19971	// arguments for call to emitvar
19910	19972	stack[base + 26LLU] = stack[base + 21]/listid/;
19911	19973	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -19915,7 +19977,7 @@
19915	19977	label = 224LLU; // emitvar
19916	19978	break;
19917	19979	}
19918		- case 1286LLU: // return from emitvar to procblock
	19980	+ case 1291LLU: // return from emitvar to procblock
19919	19981	{
19920	19982	// copy mutable arguments back from call to emitvar
19921	19983	printf("%s", ", &");

		@@ -19926,7 +19988,7 @@
19926	19988	// call copytype from procblock
19927	19989	newstack[0] = (uint64_t)stack; // backup stack location
19928	19990	newstack[1] = base;
19929		- newstack[2] = 1287LLU;
	19991	+ newstack[2] = 1292LLU;
19930	19992	// arguments for call to copytype
19931	19993	newstack[4LLU] = stack[base + 22]/listtype/;
19932	19994	stack = newstack;

		@@ -19935,7 +19997,7 @@
19935	19997	label = 82LLU; // copytype
19936	19998	break;
19937	19999	}
19938		- case 1287LLU: // return from copytype to procblock
	20000	+ case 1292LLU: // return from copytype to procblock
19939	20001	{
19940	20002	uint64_t oldstack = (uint64_t )stack[0];
19941	20003	// copy mutable arguments back from call to copytype

		@@ -19950,7 +20012,7 @@
19950	20012	stack = oldstack;
19951	20013	// call newvarraw from procblock
19952	20014	stack[base + 25LLU] = base;
19953		- stack[base + 26LLU] = 1288LLU;
	20015	+ stack[base + 26LLU] = 1293LLU;
19954	20016	// arguments for call to newvarraw
19955	20017	stack[base + 27LLU] = stack[base + 24]/copy/;
19956	20018	stack[base + 28LLU] = stack[base + 21]/listid/;

		@@ -19965,7 +20027,7 @@
19965	20027	label = 228LLU; // newvarraw
19966	20028	break;
19967	20029	}
19968		- case 1288LLU: // return from newvarraw to procblock
	20030	+ case 1293LLU: // return from newvarraw to procblock
19969	20031	{
19970	20032	// copy mutable arguments back from call to newvarraw
19971	20033	stack[base + 3]/scope/ = stack[base + 34LLU];

		@@ -19973,7 +20035,7 @@
19973	20035	stack[base + 9]/fnmaxcount/ = stack[base + 32LLU];
19974	20036	// call emitvar from procblock
19975	20037	stack[base + 24LLU] = base;
19976		- stack[base + 25LLU] = 1289LLU;
	20038	+ stack[base + 25LLU] = 1294LLU;
19977	20039	// arguments for call to emitvar
19978	20040	stack[base + 26LLU] = stack[base + 21]/listid/;
19979	20041	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -19983,7 +20045,7 @@
19983	20045	label = 224LLU; // emitvar
19984	20046	break;
19985	20047	}
19986		- case 1289LLU: // return from emitvar to procblock
	20048	+ case 1294LLU: // return from emitvar to procblock
19987	20049	{
19988	20050	// copy mutable arguments back from call to emitvar
19989	20051	printf("%s", ");");

		@@ -19990,7 +20052,7 @@
19990	20052	printf("%s", "\n label = ");
19991	20053	// call printnr from procblock
19992	20054	stack[base + 24LLU] = base;
19993		- stack[base + 25LLU] = 1290LLU;
	20055	+ stack[base + 25LLU] = 1295LLU;
19994	20056	// arguments for call to printnr
19995	20057	stack[base + 26LLU] = stack[base + 19]/labelloop/;
19996	20058	// set stack-base & callee-address

		@@ -19998,7 +20060,7 @@
19998	20060	label = 18446744073709551591LLU; // printnr
19999	20061	break;
20000	20062	}
20001		- case 1290LLU: // return from printnr to procblock
	20063	+ case 1295LLU: // return from printnr to procblock
20002	20064	{
20003	20065	// copy mutable arguments back from call to printnr
20004	20066	printf("%s", "LLU; // start to repeat");

		@@ -20007,7 +20069,7 @@
20007	20069	printf("%s", "\n case ");
20008	20070	// call printnr from procblock
20009	20071	stack[base + 24LLU] = base;
20010		- stack[base + 25LLU] = 1291LLU;
	20072	+ stack[base + 25LLU] = 1296LLU;
20011	20073	// arguments for call to printnr
20012	20074	stack[base + 26LLU] = stack[base + 19]/labelloop/;
20013	20075	// set stack-base & callee-address

		@@ -20015,7 +20077,7 @@
20015	20077	label = 18446744073709551591LLU; // printnr
20016	20078	break;
20017	20079	}
20018		- case 1291LLU: // return from printnr to procblock
	20080	+ case 1296LLU: // return from printnr to procblock
20019	20081	{
20020	20082	// copy mutable arguments back from call to printnr
20021	20083	printf("%s", "LLU: // repeat from here");

		@@ -20023,7 +20085,7 @@
20023	20085	printf("%s", "\n if(!");
20024	20086	// call emitvar from procblock
20025	20087	stack[base + 24LLU] = base;
20026		- stack[base + 25LLU] = 1292LLU;
	20088	+ stack[base + 25LLU] = 1297LLU;
20027	20089	// arguments for call to emitvar
20028	20090	stack[base + 26LLU] = stack[base + 21]/listid/;
20029	20091	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -20033,12 +20095,12 @@
20033	20095	label = 224LLU; // emitvar
20034	20096	break;
20035	20097	}
20036		- case 1292LLU: // return from emitvar to procblock
	20098	+ case 1297LLU: // return from emitvar to procblock
20037	20099	{
20038	20100	// copy mutable arguments back from call to emitvar
20039	20101	// call matchsym from procblock
20040	20102	stack[base + 24LLU] = base;
20041		- stack[base + 25LLU] = 1293LLU;
	20103	+ stack[base + 25LLU] = 1298LLU;
20042	20104	// arguments for call to matchsym
20043	20105	stack[base + 26LLU] = 41LLU;
20044	20106	stack[base + 27LLU] = stack[base + 11]/lookahead/;

		@@ -20047,13 +20109,13 @@
20047	20109	label = 27LLU; // matchsym
20048	20110	break;
20049	20111	}
20050		- case 1293LLU: // return from matchsym to procblock
	20112	+ case 1298LLU: // return from matchsym to procblock
20051	20113	{
20052	20114	// copy mutable arguments back from call to matchsym
20053	20115	stack[base + 11]/lookahead/ = stack[base + 27LLU];
20054	20116	// call matchsym from procblock
20055	20117	stack[base + 24LLU] = base;
20056		- stack[base + 25LLU] = 1294LLU;
	20118	+ stack[base + 25LLU] = 1299LLU;
20057	20119	// arguments for call to matchsym
20058	20120	stack[base + 26LLU] = 45LLU;
20059	20121	stack[base + 27LLU] = stack[base + 11]/lookahead/;

		@@ -20062,13 +20124,13 @@
20062	20124	label = 27LLU; // matchsym
20063	20125	break;
20064	20126	}
20065		- case 1294LLU: // return from matchsym to procblock
	20127	+ case 1299LLU: // return from matchsym to procblock
20066	20128	{
20067	20129	// copy mutable arguments back from call to matchsym
20068	20130	stack[base + 11]/lookahead/ = stack[base + 27LLU];
20069	20131	// call matchsym from procblock
20070	20132	stack[base + 24LLU] = base;
20071		- stack[base + 25LLU] = 1295LLU;
	20133	+ stack[base + 25LLU] = 1300LLU;
20072	20134	// arguments for call to matchsym
20073	20135	stack[base + 26LLU] = 62LLU;
20074	20136	stack[base + 27LLU] = stack[base + 11]/lookahead/;

		@@ -20077,13 +20139,13 @@
20077	20139	label = 27LLU; // matchsym
20078	20140	break;
20079	20141	}
20080		- case 1295LLU: // return from matchsym to procblock
	20142	+ case 1300LLU: // return from matchsym to procblock
20081	20143	{
20082	20144	// copy mutable arguments back from call to matchsym
20083	20145	stack[base + 11]/lookahead/ = stack[base + 27LLU];
20084	20146	// call matchsym from procblock
20085	20147	stack[base + 24LLU] = base;
20086		- stack[base + 25LLU] = 1296LLU;
	20148	+ stack[base + 25LLU] = 1301LLU;
20087	20149	// arguments for call to matchsym
20088	20150	stack[base + 26LLU] = 40LLU;
20089	20151	stack[base + 27LLU] = stack[base + 11]/lookahead/;

		@@ -20092,7 +20154,7 @@
20092	20154	label = 27LLU; // matchsym
20093	20155	break;
20094	20156	}
20095		- case 1296LLU: // return from matchsym to procblock
	20157	+ case 1301LLU: // return from matchsym to procblock
20096	20158	{
20097	20159	// copy mutable arguments back from call to matchsym
20098	20160	stack[base + 11]/lookahead/ = stack[base + 27LLU];

		@@ -20100,7 +20162,7 @@
20100	20162	stack[base + 24/elemid/] = 0; // init
20101	20163	// call parsetoken from procblock
20102	20164	stack[base + 25LLU] = base;
20103		- stack[base + 26LLU] = 1297LLU;
	20165	+ stack[base + 26LLU] = 1302LLU;
20104	20166	// arguments for call to parsetoken
20105	20167	stack[base + 30LLU] = stack[base + 11]/lookahead/;
20106	20168	// set stack-base & callee-address

		@@ -20108,7 +20170,7 @@
20108	20170	label = 18446744073709551585LLU; // parsetoken
20109	20171	break;
20110	20172	}
20111		- case 1297LLU: // return from parsetoken to procblock
	20173	+ case 1302LLU: // return from parsetoken to procblock
20112	20174	{
20113	20175	// copy mutable arguments back from call to parsetoken
20114	20176	// copy back results provided by call to parsetoken

		@@ -20117,7 +20179,7 @@
20117	20179	stack[base + 11] = stack[base + 29LLU];
20118	20180	// call equ from procblock
20119	20181	stack[base + 25LLU] = base;
20120		- stack[base + 26LLU] = 1298LLU;
	20182	+ stack[base + 26LLU] = 1303LLU;
20121	20183	// arguments for call to equ
20122	20184	stack[base + 28LLU] = stack[base + 12]/variant/;
20123	20185	stack[base + 29LLU] = 4LLU;

		@@ -20126,7 +20188,7 @@
20126	20188	label = 18446744073709551600LLU; // equ
20127	20189	break;
20128	20190	}
20129		- case 1298LLU: // return from equ to procblock
	20191	+ case 1303LLU: // return from equ to procblock
20130	20192	{
20131	20193	// copy mutable arguments back from call to equ
20132	20194	// copy back results provided by call to equ

		@@ -20133,20 +20195,20 @@
20133	20195	stack[base + 18] = stack[base + 27LLU];
20134	20196	if(!stack[base + 18]/isequal/)
20135	20197	{
20136		- label = 1299LLU; // jump to alternative
	20198	+ label = 1304LLU; // jump to alternative
20137	20199	break;
20138	20200	}
20139	20201
20140	20202	// consequent
20141		- label = 1300LLU; // consequent complete
	20203	+ label = 1305LLU; // consequent complete
20142	20204	break;
20143	20205	}
20144		- case 1299LLU: // alternative
	20206	+ case 1304LLU: // alternative
20145	20207	{
20146	20208	fprintf(stderr, "%s", "expected identifier in while next but found ");
20147	20209	// call reporttok from procblock
20148	20210	stack[base + 25LLU] = base;
20149		- stack[base + 26LLU] = 1301LLU;
	20211	+ stack[base + 26LLU] = 1306LLU;
20150	20212	// arguments for call to reporttok
20151	20213	stack[base + 27LLU] = stack[base + 12]/variant/;
20152	20214	stack[base + 28LLU] = stack[base + 24]/elemid/;

		@@ -20155,15 +20217,15 @@
20155	20217	label = 18446744073709551583LLU; // reporttok
20156	20218	break;
20157	20219	}
20158		- case 1301LLU: // return from reporttok to procblock
	20220	+ case 1306LLU: // return from reporttok to procblock
20159	20221	{
20160	20222	// copy mutable arguments back from call to reporttok
20161	20223	fprintf(stderr, "%s", "\n");
20162	20224	exit(-1);
20163		- label = 1300LLU; // alternative complete
	20225	+ label = 1305LLU; // alternative complete
20164	20226	break;
20165	20227	}
20166		- case 1300LLU: // completed if-then-else
	20228	+ case 1305LLU: // completed if-then-else
20167	20229	{
20168	20230	printf("%s", ")");
20169	20231	printf("%s", "\n {");

		@@ -20170,7 +20232,7 @@
20170	20232	printf("%s", "\n label = ");
20171	20233	// call printnr from procblock
20172	20234	stack[base + 25LLU] = base;
20173		- stack[base + 26LLU] = 1302LLU;
	20235	+ stack[base + 26LLU] = 1307LLU;
20174	20236	// arguments for call to printnr
20175	20237	stack[base + 27LLU] = stack[base + 20]/labelskip/;
20176	20238	// set stack-base & callee-address

		@@ -20178,7 +20240,7 @@
20178	20240	label = 18446744073709551591LLU; // printnr
20179	20241	break;
20180	20242	}
20181		- case 1302LLU: // return from printnr to procblock
	20243	+ case 1307LLU: // return from printnr to procblock
20182	20244	{
20183	20245	// copy mutable arguments back from call to printnr
20184	20246	printf("%s", "LLU; // break loop");

		@@ -20188,7 +20250,7 @@
20188	20250	printf("%s", "\n // loop body");
20189	20251	if(/typelist/1 != ((uint64_t )(stack[base + 22]/listtype*/))[0])
20190	20252	{
20191		- label = 1303LLU; // jump to alternative
	20253	+ label = 1308LLU; // jump to alternative
20192	20254	break;
20193	20255	}
20194	20256

		@@ -20203,7 +20265,7 @@
20203	20265	// call copytype from procblock
20204	20266	newstack[0] = (uint64_t)stack; // backup stack location
20205	20267	newstack[1] = base;
20206		- newstack[2] = 1305LLU;
	20268	+ newstack[2] = 1310LLU;
20207	20269	// arguments for call to copytype
20208	20270	newstack[4LLU] = stack[base + 25]/subtype/;
20209	20271	stack = newstack;

		@@ -20212,7 +20274,7 @@
20212	20274	label = 82LLU; // copytype
20213	20275	break;
20214	20276	}
20215		- case 1305LLU: // return from copytype to procblock
	20277	+ case 1310LLU: // return from copytype to procblock
20216	20278	{
20217	20279	uint64_t oldstack = (uint64_t )stack[0];
20218	20280	// copy mutable arguments back from call to copytype

		@@ -20227,7 +20289,7 @@
20227	20289	stack = oldstack;
20228	20290	// call newvar from procblock
20229	20291	stack[base + 27LLU] = base;
20230		- stack[base + 28LLU] = 1306LLU;
	20292	+ stack[base + 28LLU] = 1311LLU;
20231	20293	// arguments for call to newvar
20232	20294	stack[base + 29LLU] = stack[base + 26]/copy/;
20233	20295	stack[base + 30LLU] = stack[base + 24]/elemid/;

		@@ -20242,7 +20304,7 @@
20242	20304	label = 235LLU; // newvar
20243	20305	break;
20244	20306	}
20245		- case 1306LLU: // return from newvar to procblock
	20307	+ case 1311LLU: // return from newvar to procblock
20246	20308	{
20247	20309	// copy mutable arguments back from call to newvar
20248	20310	stack[base + 3]/scope/ = stack[base + 36LLU];

		@@ -20251,7 +20313,7 @@
20251	20313	printf("%s", "\n ");
20252	20314	// call emitvar from procblock
20253	20315	stack[base + 26LLU] = base;
20254		- stack[base + 27LLU] = 1307LLU;
	20316	+ stack[base + 27LLU] = 1312LLU;
20255	20317	// arguments for call to emitvar
20256	20318	stack[base + 28LLU] = stack[base + 24]/elemid/;
20257	20319	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20261,13 +20323,13 @@
20261	20323	label = 224LLU; // emitvar
20262	20324	break;
20263	20325	}
20264		- case 1307LLU: // return from emitvar to procblock
	20326	+ case 1312LLU: // return from emitvar to procblock
20265	20327	{
20266	20328	// copy mutable arguments back from call to emitvar
20267	20329	printf("%s", " = (uint64_t)(((const struct listnode *)(");
20268	20330	// call emitvar from procblock
20269	20331	stack[base + 26LLU] = base;
20270		- stack[base + 27LLU] = 1308LLU;
	20332	+ stack[base + 27LLU] = 1313LLU;
20271	20333	// arguments for call to emitvar
20272	20334	stack[base + 28LLU] = stack[base + 21]/listid/;
20273	20335	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20277,15 +20339,15 @@
20277	20339	label = 224LLU; // emitvar
20278	20340	break;
20279	20341	}
20280		- case 1308LLU: // return from emitvar to procblock
	20342	+ case 1313LLU: // return from emitvar to procblock
20281	20343	{
20282	20344	// copy mutable arguments back from call to emitvar
20283	20345	printf("%s", "))->data);");
20284	20346	((uint64_t *)(stack[base + 22]/listtype/))[1][0] = stack[base + 25]/subtype*/;
20285		- label = 1304LLU; // consequent complete
	20347	+ label = 1309LLU; // consequent complete
20286	20348	break;
20287	20349	}
20288		- case 1303LLU: // alternative
	20350	+ case 1308LLU: // alternative
20289	20351	{
20290	20352	fprintf(stderr, "%s", "can only iterate over list but found type ");
20291	20353	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -20293,7 +20355,7 @@
20293	20355	// call reporttype from procblock
20294	20356	newstack[0] = (uint64_t)stack; // backup stack location
20295	20357	newstack[1] = base;
20296		- newstack[2] = 1309LLU;
	20358	+ newstack[2] = 1314LLU;
20297	20359	// arguments for call to reporttype
20298	20360	newstack[3LLU] = stack[base + 22]/listtype/;
20299	20361	stack = newstack;

		@@ -20302,7 +20364,7 @@
20302	20364	label = 75LLU; // reporttype
20303	20365	break;
20304	20366	}
20305		- case 1309LLU: // return from reporttype to procblock
	20367	+ case 1314LLU: // return from reporttype to procblock
20306	20368	{
20307	20369	uint64_t oldstack = (uint64_t )stack[0];
20308	20370	// copy mutable arguments back from call to reporttype

		@@ -20315,10 +20377,10 @@
20315	20377	stack = oldstack;
20316	20378	fprintf(stderr, "%s", "\n");
20317	20379	exit(-1);
20318		- label = 1304LLU; // alternative complete
	20380	+ label = 1309LLU; // alternative complete
20319	20381	break;
20320	20382	}
20321		- case 1304LLU: // completed if-then-else
	20383	+ case 1309LLU: // completed if-then-else
20322	20384	{
20323	20385	//#define previdx 25
20324	20386	stack[base + 25/previdx/] = 0; // init

		@@ -20329,7 +20391,7 @@
20329	20391	// call copytype from procblock
20330	20392	newstack[0] = (uint64_t)stack; // backup stack location
20331	20393	newstack[1] = base;
20332		- newstack[2] = 1310LLU;
	20394	+ newstack[2] = 1315LLU;
20333	20395	// arguments for call to copytype
20334	20396	newstack[4LLU] = stack[base + 22]/listtype/;
20335	20397	stack = newstack;

		@@ -20338,7 +20400,7 @@
20338	20400	label = 82LLU; // copytype
20339	20401	break;
20340	20402	}
20341		- case 1310LLU: // return from copytype to procblock
	20403	+ case 1315LLU: // return from copytype to procblock
20342	20404	{
20343	20405	uint64_t oldstack = (uint64_t )stack[0];
20344	20406	// copy mutable arguments back from call to copytype

		@@ -20353,7 +20415,7 @@
20353	20415	stack = oldstack;
20354	20416	// call newvar from procblock
20355	20417	stack[base + 27LLU] = base;
20356		- stack[base + 28LLU] = 1311LLU;
	20418	+ stack[base + 28LLU] = 1316LLU;
20357	20419	// arguments for call to newvar
20358	20420	stack[base + 29LLU] = stack[base + 26]/copy/;
20359	20421	stack[base + 30LLU] = 0LLU;

		@@ -20368,7 +20430,7 @@
20368	20430	label = 235LLU; // newvar
20369	20431	break;
20370	20432	}
20371		- case 1311LLU: // return from newvar to procblock
	20433	+ case 1316LLU: // return from newvar to procblock
20372	20434	{
20373	20435	// copy mutable arguments back from call to newvar
20374	20436	stack[base + 3]/scope/ = stack[base + 36LLU];

		@@ -20378,7 +20440,7 @@
20378	20440	stack[base + 27/type/] = 0; // init
20379	20441	// call findlet from procblock
20380	20442	stack[base + 28LLU] = base;
20381		- stack[base + 29LLU] = 1312LLU;
	20443	+ stack[base + 29LLU] = 1317LLU;
20382	20444	// arguments for call to findlet
20383	20445	stack[base + 32LLU] = 0LLU;
20384	20446	stack[base + 33LLU] = stack[base + 2]/scopes/;

		@@ -20388,7 +20450,7 @@
20388	20450	label = 213LLU; // findlet
20389	20451	break;
20390	20452	}
20391		- case 1312LLU: // return from findlet to procblock
	20453	+ case 1317LLU: // return from findlet to procblock
20392	20454	{
20393	20455	// copy mutable arguments back from call to findlet
20394	20456	// copy back results provided by call to findlet

		@@ -20397,7 +20459,7 @@
20397	20459	printf("%s", "\n stack[base + ");
20398	20460	// call printnr from procblock
20399	20461	stack[base + 26LLU] = base;
20400		- stack[base + 27LLU] = 1313LLU;
	20462	+ stack[base + 27LLU] = 1318LLU;
20401	20463	// arguments for call to printnr
20402	20464	stack[base + 28LLU] = stack[base + 25]/previdx/;
20403	20465	// set stack-base & callee-address

		@@ -20405,13 +20467,13 @@
20405	20467	label = 18446744073709551591LLU; // printnr
20406	20468	break;
20407	20469	}
20408		- case 1313LLU: // return from printnr to procblock
	20470	+ case 1318LLU: // return from printnr to procblock
20409	20471	{
20410	20472	// copy mutable arguments back from call to printnr
20411	20473	printf("%s", "/previous/] = ");
20412	20474	// call emitvar from procblock
20413	20475	stack[base + 26LLU] = base;
20414		- stack[base + 27LLU] = 1314LLU;
	20476	+ stack[base + 27LLU] = 1319LLU;
20415	20477	// arguments for call to emitvar
20416	20478	stack[base + 28LLU] = stack[base + 21]/listid/;
20417	20479	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20421,7 +20483,7 @@
20421	20483	label = 224LLU; // emitvar
20422	20484	break;
20423	20485	}
20424		- case 1314LLU: // return from emitvar to procblock
	20486	+ case 1319LLU: // return from emitvar to procblock
20425	20487	{
20426	20488	// copy mutable arguments back from call to emitvar
20427	20489	printf("%s", ";");

		@@ -20428,7 +20490,7 @@
20428	20490	printf("%s", "\n ");
20429	20491	// call emitvar from procblock
20430	20492	stack[base + 26LLU] = base;
20431		- stack[base + 27LLU] = 1315LLU;
	20493	+ stack[base + 27LLU] = 1320LLU;
20432	20494	// arguments for call to emitvar
20433	20495	stack[base + 28LLU] = stack[base + 21]/listid/;
20434	20496	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20438,13 +20500,13 @@
20438	20500	label = 224LLU; // emitvar
20439	20501	break;
20440	20502	}
20441		- case 1315LLU: // return from emitvar to procblock
	20503	+ case 1320LLU: // return from emitvar to procblock
20442	20504	{
20443	20505	// copy mutable arguments back from call to emitvar
20444	20506	printf("%s", " = (uint64_t)(((const struct listnode *)(");
20445	20507	// call emitvar from procblock
20446	20508	stack[base + 26LLU] = base;
20447		- stack[base + 27LLU] = 1316LLU;
	20509	+ stack[base + 27LLU] = 1321LLU;
20448	20510	// arguments for call to emitvar
20449	20511	stack[base + 28LLU] = stack[base + 21]/listid/;
20450	20512	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20454,13 +20516,13 @@
20454	20516	label = 224LLU; // emitvar
20455	20517	break;
20456	20518	}
20457		- case 1316LLU: // return from emitvar to procblock
	20519	+ case 1321LLU: // return from emitvar to procblock
20458	20520	{
20459	20521	// copy mutable arguments back from call to emitvar
20460	20522	printf("%s", "))->next);");
20461	20523	// call matchsym from procblock
20462	20524	stack[base + 26LLU] = base;
20463		- stack[base + 27LLU] = 1317LLU;
	20525	+ stack[base + 27LLU] = 1322LLU;
20464	20526	// arguments for call to matchsym
20465	20527	stack[base + 28LLU] = 41LLU;
20466	20528	stack[base + 29LLU] = stack[base + 11]/lookahead/;

		@@ -20469,13 +20531,13 @@
20469	20531	label = 27LLU; // matchsym
20470	20532	break;
20471	20533	}
20472		- case 1317LLU: // return from matchsym to procblock
	20534	+ case 1322LLU: // return from matchsym to procblock
20473	20535	{
20474	20536	// copy mutable arguments back from call to matchsym
20475	20537	stack[base + 11]/lookahead/ = stack[base + 29LLU];
20476	20538	// call matchsym from procblock
20477	20539	stack[base + 26LLU] = base;
20478		- stack[base + 27LLU] = 1318LLU;
	20540	+ stack[base + 27LLU] = 1323LLU;
20479	20541	// arguments for call to matchsym
20480	20542	stack[base + 28LLU] = 123LLU;
20481	20543	stack[base + 29LLU] = stack[base + 11]/lookahead/;

		@@ -20484,7 +20546,7 @@
20484	20546	label = 27LLU; // matchsym
20485	20547	break;
20486	20548	}
20487		- case 1318LLU: // return from matchsym to procblock
	20549	+ case 1323LLU: // return from matchsym to procblock
20488	20550	{
20489	20551	// copy mutable arguments back from call to matchsym
20490	20552	stack[base + 11]/lookahead/ = stack[base + 29LLU];

		@@ -20493,7 +20555,7 @@
20493	20555	// call procblock from procblock
20494	20556	newstack[0] = (uint64_t)stack; // backup stack location
20495	20557	newstack[1] = base;
20496		- newstack[2] = 1319LLU;
	20558	+ newstack[2] = 1324LLU;
20497	20559	// arguments for call to procblock
20498	20560	newstack[3LLU] = stack[base + 0]/fndefs/;
20499	20561	newstack[4LLU] = stack[base + 1]/typedefs/;

		@@ -20516,7 +20578,7 @@
20516	20578	label = 961LLU; // procblock
20517	20579	break;
20518	20580	}
20519		- case 1319LLU: // return from procblock to procblock
	20581	+ case 1324LLU: // return from procblock to procblock
20520	20582	{
20521	20583	uint64_t oldstack = (uint64_t )stack[0];
20522	20584	// copy mutable arguments back from call to procblock

		@@ -20536,7 +20598,7 @@
20536	20598	printf("%s", "\n ((struct listnode *)(stack[base + ");
20537	20599	// call printnr from procblock
20538	20600	stack[base + 26LLU] = base;
20539		- stack[base + 27LLU] = 1320LLU;
	20601	+ stack[base + 27LLU] = 1325LLU;
20540	20602	// arguments for call to printnr
20541	20603	stack[base + 28LLU] = stack[base + 25]/previdx/;
20542	20604	// set stack-base & callee-address

		@@ -20544,13 +20606,13 @@
20544	20606	label = 18446744073709551591LLU; // printnr
20545	20607	break;
20546	20608	}
20547		- case 1320LLU: // return from printnr to procblock
	20609	+ case 1325LLU: // return from printnr to procblock
20548	20610	{
20549	20611	// copy mutable arguments back from call to printnr
20550	20612	printf("%s", "/previous/]))->data = ");
20551	20613	// call emitvar from procblock
20552	20614	stack[base + 26LLU] = base;
20553		- stack[base + 27LLU] = 1321LLU;
	20615	+ stack[base + 27LLU] = 1326LLU;
20554	20616	// arguments for call to emitvar
20555	20617	stack[base + 28LLU] = stack[base + 24]/elemid/;
20556	20618	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -20560,23 +20622,23 @@
20560	20622	label = 224LLU; // emitvar
20561	20623	break;
20562	20624	}
20563		- case 1321LLU: // return from emitvar to procblock
	20625	+ case 1326LLU: // return from emitvar to procblock
20564	20626	{
20565	20627	// copy mutable arguments back from call to emitvar
20566	20628	printf("%s", ";");
20567		- label = 1257LLU; // alternative complete
	20629	+ label = 1262LLU; // alternative complete
20568	20630	break;
20569	20631	}
20570		- case 1257LLU: // completed if-then-else
	20632	+ case 1262LLU: // completed if-then-else
20571	20633	{
20572		- label = 1322LLU; // start to repeat
	20634	+ label = 1327LLU; // start to repeat
20573	20635	break;
20574	20636	}
20575		- case 1322LLU: // repeat from here
	20637	+ case 1327LLU: // repeat from here
20576	20638	{
20577	20639	if(!stack[base + 3]/scope/)
20578	20640	{
20579		- label = 1323LLU; // break loop
	20641	+ label = 1328LLU; // break loop
20580	20642	break;
20581	20643	}
20582	20644

		@@ -20587,7 +20649,7 @@
20587	20649	struct listnode list = (struct listnode )stack[base + 3]/scope/;
20588	20650	if(!list)
20589	20651	{
20590		- label = 1324LLU; // jump to alternative
	20652	+ label = 1329LLU; // jump to alternative
20591	20653	break;
20592	20654	}
20593	20655

		@@ -20599,7 +20661,7 @@
20599	20661	}
20600	20662	// call dellet from procblock
20601	20663	stack[base + 22LLU] = base;
20602		- stack[base + 23LLU] = 1326LLU;
	20664	+ stack[base + 23LLU] = 1331LLU;
20603	20665	// arguments for call to dellet
20604	20666	stack[base + 24LLU] = stack[base + 21]/current/;
20605	20667	// set stack-base & callee-address

		@@ -20607,31 +20669,31 @@
20607	20669	label = 166LLU; // dellet
20608	20670	break;
20609	20671	}
20610		- case 1326LLU: // return from dellet to procblock
	20672	+ case 1331LLU: // return from dellet to procblock
20611	20673	{
20612	20674	// copy mutable arguments back from call to dellet
20613		- label = 1325LLU; // consequent complete
	20675	+ label = 1330LLU; // consequent complete
20614	20676	break;
20615	20677	}
20616		- case 1324LLU: // alternative
	20678	+ case 1329LLU: // alternative
20617	20679	{
20618	20680	fprintf(stderr, "%s", "internal error releasing loop-references\n");
20619	20681	exit(-1);
20620		- label = 1325LLU; // alternative complete
	20682	+ label = 1330LLU; // alternative complete
20621	20683	break;
20622	20684	}
20623		- case 1325LLU: // completed if-then-else
	20685	+ case 1330LLU: // completed if-then-else
20624	20686	{
20625		- label = 1322LLU; // repeat
	20687	+ label = 1327LLU; // repeat
20626	20688	break;
20627	20689	}
20628		- case 1323LLU: // loop finished
	20690	+ case 1328LLU: // loop finished
20629	20691	{
20630	20692	{ // if pop
20631	20693	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
20632	20694	if(!list)
20633	20695	{
20634		- label = 1327LLU; // jump to alternative
	20696	+ label = 1332LLU; // jump to alternative
20635	20697	break;
20636	20698	}
20637	20699

		@@ -20641,22 +20703,22 @@
20641	20703	Free(1, sizeof(struct listnode), list);
20642	20704	stack[base + 2]/scopes/ = (uint64_t)next;
20643	20705	}
20644		- label = 1328LLU; // consequent complete
	20706	+ label = 1333LLU; // consequent complete
20645	20707	break;
20646	20708	}
20647		- case 1327LLU: // alternative
	20709	+ case 1332LLU: // alternative
20648	20710	{
20649	20711	fprintf(stderr, "%s", "internal error poping scope in block/while\n");
20650	20712	exit(-1);
20651		- label = 1328LLU; // alternative complete
	20713	+ label = 1333LLU; // alternative complete
20652	20714	break;
20653	20715	}
20654		- case 1328LLU: // completed if-then-else
	20716	+ case 1333LLU: // completed if-then-else
20655	20717	{
20656	20718	printf("%s", "\n label = ");
20657	20719	// call printnr from procblock
20658	20720	stack[base + 21LLU] = base;
20659		- stack[base + 22LLU] = 1329LLU;
	20721	+ stack[base + 22LLU] = 1334LLU;
20660	20722	// arguments for call to printnr
20661	20723	stack[base + 23LLU] = stack[base + 19]/labelloop/;
20662	20724	// set stack-base & callee-address

		@@ -20664,7 +20726,7 @@
20664	20726	label = 18446744073709551591LLU; // printnr
20665	20727	break;
20666	20728	}
20667		- case 1329LLU: // return from printnr to procblock
	20729	+ case 1334LLU: // return from printnr to procblock
20668	20730	{
20669	20731	// copy mutable arguments back from call to printnr
20670	20732	printf("%s", "LLU; // repeat");

		@@ -20673,7 +20735,7 @@
20673	20735	printf("%s", "\n case ");
20674	20736	// call printnr from procblock
20675	20737	stack[base + 21LLU] = base;
20676		- stack[base + 22LLU] = 1330LLU;
	20738	+ stack[base + 22LLU] = 1335LLU;
20677	20739	// arguments for call to printnr
20678	20740	stack[base + 23LLU] = stack[base + 20]/labelskip/;
20679	20741	// set stack-base & callee-address

		@@ -20681,19 +20743,19 @@
20681	20743	label = 18446744073709551591LLU; // printnr
20682	20744	break;
20683	20745	}
20684		- case 1330LLU: // return from printnr to procblock
	20746	+ case 1335LLU: // return from printnr to procblock
20685	20747	{
20686	20748	// copy mutable arguments back from call to printnr
20687	20749	printf("%s", "LLU: // loop finished");
20688	20750	printf("%s", "\n {");
20689		- label = 1251LLU; // consequent complete
	20751	+ label = 1256LLU; // consequent complete
20690	20752	break;
20691	20753	}
20692		- case 1250LLU: // alternative
	20754	+ case 1255LLU: // alternative
20693	20755	{
20694	20756	// call equ from procblock
20695	20757	stack[base + 19LLU] = base;
20696		- stack[base + 20LLU] = 1331LLU;
	20758	+ stack[base + 20LLU] = 1336LLU;
20697	20759	// arguments for call to equ
20698	20760	stack[base + 22LLU] = stack[base + 13]/content/;
20699	20761	stack[base + 23LLU] = 589327972884807680LLU;

		@@ -20702,7 +20764,7 @@
20702	20764	label = 18446744073709551600LLU; // equ
20703	20765	break;
20704	20766	}
20705		- case 1331LLU: // return from equ to procblock
	20767	+ case 1336LLU: // return from equ to procblock
20706	20768	{
20707	20769	// copy mutable arguments back from call to equ
20708	20770	// copy back results provided by call to equ

		@@ -20709,20 +20771,20 @@
20709	20771	stack[base + 18] = stack[base + 21LLU];
20710	20772	if(!stack[base + 18]/isequal/)
20711	20773	{
20712		- label = 1332LLU; // jump to alternative
	20774	+ label = 1337LLU; // jump to alternative
20713	20775	break;
20714	20776	}
20715	20777
20716	20778	// consequent
20717	20779	printf("%s", "\n exit(-1);");
20718		- label = 1333LLU; // consequent complete
	20780	+ label = 1338LLU; // consequent complete
20719	20781	break;
20720	20782	}
20721		- case 1332LLU: // alternative
	20783	+ case 1337LLU: // alternative
20722	20784	{
20723	20785	// call equ from procblock
20724	20786	stack[base + 19LLU] = base;
20725		- stack[base + 20LLU] = 1334LLU;
	20787	+ stack[base + 20LLU] = 1339LLU;
20726	20788	// arguments for call to equ
20727	20789	stack[base + 22LLU] = stack[base + 13]/content/;
20728	20790	stack[base + 23LLU] = 819847183506341888LLU;

		@@ -20731,7 +20793,7 @@
20731	20793	label = 18446744073709551600LLU; // equ
20732	20794	break;
20733	20795	}
20734		- case 1334LLU: // return from equ to procblock
	20796	+ case 1339LLU: // return from equ to procblock
20735	20797	{
20736	20798	// copy mutable arguments back from call to equ
20737	20799	// copy back results provided by call to equ

		@@ -20738,7 +20800,7 @@
20738	20800	stack[base + 18] = stack[base + 21LLU];
20739	20801	if(!stack[base + 18]/isequal/)
20740	20802	{
20741		- label = 1335LLU; // jump to alternative
	20803	+ label = 1340LLU; // jump to alternative
20742	20804	break;
20743	20805	}
20744	20806

		@@ -20745,7 +20807,7 @@
20745	20807	// consequent
20746	20808	// call matchsym from procblock
20747	20809	stack[base + 19LLU] = base;
20748		- stack[base + 20LLU] = 1337LLU;
	20810	+ stack[base + 20LLU] = 1342LLU;
20749	20811	// arguments for call to matchsym
20750	20812	stack[base + 21LLU] = 40LLU;
20751	20813	stack[base + 22LLU] = stack[base + 11]/lookahead/;

		@@ -20754,7 +20816,7 @@
20754	20816	label = 27LLU; // matchsym
20755	20817	break;
20756	20818	}
20757		- case 1337LLU: // return from matchsym to procblock
	20819	+ case 1342LLU: // return from matchsym to procblock
20758	20820	{
20759	20821	// copy mutable arguments back from call to matchsym
20760	20822	stack[base + 11]/lookahead/ = stack[base + 22LLU];

		@@ -20761,7 +20823,7 @@
20761	20823	printf("%s", "\n fprintf(stderr, \"%s\", ");
20762	20824	// call echostring from procblock
20763	20825	stack[base + 19LLU] = base;
20764		- stack[base + 20LLU] = 1338LLU;
	20826	+ stack[base + 20LLU] = 1343LLU;
20765	20827	// arguments for call to echostring
20766	20828	stack[base + 22LLU] = stack[base + 11]/lookahead/;
20767	20829	// set stack-base & callee-address

		@@ -20769,7 +20831,7 @@
20769	20831	label = 18446744073709551582LLU; // echostring
20770	20832	break;
20771	20833	}
20772		- case 1338LLU: // return from echostring to procblock
	20834	+ case 1343LLU: // return from echostring to procblock
20773	20835	{
20774	20836	// copy mutable arguments back from call to echostring
20775	20837	// copy back results provided by call to echostring

		@@ -20777,7 +20839,7 @@
20777	20839	printf("%s", ");");
20778	20840	// call matchsym from procblock
20779	20841	stack[base + 19LLU] = base;
20780		- stack[base + 20LLU] = 1339LLU;
	20842	+ stack[base + 20LLU] = 1344LLU;
20781	20843	// arguments for call to matchsym
20782	20844	stack[base + 21LLU] = 41LLU;
20783	20845	stack[base + 22LLU] = stack[base + 11]/lookahead/;

		@@ -20786,18 +20848,18 @@
20786	20848	label = 27LLU; // matchsym
20787	20849	break;
20788	20850	}
20789		- case 1339LLU: // return from matchsym to procblock
	20851	+ case 1344LLU: // return from matchsym to procblock
20790	20852	{
20791	20853	// copy mutable arguments back from call to matchsym
20792	20854	stack[base + 11]/lookahead/ = stack[base + 22LLU];
20793		- label = 1336LLU; // consequent complete
	20855	+ label = 1341LLU; // consequent complete
20794	20856	break;
20795	20857	}
20796		- case 1335LLU: // alternative
	20858	+ case 1340LLU: // alternative
20797	20859	{
20798	20860	// call equ from procblock
20799	20861	stack[base + 19LLU] = base;
20800		- stack[base + 20LLU] = 1340LLU;
	20862	+ stack[base + 20LLU] = 1345LLU;
20801	20863	// arguments for call to equ
20802	20864	stack[base + 22LLU] = stack[base + 13]/content/;
20803	20865	stack[base + 23LLU] = 787446707498516480LLU;

		@@ -20806,7 +20868,7 @@
20806	20868	label = 18446744073709551600LLU; // equ
20807	20869	break;
20808	20870	}
20809		- case 1340LLU: // return from equ to procblock
	20871	+ case 1345LLU: // return from equ to procblock
20810	20872	{
20811	20873	// copy mutable arguments back from call to equ
20812	20874	// copy back results provided by call to equ

		@@ -20813,7 +20875,7 @@
20813	20875	stack[base + 18] = stack[base + 21LLU];
20814	20876	if(!stack[base + 18]/isequal/)
20815	20877	{
20816		- label = 1341LLU; // jump to alternative
	20878	+ label = 1346LLU; // jump to alternative
20817	20879	break;
20818	20880	}
20819	20881

		@@ -20820,7 +20882,7 @@
20820	20882	// consequent
20821	20883	// call matchsym from procblock
20822	20884	stack[base + 19LLU] = base;
20823		- stack[base + 20LLU] = 1343LLU;
	20885	+ stack[base + 20LLU] = 1348LLU;
20824	20886	// arguments for call to matchsym
20825	20887	stack[base + 21LLU] = 40LLU;
20826	20888	stack[base + 22LLU] = stack[base + 11]/lookahead/;

		@@ -20829,7 +20891,7 @@
20829	20891	label = 27LLU; // matchsym
20830	20892	break;
20831	20893	}
20832		- case 1343LLU: // return from matchsym to procblock
	20894	+ case 1348LLU: // return from matchsym to procblock
20833	20895	{
20834	20896	// copy mutable arguments back from call to matchsym
20835	20897	stack[base + 11]/lookahead/ = stack[base + 22LLU];

		@@ -20836,7 +20898,7 @@
20836	20898	printf("%s", "\n printf(\"%s\", ");
20837	20899	// call echostring from procblock
20838	20900	stack[base + 19LLU] = base;
20839		- stack[base + 20LLU] = 1344LLU;
	20901	+ stack[base + 20LLU] = 1349LLU;
20840	20902	// arguments for call to echostring
20841	20903	stack[base + 22LLU] = stack[base + 11]/lookahead/;
20842	20904	// set stack-base & callee-address

		@@ -20844,7 +20906,7 @@
20844	20906	label = 18446744073709551582LLU; // echostring
20845	20907	break;
20846	20908	}
20847		- case 1344LLU: // return from echostring to procblock
	20909	+ case 1349LLU: // return from echostring to procblock
20848	20910	{
20849	20911	// copy mutable arguments back from call to echostring
20850	20912	// copy back results provided by call to echostring

		@@ -20852,7 +20914,7 @@
20852	20914	printf("%s", ");");
20853	20915	// call matchsym from procblock
20854	20916	stack[base + 19LLU] = base;
20855		- stack[base + 20LLU] = 1345LLU;
	20917	+ stack[base + 20LLU] = 1350LLU;
20856	20918	// arguments for call to matchsym
20857	20919	stack[base + 21LLU] = 41LLU;
20858	20920	stack[base + 22LLU] = stack[base + 11]/lookahead/;

		@@ -20861,18 +20923,18 @@
20861	20923	label = 27LLU; // matchsym
20862	20924	break;
20863	20925	}
20864		- case 1345LLU: // return from matchsym to procblock
	20926	+ case 1350LLU: // return from matchsym to procblock
20865	20927	{
20866	20928	// copy mutable arguments back from call to matchsym
20867	20929	stack[base + 11]/lookahead/ = stack[base + 22LLU];
20868		- label = 1342LLU; // consequent complete
	20930	+ label = 1347LLU; // consequent complete
20869	20931	break;
20870	20932	}
20871		- case 1341LLU: // alternative
	20933	+ case 1346LLU: // alternative
20872	20934	{
20873	20935	// call equ from procblock
20874	20936	stack[base + 19LLU] = base;
20875		- stack[base + 20LLU] = 1346LLU;
	20937	+ stack[base + 20LLU] = 1351LLU;
20876	20938	// arguments for call to equ
20877	20939	stack[base + 22LLU] = stack[base + 13]/content/;
20878	20940	stack[base + 23LLU] = 253710109086056448LLU;

		@@ -20881,7 +20943,7 @@
20881	20943	label = 18446744073709551600LLU; // equ
20882	20944	break;
20883	20945	}
20884		- case 1346LLU: // return from equ to procblock
	20946	+ case 1351LLU: // return from equ to procblock
20885	20947	{
20886	20948	// copy mutable arguments back from call to equ
20887	20949	// copy back results provided by call to equ

		@@ -20888,7 +20950,7 @@
20888	20950	stack[base + 18] = stack[base + 21LLU];
20889	20951	if(!stack[base + 18]/isequal/)
20890	20952	{
20891		- label = 1347LLU; // jump to alternative
	20953	+ label = 1352LLU; // jump to alternative
20892	20954	break;
20893	20955	}
20894	20956

		@@ -20897,7 +20959,7 @@
20897	20959	stack[base + 19/type/] = 0; // init
20898	20960	// call parsetoken from procblock
20899	20961	stack[base + 20LLU] = base;
20900		- stack[base + 21LLU] = 1349LLU;
	20962	+ stack[base + 21LLU] = 1354LLU;
20901	20963	// arguments for call to parsetoken
20902	20964	stack[base + 25LLU] = stack[base + 11]/lookahead/;
20903	20965	// set stack-base & callee-address

		@@ -20905,7 +20967,7 @@
20905	20967	label = 18446744073709551585LLU; // parsetoken
20906	20968	break;
20907	20969	}
20908		- case 1349LLU: // return from parsetoken to procblock
	20970	+ case 1354LLU: // return from parsetoken to procblock
20909	20971	{
20910	20972	// copy mutable arguments back from call to parsetoken
20911	20973	// copy back results provided by call to parsetoken

		@@ -20917,7 +20979,7 @@
20917	20979	stack[base + 20]/mutable/ = 0;
20918	20980	// call equ from procblock
20919	20981	stack[base + 21LLU] = base;
20920		- stack[base + 22LLU] = 1350LLU;
	20982	+ stack[base + 22LLU] = 1355LLU;
20921	20983	// arguments for call to equ
20922	20984	stack[base + 24LLU] = stack[base + 12]/variant/;
20923	20985	stack[base + 25LLU] = 4LLU;

		@@ -20926,7 +20988,7 @@
20926	20988	label = 18446744073709551600LLU; // equ
20927	20989	break;
20928	20990	}
20929		- case 1350LLU: // return from equ to procblock
	20991	+ case 1355LLU: // return from equ to procblock
20930	20992	{
20931	20993	// copy mutable arguments back from call to equ
20932	20994	// copy back results provided by call to equ

		@@ -20933,7 +20995,7 @@
20933	20995	stack[base + 18] = stack[base + 23LLU];
20934	20996	if(!stack[base + 18]/isequal/)
20935	20997	{
20936		- label = 1351LLU; // jump to alternative
	20998	+ label = 1356LLU; // jump to alternative
20937	20999	break;
20938	21000	}
20939	21001

		@@ -20940,7 +21002,7 @@
20940	21002	// consequent
20941	21003	// call equ from procblock
20942	21004	stack[base + 21LLU] = base;
20943		- stack[base + 22LLU] = 1353LLU;
	21005	+ stack[base + 22LLU] = 1358LLU;
20944	21006	// arguments for call to equ
20945	21007	stack[base + 24LLU] = stack[base + 13]/content/;
20946	21008	stack[base + 25LLU] = 734293447447412736LLU;

		@@ -20949,7 +21011,7 @@
20949	21011	label = 18446744073709551600LLU; // equ
20950	21012	break;
20951	21013	}
20952		- case 1353LLU: // return from equ to procblock
	21014	+ case 1358LLU: // return from equ to procblock
20953	21015	{
20954	21016	// copy mutable arguments back from call to equ
20955	21017	// copy back results provided by call to equ

		@@ -20956,7 +21018,7 @@
20956	21018	stack[base + 18] = stack[base + 23LLU];
20957	21019	if(!stack[base + 18]/isequal/)
20958	21020	{
20959		- label = 1354LLU; // jump to alternative
	21021	+ label = 1359LLU; // jump to alternative
20960	21022	break;
20961	21023	}
20962	21024

		@@ -20964,7 +21026,7 @@
20964	21026	stack[base + 20]/mutable/ = 1;
20965	21027	// call parsetoken from procblock
20966	21028	stack[base + 21LLU] = base;
20967		- stack[base + 22LLU] = 1356LLU;
	21029	+ stack[base + 22LLU] = 1361LLU;
20968	21030	// arguments for call to parsetoken
20969	21031	stack[base + 26LLU] = stack[base + 11]/lookahead/;
20970	21032	// set stack-base & callee-address

		@@ -20972,7 +21034,7 @@
20972	21034	label = 18446744073709551585LLU; // parsetoken
20973	21035	break;
20974	21036	}
20975		- case 1356LLU: // return from parsetoken to procblock
	21037	+ case 1361LLU: // return from parsetoken to procblock
20976	21038	{
20977	21039	// copy mutable arguments back from call to parsetoken
20978	21040	// copy back results provided by call to parsetoken

		@@ -20979,25 +21041,25 @@
20979	21041	stack[base + 12] = stack[base + 23LLU];
20980	21042	stack[base + 13] = stack[base + 24LLU];
20981	21043	stack[base + 11] = stack[base + 25LLU];
20982		- label = 1355LLU; // consequent complete
	21044	+ label = 1360LLU; // consequent complete
20983	21045	break;
20984	21046	}
20985		- case 1354LLU: // alternative
	21047	+ case 1359LLU: // alternative
20986	21048	{
20987		- label = 1355LLU; // alternative complete
	21049	+ label = 1360LLU; // alternative complete
20988	21050	break;
20989	21051	}
20990		- case 1355LLU: // completed if-then-else
	21052	+ case 1360LLU: // completed if-then-else
20991	21053	{
20992		- label = 1352LLU; // consequent complete
	21054	+ label = 1357LLU; // consequent complete
20993	21055	break;
20994	21056	}
20995		- case 1351LLU: // alternative
	21057	+ case 1356LLU: // alternative
20996	21058	{
20997		- label = 1352LLU; // alternative complete
	21059	+ label = 1357LLU; // alternative complete
20998	21060	break;
20999	21061	}
21000		- case 1352LLU: // completed if-then-else
	21062	+ case 1357LLU: // completed if-then-else
21001	21063	{
21002	21064	uint64_t newstack = (uint64_t )Calloc(27LLU + 1, sizeof(uint64_t));
21003	21065	newstack[27LLU] = 9876543210LLU; // overflow-marker

		@@ -21004,7 +21066,7 @@
21004	21066	// call PARSETYPE from procblock
21005	21067	newstack[0] = (uint64_t)stack; // backup stack location
21006	21068	newstack[1] = base;
21007		- newstack[2] = 1357LLU;
	21069	+ newstack[2] = 1362LLU;
21008	21070	// arguments for call to PARSETYPE
21009	21071	newstack[4LLU] = stack[base + 12]/variant/;
21010	21072	newstack[5LLU] = stack[base + 13]/content/;

		@@ -21015,7 +21077,7 @@
21015	21077	label = 265LLU; // PARSETYPE
21016	21078	break;
21017	21079	}
21018		- case 1357LLU: // return from PARSETYPE to procblock
	21080	+ case 1362LLU: // return from PARSETYPE to procblock
21019	21081	{
21020	21082	uint64_t oldstack = (uint64_t )stack[0];
21021	21083	// copy mutable arguments back from call to PARSETYPE

		@@ -21033,7 +21095,7 @@
21033	21095	stack = oldstack;
21034	21096	// call parsetoken from procblock
21035	21097	stack[base + 21LLU] = base;
21036		- stack[base + 22LLU] = 1358LLU;
	21098	+ stack[base + 22LLU] = 1363LLU;
21037	21099	// arguments for call to parsetoken
21038	21100	stack[base + 26LLU] = stack[base + 11]/lookahead/;
21039	21101	// set stack-base & callee-address

		@@ -21041,7 +21103,7 @@
21041	21103	label = 18446744073709551585LLU; // parsetoken
21042	21104	break;
21043	21105	}
21044		- case 1358LLU: // return from parsetoken to procblock
	21106	+ case 1363LLU: // return from parsetoken to procblock
21045	21107	{
21046	21108	// copy mutable arguments back from call to parsetoken
21047	21109	// copy back results provided by call to parsetoken

		@@ -21050,7 +21112,7 @@
21050	21112	stack[base + 11] = stack[base + 25LLU];
21051	21113	// call equ from procblock
21052	21114	stack[base + 21LLU] = base;
21053		- stack[base + 22LLU] = 1359LLU;
	21115	+ stack[base + 22LLU] = 1364LLU;
21054	21116	// arguments for call to equ
21055	21117	stack[base + 24LLU] = stack[base + 12]/variant/;
21056	21118	stack[base + 25LLU] = 4LLU;

		@@ -21059,7 +21121,7 @@
21059	21121	label = 18446744073709551600LLU; // equ
21060	21122	break;
21061	21123	}
21062		- case 1359LLU: // return from equ to procblock
	21124	+ case 1364LLU: // return from equ to procblock
21063	21125	{
21064	21126	// copy mutable arguments back from call to equ
21065	21127	// copy back results provided by call to equ

		@@ -21066,7 +21128,7 @@
21066	21128	stack[base + 18] = stack[base + 23LLU];
21067	21129	if(!stack[base + 18]/isequal/)
21068	21130	{
21069		- label = 1360LLU; // jump to alternative
	21131	+ label = 1365LLU; // jump to alternative
21070	21132	break;
21071	21133	}
21072	21134

		@@ -21073,7 +21135,7 @@
21073	21135	// consequent
21074	21136	// call newvar from procblock
21075	21137	stack[base + 21LLU] = base;
21076		- stack[base + 22LLU] = 1362LLU;
	21138	+ stack[base + 22LLU] = 1367LLU;
21077	21139	// arguments for call to newvar
21078	21140	stack[base + 23LLU] = stack[base + 19]/type/;
21079	21141	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -21088,21 +21150,21 @@
21088	21150	label = 235LLU; // newvar
21089	21151	break;
21090	21152	}
21091		- case 1362LLU: // return from newvar to procblock
	21153	+ case 1367LLU: // return from newvar to procblock
21092	21154	{
21093	21155	// copy mutable arguments back from call to newvar
21094	21156	stack[base + 3]/scope/ = stack[base + 30LLU];
21095	21157	stack[base + 16]/varcount/ = stack[base + 29LLU];
21096	21158	stack[base + 9]/fnmaxcount/ = stack[base + 28LLU];
21097		- label = 1361LLU; // consequent complete
	21159	+ label = 1366LLU; // consequent complete
21098	21160	break;
21099	21161	}
21100		- case 1360LLU: // alternative
	21162	+ case 1365LLU: // alternative
21101	21163	{
21102	21164	fprintf(stderr, "%s", "expected identifier in new but found ");
21103	21165	// call reporttok from procblock
21104	21166	stack[base + 21LLU] = base;
21105		- stack[base + 22LLU] = 1363LLU;
	21167	+ stack[base + 22LLU] = 1368LLU;
21106	21168	// arguments for call to reporttok
21107	21169	stack[base + 23LLU] = stack[base + 12]/variant/;
21108	21170	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -21111,24 +21173,24 @@
21111	21173	label = 18446744073709551583LLU; // reporttok
21112	21174	break;
21113	21175	}
21114		- case 1363LLU: // return from reporttok to procblock
	21176	+ case 1368LLU: // return from reporttok to procblock
21115	21177	{
21116	21178	// copy mutable arguments back from call to reporttok
21117	21179	fprintf(stderr, "%s", "\n");
21118	21180	exit(-1);
21119		- label = 1361LLU; // alternative complete
	21181	+ label = 1366LLU; // alternative complete
21120	21182	break;
21121	21183	}
21122		- case 1361LLU: // completed if-then-else
	21184	+ case 1366LLU: // completed if-then-else
21123	21185	{
21124		- label = 1348LLU; // consequent complete
	21186	+ label = 1353LLU; // consequent complete
21125	21187	break;
21126	21188	}
21127		- case 1347LLU: // alternative
	21189	+ case 1352LLU: // alternative
21128	21190	{
21129	21191	// call equ from procblock
21130	21192	stack[base + 19LLU] = base;
21131		- stack[base + 20LLU] = 1364LLU;
	21193	+ stack[base + 20LLU] = 1369LLU;
21132	21194	// arguments for call to equ
21133	21195	stack[base + 22LLU] = stack[base + 13]/content/;
21134	21196	stack[base + 23LLU] = 217668117927559168LLU;

		@@ -21137,7 +21199,7 @@
21137	21199	label = 18446744073709551600LLU; // equ
21138	21200	break;
21139	21201	}
21140		- case 1364LLU: // return from equ to procblock
	21202	+ case 1369LLU: // return from equ to procblock
21141	21203	{
21142	21204	// copy mutable arguments back from call to equ
21143	21205	// copy back results provided by call to equ

		@@ -21144,7 +21206,7 @@
21144	21206	stack[base + 18] = stack[base + 21LLU];
21145	21207	if(!stack[base + 18]/isequal/)
21146	21208	{
21147		- label = 1365LLU; // jump to alternative
	21209	+ label = 1370LLU; // jump to alternative
21148	21210	break;
21149	21211	}
21150	21212

		@@ -21151,7 +21213,7 @@
21151	21213	// consequent
21152	21214	// call parsetoken from procblock
21153	21215	stack[base + 19LLU] = base;
21154		- stack[base + 20LLU] = 1367LLU;
	21216	+ stack[base + 20LLU] = 1372LLU;
21155	21217	// arguments for call to parsetoken
21156	21218	stack[base + 24LLU] = stack[base + 11]/lookahead/;
21157	21219	// set stack-base & callee-address

		@@ -21159,7 +21221,7 @@
21159	21221	label = 18446744073709551585LLU; // parsetoken
21160	21222	break;
21161	21223	}
21162		- case 1367LLU: // return from parsetoken to procblock
	21224	+ case 1372LLU: // return from parsetoken to procblock
21163	21225	{
21164	21226	// copy mutable arguments back from call to parsetoken
21165	21227	// copy back results provided by call to parsetoken

		@@ -21168,7 +21230,7 @@
21168	21230	stack[base + 11] = stack[base + 23LLU];
21169	21231	// call equ from procblock
21170	21232	stack[base + 19LLU] = base;
21171		- stack[base + 20LLU] = 1368LLU;
	21233	+ stack[base + 20LLU] = 1373LLU;
21172	21234	// arguments for call to equ
21173	21235	stack[base + 22LLU] = stack[base + 13]/content/;
21174	21236	stack[base + 23LLU] = 40LLU;

		@@ -21177,7 +21239,7 @@
21177	21239	label = 18446744073709551600LLU; // equ
21178	21240	break;
21179	21241	}
21180		- case 1368LLU: // return from equ to procblock
	21242	+ case 1373LLU: // return from equ to procblock
21181	21243	{
21182	21244	// copy mutable arguments back from call to equ
21183	21245	// copy back results provided by call to equ

		@@ -21184,7 +21246,7 @@
21184	21246	stack[base + 18] = stack[base + 21LLU];
21185	21247	if(!stack[base + 18]/isequal/)
21186	21248	{
21187		- label = 1369LLU; // jump to alternative
	21249	+ label = 1374LLU; // jump to alternative
21188	21250	break;
21189	21251	}
21190	21252

		@@ -21202,7 +21264,7 @@
21202	21264	stack[base + 22]/calleedef/ = 0;
21203	21265	// call skipwscmnt from procblock
21204	21266	stack[base + 23LLU] = base;
21205		- stack[base + 24LLU] = 1371LLU;
	21267	+ stack[base + 24LLU] = 1376LLU;
21206	21268	// arguments for call to skipwscmnt
21207	21269	stack[base + 26LLU] = stack[base + 11]/lookahead/;
21208	21270	// set stack-base & callee-address

		@@ -21210,7 +21272,7 @@
21210	21272	label = 18446744073709551581LLU; // skipwscmnt
21211	21273	break;
21212	21274	}
21213		- case 1371LLU: // return from skipwscmnt to procblock
	21275	+ case 1376LLU: // return from skipwscmnt to procblock
21214	21276	{
21215	21277	// copy mutable arguments back from call to skipwscmnt
21216	21278	// copy back results provided by call to skipwscmnt

		@@ -21217,7 +21279,7 @@
21217	21279	stack[base + 11] = stack[base + 25LLU];
21218	21280	// call equ from procblock
21219	21281	stack[base + 23LLU] = base;
21220		- stack[base + 24LLU] = 1372LLU;
	21282	+ stack[base + 24LLU] = 1377LLU;
21221	21283	// arguments for call to equ
21222	21284	stack[base + 26LLU] = stack[base + 11]/lookahead/;
21223	21285	stack[base + 27LLU] = 41LLU;

		@@ -21226,7 +21288,7 @@
21226	21288	label = 18446744073709551600LLU; // equ
21227	21289	break;
21228	21290	}
21229		- case 1372LLU: // return from equ to procblock
	21291	+ case 1377LLU: // return from equ to procblock
21230	21292	{
21231	21293	// copy mutable arguments back from call to equ
21232	21294	// copy back results provided by call to equ

		@@ -21233,27 +21295,27 @@
21233	21295	stack[base + 18] = stack[base + 25LLU];
21234	21296	if(!stack[base + 18]/isequal/)
21235	21297	{
21236		- label = 1373LLU; // jump to alternative
	21298	+ label = 1378LLU; // jump to alternative
21237	21299	break;
21238	21300	}
21239	21301
21240	21302	// consequent
21241		- label = 1374LLU; // consequent complete
	21303	+ label = 1379LLU; // consequent complete
21242	21304	break;
21243	21305	}
21244		- case 1373LLU: // alternative
	21306	+ case 1378LLU: // alternative
21245	21307	{
21246	21308	//#define continue 23
21247	21309	stack[base + 23/continue/] = 0; // init
21248	21310	stack[base + 23]/continue/ = 1;
21249		- label = 1375LLU; // start to repeat
	21311	+ label = 1380LLU; // start to repeat
21250	21312	break;
21251	21313	}
21252		- case 1375LLU: // repeat from here
	21314	+ case 1380LLU: // repeat from here
21253	21315	{
21254	21316	if(!stack[base + 23]/continue/)
21255	21317	{
21256		- label = 1376LLU; // break loop
	21318	+ label = 1381LLU; // break loop
21257	21319	break;
21258	21320	}
21259	21321

		@@ -21260,7 +21322,7 @@
21260	21322	// loop body
21261	21323	// call parsetoken from procblock
21262	21324	stack[base + 24LLU] = base;
21263		- stack[base + 25LLU] = 1377LLU;
	21325	+ stack[base + 25LLU] = 1382LLU;
21264	21326	// arguments for call to parsetoken
21265	21327	stack[base + 29LLU] = stack[base + 11]/lookahead/;
21266	21328	// set stack-base & callee-address

		@@ -21268,7 +21330,7 @@
21268	21330	label = 18446744073709551585LLU; // parsetoken
21269	21331	break;
21270	21332	}
21271		- case 1377LLU: // return from parsetoken to procblock
	21333	+ case 1382LLU: // return from parsetoken to procblock
21272	21334	{
21273	21335	// copy mutable arguments back from call to parsetoken
21274	21336	// copy back results provided by call to parsetoken

		@@ -21280,7 +21342,7 @@
21280	21342	stack[base + 24]/mutable/ = 0;
21281	21343	// call equ from procblock
21282	21344	stack[base + 25LLU] = base;
21283		- stack[base + 26LLU] = 1378LLU;
	21345	+ stack[base + 26LLU] = 1383LLU;
21284	21346	// arguments for call to equ
21285	21347	stack[base + 28LLU] = stack[base + 12]/variant/;
21286	21348	stack[base + 29LLU] = 4LLU;

		@@ -21289,7 +21351,7 @@
21289	21351	label = 18446744073709551600LLU; // equ
21290	21352	break;
21291	21353	}
21292		- case 1378LLU: // return from equ to procblock
	21354	+ case 1383LLU: // return from equ to procblock
21293	21355	{
21294	21356	// copy mutable arguments back from call to equ
21295	21357	// copy back results provided by call to equ

		@@ -21296,7 +21358,7 @@
21296	21358	stack[base + 18] = stack[base + 27LLU];
21297	21359	if(!stack[base + 18]/isequal/)
21298	21360	{
21299		- label = 1379LLU; // jump to alternative
	21361	+ label = 1384LLU; // jump to alternative
21300	21362	break;
21301	21363	}
21302	21364

		@@ -21303,7 +21365,7 @@
21303	21365	// consequent
21304	21366	// call equ from procblock
21305	21367	stack[base + 25LLU] = base;
21306		- stack[base + 26LLU] = 1381LLU;
	21368	+ stack[base + 26LLU] = 1386LLU;
21307	21369	// arguments for call to equ
21308	21370	stack[base + 28LLU] = stack[base + 13]/content/;
21309	21371	stack[base + 29LLU] = 734293447447412736LLU;

		@@ -21312,7 +21374,7 @@
21312	21374	label = 18446744073709551600LLU; // equ
21313	21375	break;
21314	21376	}
21315		- case 1381LLU: // return from equ to procblock
	21377	+ case 1386LLU: // return from equ to procblock
21316	21378	{
21317	21379	// copy mutable arguments back from call to equ
21318	21380	// copy back results provided by call to equ

		@@ -21319,7 +21381,7 @@
21319	21381	stack[base + 18] = stack[base + 27LLU];
21320	21382	if(!stack[base + 18]/isequal/)
21321	21383	{
21322		- label = 1382LLU; // jump to alternative
	21384	+ label = 1387LLU; // jump to alternative
21323	21385	break;
21324	21386	}
21325	21387

		@@ -21327,7 +21389,7 @@
21327	21389	stack[base + 24]/mutable/ = 1;
21328	21390	// call parsetoken from procblock
21329	21391	stack[base + 25LLU] = base;
21330		- stack[base + 26LLU] = 1384LLU;
	21392	+ stack[base + 26LLU] = 1389LLU;
21331	21393	// arguments for call to parsetoken
21332	21394	stack[base + 30LLU] = stack[base + 11]/lookahead/;
21333	21395	// set stack-base & callee-address

		@@ -21335,7 +21397,7 @@
21335	21397	label = 18446744073709551585LLU; // parsetoken
21336	21398	break;
21337	21399	}
21338		- case 1384LLU: // return from parsetoken to procblock
	21400	+ case 1389LLU: // return from parsetoken to procblock
21339	21401	{
21340	21402	// copy mutable arguments back from call to parsetoken
21341	21403	// copy back results provided by call to parsetoken

		@@ -21344,7 +21406,7 @@
21344	21406	stack[base + 11] = stack[base + 29LLU];
21345	21407	// call equ from procblock
21346	21408	stack[base + 25LLU] = base;
21347		- stack[base + 26LLU] = 1385LLU;
	21409	+ stack[base + 26LLU] = 1390LLU;
21348	21410	// arguments for call to equ
21349	21411	stack[base + 28LLU] = stack[base + 12]/variant/;
21350	21412	stack[base + 29LLU] = 4LLU;

		@@ -21353,7 +21415,7 @@
21353	21415	label = 18446744073709551600LLU; // equ
21354	21416	break;
21355	21417	}
21356		- case 1385LLU: // return from equ to procblock
	21418	+ case 1390LLU: // return from equ to procblock
21357	21419	{
21358	21420	// copy mutable arguments back from call to equ
21359	21421	// copy back results provided by call to equ

		@@ -21360,20 +21422,20 @@
21360	21422	stack[base + 18] = stack[base + 27LLU];
21361	21423	if(!stack[base + 18]/isequal/)
21362	21424	{
21363		- label = 1386LLU; // jump to alternative
	21425	+ label = 1391LLU; // jump to alternative
21364	21426	break;
21365	21427	}
21366	21428
21367	21429	// consequent
21368		- label = 1387LLU; // consequent complete
	21430	+ label = 1392LLU; // consequent complete
21369	21431	break;
21370	21432	}
21371		- case 1386LLU: // alternative
	21433	+ case 1391LLU: // alternative
21372	21434	{
21373	21435	fprintf(stderr, "%s", "let expects identifier but found ");
21374	21436	// call reporttok from procblock
21375	21437	stack[base + 25LLU] = base;
21376		- stack[base + 26LLU] = 1388LLU;
	21438	+ stack[base + 26LLU] = 1393LLU;
21377	21439	// arguments for call to reporttok
21378	21440	stack[base + 27LLU] = stack[base + 12]/variant/;
21379	21441	stack[base + 28LLU] = stack[base + 13]/content/;

		@@ -21382,34 +21444,34 @@
21382	21444	label = 18446744073709551583LLU; // reporttok
21383	21445	break;
21384	21446	}
21385		- case 1388LLU: // return from reporttok to procblock
	21447	+ case 1393LLU: // return from reporttok to procblock
21386	21448	{
21387	21449	// copy mutable arguments back from call to reporttok
21388	21450	exit(-1);
21389		- label = 1387LLU; // alternative complete
	21451	+ label = 1392LLU; // alternative complete
21390	21452	break;
21391	21453	}
21392		- case 1387LLU: // completed if-then-else
	21454	+ case 1392LLU: // completed if-then-else
21393	21455	{
21394		- label = 1383LLU; // consequent complete
	21456	+ label = 1388LLU; // consequent complete
21395	21457	break;
21396	21458	}
21397		- case 1382LLU: // alternative
	21459	+ case 1387LLU: // alternative
21398	21460	{
21399		- label = 1383LLU; // alternative complete
	21461	+ label = 1388LLU; // alternative complete
21400	21462	break;
21401	21463	}
21402		- case 1383LLU: // completed if-then-else
	21464	+ case 1388LLU: // completed if-then-else
21403	21465	{
21404		- label = 1380LLU; // consequent complete
	21466	+ label = 1385LLU; // consequent complete
21405	21467	break;
21406	21468	}
21407		- case 1379LLU: // alternative
	21469	+ case 1384LLU: // alternative
21408	21470	{
21409	21471	fprintf(stderr, "%s", "let expects identifier but found ");
21410	21472	// call reporttok from procblock
21411	21473	stack[base + 25LLU] = base;
21412		- stack[base + 26LLU] = 1389LLU;
	21474	+ stack[base + 26LLU] = 1394LLU;
21413	21475	// arguments for call to reporttok
21414	21476	stack[base + 27LLU] = stack[base + 12]/variant/;
21415	21477	stack[base + 28LLU] = stack[base + 13]/content/;

		@@ -21418,20 +21480,20 @@
21418	21480	label = 18446744073709551583LLU; // reporttok
21419	21481	break;
21420	21482	}
21421		- case 1389LLU: // return from reporttok to procblock
	21483	+ case 1394LLU: // return from reporttok to procblock
21422	21484	{
21423	21485	// copy mutable arguments back from call to reporttok
21424	21486	exit(-1);
21425		- label = 1380LLU; // alternative complete
	21487	+ label = 1385LLU; // alternative complete
21426	21488	break;
21427	21489	}
21428		- case 1380LLU: // completed if-then-else
	21490	+ case 1385LLU: // completed if-then-else
21429	21491	{
21430	21492	//#define found 25
21431	21493	stack[base + 25/found/] = 0; // init
21432	21494	// call lookidnr from procblock
21433	21495	stack[base + 26LLU] = base;
21434		- stack[base + 27LLU] = 1390LLU;
	21496	+ stack[base + 27LLU] = 1395LLU;
21435	21497	// arguments for call to lookidnr
21436	21498	stack[base + 29LLU] = stack[base + 21]/news/;
21437	21499	stack[base + 30LLU] = stack[base + 13]/content/;

		@@ -21440,7 +21502,7 @@
21440	21502	label = 252LLU; // lookidnr
21441	21503	break;
21442	21504	}
21443		- case 1390LLU: // return from lookidnr to procblock
	21505	+ case 1395LLU: // return from lookidnr to procblock
21444	21506	{
21445	21507	// copy mutable arguments back from call to lookidnr
21446	21508	// copy back results provided by call to lookidnr

		@@ -21447,7 +21509,7 @@
21447	21509	stack[base + 25] = stack[base + 28LLU];
21448	21510	if(!stack[base + 25]/found/)
21449	21511	{
21450		- label = 1391LLU; // jump to alternative
	21512	+ label = 1396LLU; // jump to alternative
21451	21513	break;
21452	21514	}
21453	21515

		@@ -21455,7 +21517,7 @@
21455	21517	fprintf(stderr, "%s", "in function-call - duplicate result-identifier ");
21456	21518	// call reportid from procblock
21457	21519	stack[base + 26LLU] = base;
21458		- stack[base + 27LLU] = 1393LLU;
	21520	+ stack[base + 27LLU] = 1398LLU;
21459	21521	// arguments for call to reportid
21460	21522	stack[base + 28LLU] = stack[base + 13]/content/;
21461	21523	// set stack-base & callee-address

		@@ -21463,26 +21525,26 @@
21463	21525	label = 18446744073709551587LLU; // reportid
21464	21526	break;
21465	21527	}
21466		- case 1393LLU: // return from reportid to procblock
	21528	+ case 1398LLU: // return from reportid to procblock
21467	21529	{
21468	21530	// copy mutable arguments back from call to reportid
21469	21531	fprintf(stderr, "%s", "\n");
21470	21532	exit(-1);
21471		- label = 1392LLU; // consequent complete
	21533	+ label = 1397LLU; // consequent complete
21472	21534	break;
21473	21535	}
21474		- case 1391LLU: // alternative
	21536	+ case 1396LLU: // alternative
21475	21537	{
21476		- label = 1392LLU; // alternative complete
	21538	+ label = 1397LLU; // alternative complete
21477	21539	break;
21478	21540	}
21479		- case 1392LLU: // completed if-then-else
	21541	+ case 1397LLU: // completed if-then-else
21480	21542	{
21481	21543	//#define idnr 26
21482	21544	stack[base + 26/idnr/] = 0; // init
21483	21545	// call mkidnr from procblock
21484	21546	stack[base + 27LLU] = base;
21485		- stack[base + 28LLU] = 1394LLU;
	21547	+ stack[base + 28LLU] = 1399LLU;
21486	21548	// arguments for call to mkidnr
21487	21549	stack[base + 30LLU] = stack[base + 13]/content/;
21488	21550	stack[base + 31LLU] = stack[base + 24]/mutable/;

		@@ -21491,7 +21553,7 @@
21491	21553	label = 246LLU; // mkidnr
21492	21554	break;
21493	21555	}
21494		- case 1394LLU: // return from mkidnr to procblock
	21556	+ case 1399LLU: // return from mkidnr to procblock
21495	21557	{
21496	21558	// copy mutable arguments back from call to mkidnr
21497	21559	// copy back results provided by call to mkidnr

		@@ -21504,7 +21566,7 @@
21504	21566	}
21505	21567	// call skipwscmnt from procblock
21506	21568	stack[base + 25LLU] = base;
21507		- stack[base + 26LLU] = 1395LLU;
	21569	+ stack[base + 26LLU] = 1400LLU;
21508	21570	// arguments for call to skipwscmnt
21509	21571	stack[base + 28LLU] = stack[base + 11]/lookahead/;
21510	21572	// set stack-base & callee-address

		@@ -21512,7 +21574,7 @@
21512	21574	label = 18446744073709551581LLU; // skipwscmnt
21513	21575	break;
21514	21576	}
21515		- case 1395LLU: // return from skipwscmnt to procblock
	21577	+ case 1400LLU: // return from skipwscmnt to procblock
21516	21578	{
21517	21579	// copy mutable arguments back from call to skipwscmnt
21518	21580	// copy back results provided by call to skipwscmnt

		@@ -21519,7 +21581,7 @@
21519	21581	stack[base + 11] = stack[base + 27LLU];
21520	21582	// call neq from procblock
21521	21583	stack[base + 25LLU] = base;
21522		- stack[base + 26LLU] = 1396LLU;
	21584	+ stack[base + 26LLU] = 1401LLU;
21523	21585	// arguments for call to neq
21524	21586	stack[base + 28LLU] = stack[base + 11]/lookahead/;
21525	21587	stack[base + 29LLU] = 41LLU;

		@@ -21528,7 +21590,7 @@
21528	21590	label = 18446744073709551599LLU; // neq
21529	21591	break;
21530	21592	}
21531		- case 1396LLU: // return from neq to procblock
	21593	+ case 1401LLU: // return from neq to procblock
21532	21594	{
21533	21595	// copy mutable arguments back from call to neq
21534	21596	// copy back results provided by call to neq

		@@ -21535,7 +21597,7 @@
21535	21597	stack[base + 23] = stack[base + 27LLU];
21536	21598	if(!stack[base + 23]/continue/)
21537	21599	{
21538		- label = 1397LLU; // jump to alternative
	21600	+ label = 1402LLU; // jump to alternative
21539	21601	break;
21540	21602	}
21541	21603

		@@ -21542,7 +21604,7 @@
21542	21604	// consequent
21543	21605	// call matchsym from procblock
21544	21606	stack[base + 25LLU] = base;
21545		- stack[base + 26LLU] = 1399LLU;
	21607	+ stack[base + 26LLU] = 1404LLU;
21546	21608	// arguments for call to matchsym
21547	21609	stack[base + 27LLU] = 44LLU;
21548	21610	stack[base + 28LLU] = stack[base + 11]/lookahead/;

		@@ -21551,33 +21613,33 @@
21551	21613	label = 27LLU; // matchsym
21552	21614	break;
21553	21615	}
21554		- case 1399LLU: // return from matchsym to procblock
	21616	+ case 1404LLU: // return from matchsym to procblock
21555	21617	{
21556	21618	// copy mutable arguments back from call to matchsym
21557	21619	stack[base + 11]/lookahead/ = stack[base + 28LLU];
21558		- label = 1398LLU; // consequent complete
	21620	+ label = 1403LLU; // consequent complete
21559	21621	break;
21560	21622	}
21561		- case 1397LLU: // alternative
	21623	+ case 1402LLU: // alternative
21562	21624	{
21563		- label = 1398LLU; // alternative complete
	21625	+ label = 1403LLU; // alternative complete
21564	21626	break;
21565	21627	}
21566		- case 1398LLU: // completed if-then-else
	21628	+ case 1403LLU: // completed if-then-else
21567	21629	{
21568		- label = 1375LLU; // repeat
	21630	+ label = 1380LLU; // repeat
21569	21631	break;
21570	21632	}
21571		- case 1376LLU: // loop finished
	21633	+ case 1381LLU: // loop finished
21572	21634	{
21573		- label = 1374LLU; // alternative complete
	21635	+ label = 1379LLU; // alternative complete
21574	21636	break;
21575	21637	}
21576		- case 1374LLU: // completed if-then-else
	21638	+ case 1379LLU: // completed if-then-else
21577	21639	{
21578	21640	// call matchsym from procblock
21579	21641	stack[base + 23LLU] = base;
21580		- stack[base + 24LLU] = 1400LLU;
	21642	+ stack[base + 24LLU] = 1405LLU;
21581	21643	// arguments for call to matchsym
21582	21644	stack[base + 25LLU] = 41LLU;
21583	21645	stack[base + 26LLU] = stack[base + 11]/lookahead/;

		@@ -21586,7 +21648,7 @@
21586	21648	label = 27LLU; // matchsym
21587	21649	break;
21588	21650	}
21589		- case 1400LLU: // return from matchsym to procblock
	21651	+ case 1405LLU: // return from matchsym to procblock
21590	21652	{
21591	21653	// copy mutable arguments back from call to matchsym
21592	21654	stack[base + 11]/lookahead/ = stack[base + 26LLU];

		@@ -21593,7 +21655,7 @@
21593	21655	list_reverse(((struct listnode *)(&stack[base + 21]/news*/)));
21594	21656	// call matchsym from procblock
21595	21657	stack[base + 23LLU] = base;
21596		- stack[base + 24LLU] = 1401LLU;
	21658	+ stack[base + 24LLU] = 1406LLU;
21597	21659	// arguments for call to matchsym
21598	21660	stack[base + 25LLU] = 61LLU;
21599	21661	stack[base + 26LLU] = stack[base + 11]/lookahead/;

		@@ -21602,13 +21664,13 @@
21602	21664	label = 27LLU; // matchsym
21603	21665	break;
21604	21666	}
21605		- case 1401LLU: // return from matchsym to procblock
	21667	+ case 1406LLU: // return from matchsym to procblock
21606	21668	{
21607	21669	// copy mutable arguments back from call to matchsym
21608	21670	stack[base + 11]/lookahead/ = stack[base + 26LLU];
21609	21671	// call parsetoken from procblock
21610	21672	stack[base + 23LLU] = base;
21611		- stack[base + 24LLU] = 1402LLU;
	21673	+ stack[base + 24LLU] = 1407LLU;
21612	21674	// arguments for call to parsetoken
21613	21675	stack[base + 28LLU] = stack[base + 11]/lookahead/;
21614	21676	// set stack-base & callee-address

		@@ -21616,7 +21678,7 @@
21616	21678	label = 18446744073709551585LLU; // parsetoken
21617	21679	break;
21618	21680	}
21619		- case 1402LLU: // return from parsetoken to procblock
	21681	+ case 1407LLU: // return from parsetoken to procblock
21620	21682	{
21621	21683	// copy mutable arguments back from call to parsetoken
21622	21684	// copy back results provided by call to parsetoken

		@@ -21625,7 +21687,7 @@
21625	21687	stack[base + 11] = stack[base + 27LLU];
21626	21688	// call equ from procblock
21627	21689	stack[base + 23LLU] = base;
21628		- stack[base + 24LLU] = 1403LLU;
	21690	+ stack[base + 24LLU] = 1408LLU;
21629	21691	// arguments for call to equ
21630	21692	stack[base + 26LLU] = stack[base + 12]/variant/;
21631	21693	stack[base + 27LLU] = 4LLU;

		@@ -21634,7 +21696,7 @@
21634	21696	label = 18446744073709551600LLU; // equ
21635	21697	break;
21636	21698	}
21637		- case 1403LLU: // return from equ to procblock
	21699	+ case 1408LLU: // return from equ to procblock
21638	21700	{
21639	21701	// copy mutable arguments back from call to equ
21640	21702	// copy back results provided by call to equ

		@@ -21641,20 +21703,20 @@
21641	21703	stack[base + 18] = stack[base + 25LLU];
21642	21704	if(!stack[base + 18]/isequal/)
21643	21705	{
21644		- label = 1404LLU; // jump to alternative
	21706	+ label = 1409LLU; // jump to alternative
21645	21707	break;
21646	21708	}
21647	21709
21648	21710	// consequent
21649		- label = 1405LLU; // consequent complete
	21711	+ label = 1410LLU; // consequent complete
21650	21712	break;
21651	21713	}
21652		- case 1404LLU: // alternative
	21714	+ case 1409LLU: // alternative
21653	21715	{
21654	21716	fprintf(stderr, "%s", "parsing function call expected identifier but found ");
21655	21717	// call reporttok from procblock
21656	21718	stack[base + 23LLU] = base;
21657		- stack[base + 24LLU] = 1406LLU;
	21719	+ stack[base + 24LLU] = 1411LLU;
21658	21720	// arguments for call to reporttok
21659	21721	stack[base + 25LLU] = stack[base + 12]/variant/;
21660	21722	stack[base + 26LLU] = stack[base + 13]/content/;

		@@ -21663,18 +21725,18 @@
21663	21725	label = 18446744073709551583LLU; // reporttok
21664	21726	break;
21665	21727	}
21666		- case 1406LLU: // return from reporttok to procblock
	21728	+ case 1411LLU: // return from reporttok to procblock
21667	21729	{
21668	21730	// copy mutable arguments back from call to reporttok
21669	21731	exit(-1);
21670		- label = 1405LLU; // alternative complete
	21732	+ label = 1410LLU; // alternative complete
21671	21733	break;
21672	21734	}
21673		- case 1405LLU: // completed if-then-else
	21735	+ case 1410LLU: // completed if-then-else
21674	21736	{
21675	21737	// call findfn from procblock
21676	21738	stack[base + 23LLU] = base;
21677		- stack[base + 24LLU] = 1407LLU;
	21739	+ stack[base + 24LLU] = 1412LLU;
21678	21740	// arguments for call to findfn
21679	21741	stack[base + 26LLU] = stack[base + 0]/fndefs/;
21680	21742	stack[base + 27LLU] = stack[base + 13]/content/;

		@@ -21683,7 +21745,7 @@
21683	21745	label = 386LLU; // findfn
21684	21746	break;
21685	21747	}
21686		- case 1407LLU: // return from findfn to procblock
	21748	+ case 1412LLU: // return from findfn to procblock
21687	21749	{
21688	21750	// copy mutable arguments back from call to findfn
21689	21751	// copy back results provided by call to findfn

		@@ -21690,7 +21752,7 @@
21690	21752	stack[base + 22] = stack[base + 25LLU];
21691	21753	if(/fndef/0 != ((uint64_t )(stack[base + 22]/calleedef*/))[0])
21692	21754	{
21693		- label = 1408LLU; // jump to alternative
	21755	+ label = 1413LLU; // jump to alternative
21694	21756	break;
21695	21757	}
21696	21758

		@@ -21714,14 +21776,14 @@
21714	21776	stack[base + 28/cerec/] = 0; // init
21715	21777	stack[base + 28]/cerec/ = ((uint64_t *)(stack[base + 22]/calleedef*/))[1][5];
21716	21778	assign(stack[base + 24]/cerestypes/, &stack[base + 29]/cerestypes/);
21717		- label = 1410LLU; // start to repeat
	21779	+ label = 1415LLU; // start to repeat
21718	21780	break;
21719	21781	}
21720		- case 1410LLU: // repeat from here
	21782	+ case 1415LLU: // repeat from here
21721	21783	{
21722	21784	if(!stack[base + 29]/cerestypes/)
21723	21785	{
21724		- label = 1411LLU; // break loop
	21786	+ label = 1416LLU; // break loop
21725	21787	break;
21726	21788	}
21727	21789

		@@ -21739,7 +21801,7 @@
21739	21801	struct listnode list = (struct listnode )stack[base + 21]/news/;
21740	21802	if(!list)
21741	21803	{
21742		- label = 1412LLU; // jump to alternative
	21804	+ label = 1417LLU; // jump to alternative
21743	21805	break;
21744	21806	}
21745	21807

		@@ -21749,15 +21811,15 @@
21749	21811	Free(1, sizeof(struct listnode), list);
21750	21812	stack[base + 21]/news/ = (uint64_t)next;
21751	21813	}
21752		- label = 1413LLU; // consequent complete
	21814	+ label = 1418LLU; // consequent complete
21753	21815	break;
21754	21816	}
21755		- case 1412LLU: // alternative
	21817	+ case 1417LLU: // alternative
21756	21818	{
21757	21819	fprintf(stderr, "%s", "in function ");
21758	21820	// call reportid from procblock
21759	21821	stack[base + 33LLU] = base;
21760		- stack[base + 34LLU] = 1414LLU;
	21822	+ stack[base + 34LLU] = 1419LLU;
21761	21823	// arguments for call to reportid
21762	21824	stack[base + 35LLU] = stack[base + 5]/fnid/;
21763	21825	// set stack-base & callee-address

		@@ -21765,13 +21827,13 @@
21765	21827	label = 18446744073709551587LLU; // reportid
21766	21828	break;
21767	21829	}
21768		- case 1414LLU: // return from reportid to procblock
	21830	+ case 1419LLU: // return from reportid to procblock
21769	21831	{
21770	21832	// copy mutable arguments back from call to reportid
21771	21833	fprintf(stderr, "%s", " call to ");
21772	21834	// call reportid from procblock
21773	21835	stack[base + 33LLU] = base;
21774		- stack[base + 34LLU] = 1415LLU;
	21836	+ stack[base + 34LLU] = 1420LLU;
21775	21837	// arguments for call to reportid
21776	21838	stack[base + 35LLU] = stack[base + 27]/ceid/;
21777	21839	// set stack-base & callee-address

		@@ -21779,20 +21841,20 @@
21779	21841	label = 18446744073709551587LLU; // reportid
21780	21842	break;
21781	21843	}
21782		- case 1415LLU: // return from reportid to procblock
	21844	+ case 1420LLU: // return from reportid to procblock
21783	21845	{
21784	21846	// copy mutable arguments back from call to reportid
21785	21847	fprintf(stderr, "%s", " not enough destination-variables for results");
21786	21848	fprintf(stderr, "%s", "\n");
21787	21849	exit(-1);
21788		- label = 1413LLU; // alternative complete
	21850	+ label = 1418LLU; // alternative complete
21789	21851	break;
21790	21852	}
21791		- case 1413LLU: // completed if-then-else
	21853	+ case 1418LLU: // completed if-then-else
21792	21854	{
21793	21855	if(/result/0 != ((uint64_t )(stack[base + 30]/result*/))[0])
21794	21856	{
21795		- label = 1416LLU; // jump to alternative
	21857	+ label = 1421LLU; // jump to alternative
21796	21858	break;
21797	21859	}
21798	21860

		@@ -21805,7 +21867,7 @@
21805	21867	stack[base + 34]/mutable/ = ((uint64_t *)(stack[base + 30]/result*/))[1][1];
21806	21868	if(/typeid/0 != ((uint64_t )(stack[base + 33]/typeid*/))[0])
21807	21869	{
21808		- label = 1418LLU; // jump to alternative
	21870	+ label = 1423LLU; // jump to alternative
21809	21871	break;
21810	21872	}
21811	21873

		@@ -21818,7 +21880,7 @@
21818	21880	stack[base + 36]/paramname/ = ((uint64_t *)(stack[base + 33]/typeid*/))[1][1];
21819	21881	if(/idnr/0 != ((uint64_t )(stack[base + 32]/RESULT*/))[0])
21820	21882	{
21821		- label = 1420LLU; // jump to alternative
	21883	+ label = 1425LLU; // jump to alternative
21822	21884	break;
21823	21885	}
21824	21886

		@@ -21836,7 +21898,7 @@
21836	21898	// call copytype from procblock
21837	21899	newstack[0] = (uint64_t)stack; // backup stack location
21838	21900	newstack[1] = base;
21839		- newstack[2] = 1422LLU;
	21901	+ newstack[2] = 1427LLU;
21840	21902	// arguments for call to copytype
21841	21903	newstack[4LLU] = stack[base + 35]/expected/;
21842	21904	stack = newstack;

		@@ -21845,7 +21907,7 @@
21845	21907	label = 82LLU; // copytype
21846	21908	break;
21847	21909	}
21848		- case 1422LLU: // return from copytype to procblock
	21910	+ case 1427LLU: // return from copytype to procblock
21849	21911	{
21850	21912	uint64_t oldstack = (uint64_t )stack[0];
21851	21913	// copy mutable arguments back from call to copytype

		@@ -21860,7 +21922,7 @@
21860	21922	stack = oldstack;
21861	21923	// call newvar from procblock
21862	21924	stack[base + 40LLU] = base;
21863		- stack[base + 41LLU] = 1423LLU;
	21925	+ stack[base + 41LLU] = 1428LLU;
21864	21926	// arguments for call to newvar
21865	21927	stack[base + 42LLU] = stack[base + 39]/type/;
21866	21928	stack[base + 43LLU] = stack[base + 37]/id/;

		@@ -21875,7 +21937,7 @@
21875	21937	label = 235LLU; // newvar
21876	21938	break;
21877	21939	}
21878		- case 1423LLU: // return from newvar to procblock
	21940	+ case 1428LLU: // return from newvar to procblock
21879	21941	{
21880	21942	// copy mutable arguments back from call to newvar
21881	21943	stack[base + 3]/scope/ = stack[base + 49LLU];

		@@ -21885,7 +21947,7 @@
21885	21947	stack[base + 40/INDEX/] = 0; // init
21886	21948	// call findletidx from procblock
21887	21949	stack[base + 41LLU] = base;
21888		- stack[base + 42LLU] = 1424LLU;
	21950	+ stack[base + 42LLU] = 1429LLU;
21889	21951	// arguments for call to findletidx
21890	21952	stack[base + 44LLU] = stack[base + 37]/id/;
21891	21953	stack[base + 45LLU] = stack[base + 2]/scopes/;

		@@ -21895,7 +21957,7 @@
21895	21957	label = 215LLU; // findletidx
21896	21958	break;
21897	21959	}
21898		- case 1424LLU: // return from findletidx to procblock
	21960	+ case 1429LLU: // return from findletidx to procblock
21899	21961	{
21900	21962	// copy mutable arguments back from call to findletidx
21901	21963	// copy back results provided by call to findletidx

		@@ -21915,55 +21977,55 @@
21915	21977	// releasing RESULT
21916	21978	Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 32]/RESULT*/)[1]);
21917	21979	Free(2, sizeof(uint64_t), (uint64_t )stack[base + 32]/RESULT*/);
21918		- label = 1421LLU; // consequent complete
	21980	+ label = 1426LLU; // consequent complete
21919	21981	break;
21920	21982	}
21921		- case 1420LLU: // alternative
	21983	+ case 1425LLU: // alternative
21922	21984	{
21923	21985	fprintf(stderr, "%s", "INTERNAL ERROR accessing idnr\n");
21924	21986	exit(-1);
21925		- label = 1421LLU; // alternative complete
	21987	+ label = 1426LLU; // alternative complete
21926	21988	break;
21927	21989	}
21928		- case 1421LLU: // completed if-then-else
	21990	+ case 1426LLU: // completed if-then-else
21929	21991	{
21930	21992	((uint64_t *)(stack[base + 33]/typeid/))[1][1] = stack[base + 36]/paramname*/;
21931	21993	((uint64_t *)(stack[base + 33]/typeid/))[1][0] = stack[base + 35]/expected*/;
21932		- label = 1419LLU; // consequent complete
	21994	+ label = 1424LLU; // consequent complete
21933	21995	break;
21934	21996	}
21935		- case 1418LLU: // alternative
	21997	+ case 1423LLU: // alternative
21936	21998	{
21937	21999	fprintf(stderr, "%s", "INTERNAL ERROR accessing typeid\n");
21938	22000	exit(-1);
21939		- label = 1419LLU; // alternative complete
	22001	+ label = 1424LLU; // alternative complete
21940	22002	break;
21941	22003	}
21942		- case 1419LLU: // completed if-then-else
	22004	+ case 1424LLU: // completed if-then-else
21943	22005	{
21944	22006	((uint64_t *)(stack[base + 30]/result/))[1][1] = stack[base + 34]/mutable*/;
21945	22007	((uint64_t *)(stack[base + 30]/result/))[1][0] = stack[base + 33]/typeid*/;
21946		- label = 1417LLU; // consequent complete
	22008	+ label = 1422LLU; // consequent complete
21947	22009	break;
21948	22010	}
21949		- case 1416LLU: // alternative
	22011	+ case 1421LLU: // alternative
21950	22012	{
21951	22013	fprintf(stderr, "%s", "INTERNAL ERROR accessing result\n");
21952	22014	exit(-1);
21953		- label = 1417LLU; // alternative complete
	22015	+ label = 1422LLU; // alternative complete
21954	22016	break;
21955	22017	}
21956		- case 1417LLU: // completed if-then-else
	22018	+ case 1422LLU: // completed if-then-else
21957	22019	{
21958	22020	((struct listnode )(stack[base + 31/previous/]))->data = stack[base + 30]/result*/;
21959		- label = 1410LLU; // repeat
	22021	+ label = 1415LLU; // repeat
21960	22022	break;
21961	22023	}
21962		- case 1411LLU: // loop finished
	22024	+ case 1416LLU: // loop finished
21963	22025	{
21964	22026	if(!stack[base + 21]/news/)
21965	22027	{
21966		- label = 1425LLU; // jump to alternative
	22028	+ label = 1430LLU; // jump to alternative
21967	22029	break;
21968	22030	}
21969	22031

		@@ -21971,7 +22033,7 @@
21971	22033	fprintf(stderr, "%s", "in function ");
21972	22034	// call reportid from procblock
21973	22035	stack[base + 32LLU] = base;
21974		- stack[base + 33LLU] = 1427LLU;
	22036	+ stack[base + 33LLU] = 1432LLU;
21975	22037	// arguments for call to reportid
21976	22038	stack[base + 34LLU] = stack[base + 5]/fnid/;
21977	22039	// set stack-base & callee-address

		@@ -21979,13 +22041,13 @@
21979	22041	label = 18446744073709551587LLU; // reportid
21980	22042	break;
21981	22043	}
21982		- case 1427LLU: // return from reportid to procblock
	22044	+ case 1432LLU: // return from reportid to procblock
21983	22045	{
21984	22046	// copy mutable arguments back from call to reportid
21985	22047	fprintf(stderr, "%s", " let-expression initialized by call to ");
21986	22048	// call reportid from procblock
21987	22049	stack[base + 32LLU] = base;
21988		- stack[base + 33LLU] = 1428LLU;
	22050	+ stack[base + 33LLU] = 1433LLU;
21989	22051	// arguments for call to reportid
21990	22052	stack[base + 34LLU] = stack[base + 27]/ceid/;
21991	22053	// set stack-base & callee-address

		@@ -21993,21 +22055,21 @@
21993	22055	label = 18446744073709551587LLU; // reportid
21994	22056	break;
21995	22057	}
21996		- case 1428LLU: // return from reportid to procblock
	22058	+ case 1433LLU: // return from reportid to procblock
21997	22059	{
21998	22060	// copy mutable arguments back from call to reportid
21999	22061	fprintf(stderr, "%s", " too many destination-variables");
22000	22062	fprintf(stderr, "%s", "\n");
22001	22063	exit(-1);
22002		- label = 1426LLU; // consequent complete
	22064	+ label = 1431LLU; // consequent complete
22003	22065	break;
22004	22066	}
22005		- case 1425LLU: // alternative
	22067	+ case 1430LLU: // alternative
22006	22068	{
22007		- label = 1426LLU; // alternative complete
	22069	+ label = 1431LLU; // alternative complete
22008	22070	break;
22009	22071	}
22010		- case 1426LLU: // completed if-then-else
	22072	+ case 1431LLU: // completed if-then-else
22011	22073	{
22012	22074	((uint64_t *)(stack[base + 22]/calleedef/))[1][5] = stack[base + 28]/cerec*/;
22013	22075	((uint64_t *)(stack[base + 22]/calleedef/))[1][4] = stack[base + 27]/ceid*/;

		@@ -22015,23 +22077,23 @@
22015	22077	((uint64_t *)(stack[base + 22]/calleedef/))[1][2] = stack[base + 25]/ceargtypes*/;
22016	22078	((uint64_t *)(stack[base + 22]/calleedef/))[1][1] = stack[base + 24]/cerestypes*/;
22017	22079	((uint64_t *)(stack[base + 22]/calleedef/))[1][0] = stack[base + 23]/celabel*/;
22018		- label = 1409LLU; // consequent complete
	22080	+ label = 1414LLU; // consequent complete
22019	22081	break;
22020	22082	}
22021		- case 1408LLU: // alternative
	22083	+ case 1413LLU: // alternative
22022	22084	{
22023	22085	fprintf(stderr, "%s", "INTERNAL ERROR accesing fndef");
22024	22086	exit(-1);
22025		- label = 1409LLU; // alternative complete
	22087	+ label = 1414LLU; // alternative complete
22026	22088	break;
22027	22089	}
22028		- case 1409LLU: // completed if-then-else
	22090	+ case 1414LLU: // completed if-then-else
22029	22091	{
22030	22092	list_reverse(((struct listnode *)(&stack[base + 19]/verified*/)));
22031	22093	list_reverse(((struct listnode *)(&stack[base + 20]/locked*/)));
22032	22094	// call matchsym from procblock
22033	22095	stack[base + 23LLU] = base;
22034		- stack[base + 24LLU] = 1429LLU;
	22096	+ stack[base + 24LLU] = 1434LLU;
22035	22097	// arguments for call to matchsym
22036	22098	stack[base + 25LLU] = 40LLU;
22037	22099	stack[base + 26LLU] = stack[base + 11]/lookahead/;

		@@ -22040,13 +22102,13 @@
22040	22102	label = 27LLU; // matchsym
22041	22103	break;
22042	22104	}
22043		- case 1429LLU: // return from matchsym to procblock
	22105	+ case 1434LLU: // return from matchsym to procblock
22044	22106	{
22045	22107	// copy mutable arguments back from call to matchsym
22046	22108	stack[base + 11]/lookahead/ = stack[base + 26LLU];
22047	22109	// call ProcCall from procblock
22048	22110	stack[base + 23LLU] = base;
22049		- stack[base + 24LLU] = 1430LLU;
	22111	+ stack[base + 24LLU] = 1435LLU;
22050	22112	// arguments for call to ProcCall
22051	22113	stack[base + 25LLU] = stack[base + 19]/verified/;
22052	22114	stack[base + 26LLU] = stack[base + 20]/locked/;

		@@ -22070,7 +22132,7 @@
22070	22132	label = 430LLU; // ProcCall
22071	22133	break;
22072	22134	}
22073		- case 1430LLU: // return from ProcCall to procblock
	22135	+ case 1435LLU: // return from ProcCall to procblock
22074	22136	{
22075	22137	// copy mutable arguments back from call to ProcCall
22076	22138	stack[base + 14]/label/ = stack[base + 41LLU];

		@@ -22080,10 +22142,10 @@
22080	22142	stack[base + 9]/fnmaxcount/ = stack[base + 36LLU];
22081	22143	stack[base + 20]/locked/ = stack[base + 26LLU];
22082	22144	stack[base + 19]/verified/ = stack[base + 25LLU];
22083		- label = 1370LLU; // consequent complete
	22145	+ label = 1375LLU; // consequent complete
22084	22146	break;
22085	22147	}
22086		- case 1369LLU: // alternative
	22148	+ case 1374LLU: // alternative
22087	22149	{
22088	22150	//#define mutable 19
22089	22151	stack[base + 19/mutable/] = 0; // init

		@@ -22090,7 +22152,7 @@
22090	22152	stack[base + 19]/mutable/ = 0;
22091	22153	// call equ from procblock
22092	22154	stack[base + 20LLU] = base;
22093		- stack[base + 21LLU] = 1431LLU;
	22155	+ stack[base + 21LLU] = 1436LLU;
22094	22156	// arguments for call to equ
22095	22157	stack[base + 23LLU] = stack[base + 12]/variant/;
22096	22158	stack[base + 24LLU] = 4LLU;

		@@ -22099,7 +22161,7 @@
22099	22161	label = 18446744073709551600LLU; // equ
22100	22162	break;
22101	22163	}
22102		- case 1431LLU: // return from equ to procblock
	22164	+ case 1436LLU: // return from equ to procblock
22103	22165	{
22104	22166	// copy mutable arguments back from call to equ
22105	22167	// copy back results provided by call to equ

		@@ -22106,7 +22168,7 @@
22106	22168	stack[base + 18] = stack[base + 22LLU];
22107	22169	if(!stack[base + 18]/isequal/)
22108	22170	{
22109		- label = 1432LLU; // jump to alternative
	22171	+ label = 1437LLU; // jump to alternative
22110	22172	break;
22111	22173	}
22112	22174

		@@ -22113,7 +22175,7 @@
22113	22175	// consequent
22114	22176	// call equ from procblock
22115	22177	stack[base + 20LLU] = base;
22116		- stack[base + 21LLU] = 1434LLU;
	22178	+ stack[base + 21LLU] = 1439LLU;
22117	22179	// arguments for call to equ
22118	22180	stack[base + 23LLU] = stack[base + 13]/content/;
22119	22181	stack[base + 24LLU] = 734293447447412736LLU;

		@@ -22122,7 +22184,7 @@
22122	22184	label = 18446744073709551600LLU; // equ
22123	22185	break;
22124	22186	}
22125		- case 1434LLU: // return from equ to procblock
	22187	+ case 1439LLU: // return from equ to procblock
22126	22188	{
22127	22189	// copy mutable arguments back from call to equ
22128	22190	// copy back results provided by call to equ

		@@ -22129,7 +22191,7 @@
22129	22191	stack[base + 18] = stack[base + 22LLU];
22130	22192	if(!stack[base + 18]/isequal/)
22131	22193	{
22132		- label = 1435LLU; // jump to alternative
	22194	+ label = 1440LLU; // jump to alternative
22133	22195	break;
22134	22196	}
22135	22197

		@@ -22137,7 +22199,7 @@
22137	22199	stack[base + 19]/mutable/ = 1;
22138	22200	// call parsetoken from procblock
22139	22201	stack[base + 20LLU] = base;
22140		- stack[base + 21LLU] = 1437LLU;
	22202	+ stack[base + 21LLU] = 1442LLU;
22141	22203	// arguments for call to parsetoken
22142	22204	stack[base + 25LLU] = stack[base + 11]/lookahead/;
22143	22205	// set stack-base & callee-address

		@@ -22145,7 +22207,7 @@
22145	22207	label = 18446744073709551585LLU; // parsetoken
22146	22208	break;
22147	22209	}
22148		- case 1437LLU: // return from parsetoken to procblock
	22210	+ case 1442LLU: // return from parsetoken to procblock
22149	22211	{
22150	22212	// copy mutable arguments back from call to parsetoken
22151	22213	// copy back results provided by call to parsetoken

		@@ -22154,7 +22216,7 @@
22154	22216	stack[base + 11] = stack[base + 24LLU];
22155	22217	// call equ from procblock
22156	22218	stack[base + 20LLU] = base;
22157		- stack[base + 21LLU] = 1438LLU;
	22219	+ stack[base + 21LLU] = 1443LLU;
22158	22220	// arguments for call to equ
22159	22221	stack[base + 23LLU] = stack[base + 12]/variant/;
22160	22222	stack[base + 24LLU] = 4LLU;

		@@ -22163,7 +22225,7 @@
22163	22225	label = 18446744073709551600LLU; // equ
22164	22226	break;
22165	22227	}
22166		- case 1438LLU: // return from equ to procblock
	22228	+ case 1443LLU: // return from equ to procblock
22167	22229	{
22168	22230	// copy mutable arguments back from call to equ
22169	22231	// copy back results provided by call to equ

		@@ -22170,20 +22232,20 @@
22170	22232	stack[base + 18] = stack[base + 22LLU];
22171	22233	if(!stack[base + 18]/isequal/)
22172	22234	{
22173		- label = 1439LLU; // jump to alternative
	22235	+ label = 1444LLU; // jump to alternative
22174	22236	break;
22175	22237	}
22176	22238
22177	22239	// consequent
22178		- label = 1440LLU; // consequent complete
	22240	+ label = 1445LLU; // consequent complete
22179	22241	break;
22180	22242	}
22181		- case 1439LLU: // alternative
	22243	+ case 1444LLU: // alternative
22182	22244	{
22183	22245	fprintf(stderr, "%s", "let expects identifier but found ");
22184	22246	// call reporttok from procblock
22185	22247	stack[base + 20LLU] = base;
22186		- stack[base + 21LLU] = 1441LLU;
	22248	+ stack[base + 21LLU] = 1446LLU;
22187	22249	// arguments for call to reporttok
22188	22250	stack[base + 22LLU] = stack[base + 12]/variant/;
22189	22251	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -22192,34 +22254,34 @@
22192	22254	label = 18446744073709551583LLU; // reporttok
22193	22255	break;
22194	22256	}
22195		- case 1441LLU: // return from reporttok to procblock
	22257	+ case 1446LLU: // return from reporttok to procblock
22196	22258	{
22197	22259	// copy mutable arguments back from call to reporttok
22198	22260	exit(-1);
22199		- label = 1440LLU; // alternative complete
	22261	+ label = 1445LLU; // alternative complete
22200	22262	break;
22201	22263	}
22202		- case 1440LLU: // completed if-then-else
	22264	+ case 1445LLU: // completed if-then-else
22203	22265	{
22204		- label = 1436LLU; // consequent complete
	22266	+ label = 1441LLU; // consequent complete
22205	22267	break;
22206	22268	}
22207		- case 1435LLU: // alternative
	22269	+ case 1440LLU: // alternative
22208	22270	{
22209		- label = 1436LLU; // alternative complete
	22271	+ label = 1441LLU; // alternative complete
22210	22272	break;
22211	22273	}
22212		- case 1436LLU: // completed if-then-else
	22274	+ case 1441LLU: // completed if-then-else
22213	22275	{
22214		- label = 1433LLU; // consequent complete
	22276	+ label = 1438LLU; // consequent complete
22215	22277	break;
22216	22278	}
22217		- case 1432LLU: // alternative
	22279	+ case 1437LLU: // alternative
22218	22280	{
22219	22281	fprintf(stderr, "%s", "let expects identifier but found ");
22220	22282	// call reporttok from procblock
22221	22283	stack[base + 20LLU] = base;
22222		- stack[base + 21LLU] = 1442LLU;
	22284	+ stack[base + 21LLU] = 1447LLU;
22223	22285	// arguments for call to reporttok
22224	22286	stack[base + 22LLU] = stack[base + 12]/variant/;
22225	22287	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -22228,14 +22290,14 @@
22228	22290	label = 18446744073709551583LLU; // reporttok
22229	22291	break;
22230	22292	}
22231		- case 1442LLU: // return from reporttok to procblock
	22293	+ case 1447LLU: // return from reporttok to procblock
22232	22294	{
22233	22295	// copy mutable arguments back from call to reporttok
22234	22296	exit(-1);
22235		- label = 1433LLU; // alternative complete
	22297	+ label = 1438LLU; // alternative complete
22236	22298	break;
22237	22299	}
22238		- case 1433LLU: // completed if-then-else
	22300	+ case 1438LLU: // completed if-then-else
22239	22301	{
22240	22302	//#define id 20
22241	22303	stack[base + 20/id/] = 0; // init

		@@ -22242,7 +22304,7 @@
22242	22304	stack[base + 20]/id/ = stack[base + 13]/content/;
22243	22305	// call matchsym from procblock
22244	22306	stack[base + 21LLU] = base;
22245		- stack[base + 22LLU] = 1443LLU;
	22307	+ stack[base + 22LLU] = 1448LLU;
22246	22308	// arguments for call to matchsym
22247	22309	stack[base + 23LLU] = 61LLU;
22248	22310	stack[base + 24LLU] = stack[base + 11]/lookahead/;

		@@ -22251,13 +22313,13 @@
22251	22313	label = 27LLU; // matchsym
22252	22314	break;
22253	22315	}
22254		- case 1443LLU: // return from matchsym to procblock
	22316	+ case 1448LLU: // return from matchsym to procblock
22255	22317	{
22256	22318	// copy mutable arguments back from call to matchsym
22257	22319	stack[base + 11]/lookahead/ = stack[base + 24LLU];
22258	22320	// call parsetoken from procblock
22259	22321	stack[base + 21LLU] = base;
22260		- stack[base + 22LLU] = 1444LLU;
	22322	+ stack[base + 22LLU] = 1449LLU;
22261	22323	// arguments for call to parsetoken
22262	22324	stack[base + 26LLU] = stack[base + 11]/lookahead/;
22263	22325	// set stack-base & callee-address

		@@ -22265,7 +22327,7 @@
22265	22327	label = 18446744073709551585LLU; // parsetoken
22266	22328	break;
22267	22329	}
22268		- case 1444LLU: // return from parsetoken to procblock
	22330	+ case 1449LLU: // return from parsetoken to procblock
22269	22331	{
22270	22332	// copy mutable arguments back from call to parsetoken
22271	22333	// copy back results provided by call to parsetoken

		@@ -22274,7 +22336,7 @@
22274	22336	stack[base + 11] = stack[base + 25LLU];
22275	22337	// call assignfrom from procblock
22276	22338	stack[base + 21LLU] = base;
22277		- stack[base + 22LLU] = 1445LLU;
	22339	+ stack[base + 22LLU] = 1450LLU;
22278	22340	// arguments for call to assignfrom
22279	22341	stack[base + 23LLU] = stack[base + 5]/fnid/;
22280	22342	stack[base + 24LLU] = stack[base + 20]/id/;

		@@ -22294,7 +22356,7 @@
22294	22356	label = 804LLU; // assignfrom
22295	22357	break;
22296	22358	}
22297		- case 1445LLU: // return from assignfrom to procblock
	22359	+ case 1450LLU: // return from assignfrom to procblock
22298	22360	{
22299	22361	// copy mutable arguments back from call to assignfrom
22300	22362	stack[base + 13]/content/ = stack[base + 35LLU];

		@@ -22303,19 +22365,19 @@
22303	22365	stack[base + 16]/varcount/ = stack[base + 32LLU];
22304	22366	stack[base + 9]/fnmaxcount/ = stack[base + 31LLU];
22305	22367	stack[base + 3]/scope/ = stack[base + 28LLU];
22306		- label = 1370LLU; // alternative complete
	22368	+ label = 1375LLU; // alternative complete
22307	22369	break;
22308	22370	}
22309		- case 1370LLU: // completed if-then-else
	22371	+ case 1375LLU: // completed if-then-else
22310	22372	{
22311		- label = 1366LLU; // consequent complete
	22373	+ label = 1371LLU; // consequent complete
22312	22374	break;
22313	22375	}
22314		- case 1365LLU: // alternative
	22376	+ case 1370LLU: // alternative
22315	22377	{
22316	22378	// call equ from procblock
22317	22379	stack[base + 19LLU] = base;
22318		- stack[base + 20LLU] = 1446LLU;
	22380	+ stack[base + 20LLU] = 1451LLU;
22319	22381	// arguments for call to equ
22320	22382	stack[base + 22LLU] = stack[base + 13]/content/;
22321	22383	stack[base + 23LLU] = 567601207044997120LLU;

		@@ -22324,7 +22386,7 @@
22324	22386	label = 18446744073709551600LLU; // equ
22325	22387	break;
22326	22388	}
22327		- case 1446LLU: // return from equ to procblock
	22389	+ case 1451LLU: // return from equ to procblock
22328	22390	{
22329	22391	// copy mutable arguments back from call to equ
22330	22392	// copy back results provided by call to equ

		@@ -22331,7 +22393,7 @@
22331	22393	stack[base + 18] = stack[base + 21LLU];
22332	22394	if(!stack[base + 18]/isequal/)
22333	22395	{
22334		- label = 1447LLU; // jump to alternative
	22396	+ label = 1452LLU; // jump to alternative
22335	22397	break;
22336	22398	}
22337	22399

		@@ -22338,7 +22400,7 @@
22338	22400	// consequent
22339	22401	// call parsetoken from procblock
22340	22402	stack[base + 19LLU] = base;
22341		- stack[base + 20LLU] = 1449LLU;
	22403	+ stack[base + 20LLU] = 1454LLU;
22342	22404	// arguments for call to parsetoken
22343	22405	stack[base + 24LLU] = stack[base + 11]/lookahead/;
22344	22406	// set stack-base & callee-address

		@@ -22346,7 +22408,7 @@
22346	22408	label = 18446744073709551585LLU; // parsetoken
22347	22409	break;
22348	22410	}
22349		- case 1449LLU: // return from parsetoken to procblock
	22411	+ case 1454LLU: // return from parsetoken to procblock
22350	22412	{
22351	22413	// copy mutable arguments back from call to parsetoken
22352	22414	// copy back results provided by call to parsetoken

		@@ -22355,7 +22417,7 @@
22355	22417	stack[base + 11] = stack[base + 23LLU];
22356	22418	// call equ from procblock
22357	22419	stack[base + 19LLU] = base;
22358		- stack[base + 20LLU] = 1450LLU;
	22420	+ stack[base + 20LLU] = 1455LLU;
22359	22421	// arguments for call to equ
22360	22422	stack[base + 22LLU] = stack[base + 12]/variant/;
22361	22423	stack[base + 23LLU] = 4LLU;

		@@ -22364,7 +22426,7 @@
22364	22426	label = 18446744073709551600LLU; // equ
22365	22427	break;
22366	22428	}
22367		- case 1450LLU: // return from equ to procblock
	22429	+ case 1455LLU: // return from equ to procblock
22368	22430	{
22369	22431	// copy mutable arguments back from call to equ
22370	22432	// copy back results provided by call to equ

		@@ -22371,7 +22433,7 @@
22371	22433	stack[base + 18] = stack[base + 21LLU];
22372	22434	if(!stack[base + 18]/isequal/)
22373	22435	{
22374		- label = 1451LLU; // jump to alternative
	22436	+ label = 1456LLU; // jump to alternative
22375	22437	break;
22376	22438	}
22377	22439

		@@ -22379,7 +22441,7 @@
22379	22441	printf("%s", "\n#define ");
22380	22442	// call printid from procblock
22381	22443	stack[base + 19LLU] = base;
22382		- stack[base + 20LLU] = 1453LLU;
	22444	+ stack[base + 20LLU] = 1458LLU;
22383	22445	// arguments for call to printid
22384	22446	stack[base + 21LLU] = stack[base + 13]/content/;
22385	22447	// set stack-base & callee-address

		@@ -22387,13 +22449,13 @@
22387	22449	label = 18446744073709551588LLU; // printid
22388	22450	break;
22389	22451	}
22390		- case 1453LLU: // return from printid to procblock
	22452	+ case 1458LLU: // return from printid to procblock
22391	22453	{
22392	22454	// copy mutable arguments back from call to printid
22393	22455	printf("%s", " ");
22394	22456	// call emitindex from procblock
22395	22457	stack[base + 19LLU] = base;
22396		- stack[base + 20LLU] = 1454LLU;
	22458	+ stack[base + 20LLU] = 1459LLU;
22397	22459	// arguments for call to emitindex
22398	22460	stack[base + 21LLU] = stack[base + 13]/content/;
22399	22461	stack[base + 22LLU] = stack[base + 2]/scopes/;

		@@ -22403,18 +22465,18 @@
22403	22465	label = 219LLU; // emitindex
22404	22466	break;
22405	22467	}
22406		- case 1454LLU: // return from emitindex to procblock
	22468	+ case 1459LLU: // return from emitindex to procblock
22407	22469	{
22408	22470	// copy mutable arguments back from call to emitindex
22409		- label = 1452LLU; // consequent complete
	22471	+ label = 1457LLU; // consequent complete
22410	22472	break;
22411	22473	}
22412		- case 1451LLU: // alternative
	22474	+ case 1456LLU: // alternative
22413	22475	{
22414	22476	fprintf(stderr, "%s", "expected identifier in define but found ");
22415	22477	// call reporttok from procblock
22416	22478	stack[base + 19LLU] = base;
22417		- stack[base + 20LLU] = 1455LLU;
	22479	+ stack[base + 20LLU] = 1460LLU;
22418	22480	// arguments for call to reporttok
22419	22481	stack[base + 21LLU] = stack[base + 12]/variant/;
22420	22482	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -22423,24 +22485,24 @@
22423	22485	label = 18446744073709551583LLU; // reporttok
22424	22486	break;
22425	22487	}
22426		- case 1455LLU: // return from reporttok to procblock
	22488	+ case 1460LLU: // return from reporttok to procblock
22427	22489	{
22428	22490	// copy mutable arguments back from call to reporttok
22429	22491	fprintf(stderr, "%s", "\n");
22430	22492	exit(-1);
22431		- label = 1452LLU; // alternative complete
	22493	+ label = 1457LLU; // alternative complete
22432	22494	break;
22433	22495	}
22434		- case 1452LLU: // completed if-then-else
	22496	+ case 1457LLU: // completed if-then-else
22435	22497	{
22436		- label = 1448LLU; // consequent complete
	22498	+ label = 1453LLU; // consequent complete
22437	22499	break;
22438	22500	}
22439		- case 1447LLU: // alternative
	22501	+ case 1452LLU: // alternative
22440	22502	{
22441	22503	// call equ from procblock
22442	22504	stack[base + 19LLU] = base;
22443		- stack[base + 20LLU] = 1456LLU;
	22505	+ stack[base + 20LLU] = 1461LLU;
22444	22506	// arguments for call to equ
22445	22507	stack[base + 22LLU] = stack[base + 13]/content/;
22446	22508	stack[base + 23LLU] = 876370176398852096LLU;

		@@ -22449,7 +22511,7 @@
22449	22511	label = 18446744073709551600LLU; // equ
22450	22512	break;
22451	22513	}
22452		- case 1456LLU: // return from equ to procblock
	22514	+ case 1461LLU: // return from equ to procblock
22453	22515	{
22454	22516	// copy mutable arguments back from call to equ
22455	22517	// copy back results provided by call to equ

		@@ -22456,7 +22518,7 @@
22456	22518	stack[base + 18] = stack[base + 21LLU];
22457	22519	if(!stack[base + 18]/isequal/)
22458	22520	{
22459		- label = 1457LLU; // jump to alternative
	22521	+ label = 1462LLU; // jump to alternative
22460	22522	break;
22461	22523	}
22462	22524

		@@ -22463,7 +22525,7 @@
22463	22525	// consequent
22464	22526	// call parsetoken from procblock
22465	22527	stack[base + 19LLU] = base;
22466		- stack[base + 20LLU] = 1459LLU;
	22528	+ stack[base + 20LLU] = 1464LLU;
22467	22529	// arguments for call to parsetoken
22468	22530	stack[base + 24LLU] = stack[base + 11]/lookahead/;
22469	22531	// set stack-base & callee-address

		@@ -22471,7 +22533,7 @@
22471	22533	label = 18446744073709551585LLU; // parsetoken
22472	22534	break;
22473	22535	}
22474		- case 1459LLU: // return from parsetoken to procblock
	22536	+ case 1464LLU: // return from parsetoken to procblock
22475	22537	{
22476	22538	// copy mutable arguments back from call to parsetoken
22477	22539	// copy back results provided by call to parsetoken

		@@ -22480,7 +22542,7 @@
22480	22542	stack[base + 11] = stack[base + 23LLU];
22481	22543	// call equ from procblock
22482	22544	stack[base + 19LLU] = base;
22483		- stack[base + 20LLU] = 1460LLU;
	22545	+ stack[base + 20LLU] = 1465LLU;
22484	22546	// arguments for call to equ
22485	22547	stack[base + 22LLU] = stack[base + 12]/variant/;
22486	22548	stack[base + 23LLU] = 4LLU;

		@@ -22489,7 +22551,7 @@
22489	22551	label = 18446744073709551600LLU; // equ
22490	22552	break;
22491	22553	}
22492		- case 1460LLU: // return from equ to procblock
	22554	+ case 1465LLU: // return from equ to procblock
22493	22555	{
22494	22556	// copy mutable arguments back from call to equ
22495	22557	// copy back results provided by call to equ

		@@ -22496,7 +22558,7 @@
22496	22558	stack[base + 18] = stack[base + 21LLU];
22497	22559	if(!stack[base + 18]/isequal/)
22498	22560	{
22499		- label = 1461LLU; // jump to alternative
	22561	+ label = 1466LLU; // jump to alternative
22500	22562	break;
22501	22563	}
22502	22564

		@@ -22504,7 +22566,7 @@
22504	22566	printf("%s", "\n#undef ");
22505	22567	// call printid from procblock
22506	22568	stack[base + 19LLU] = base;
22507		- stack[base + 20LLU] = 1463LLU;
	22569	+ stack[base + 20LLU] = 1468LLU;
22508	22570	// arguments for call to printid
22509	22571	stack[base + 21LLU] = stack[base + 13]/content/;
22510	22572	// set stack-base & callee-address

		@@ -22512,18 +22574,18 @@
22512	22574	label = 18446744073709551588LLU; // printid
22513	22575	break;
22514	22576	}
22515		- case 1463LLU: // return from printid to procblock
	22577	+ case 1468LLU: // return from printid to procblock
22516	22578	{
22517	22579	// copy mutable arguments back from call to printid
22518		- label = 1462LLU; // consequent complete
	22580	+ label = 1467LLU; // consequent complete
22519	22581	break;
22520	22582	}
22521		- case 1461LLU: // alternative
	22583	+ case 1466LLU: // alternative
22522	22584	{
22523	22585	fprintf(stderr, "%s", "expected identifier in define but found ");
22524	22586	// call reporttok from procblock
22525	22587	stack[base + 19LLU] = base;
22526		- stack[base + 20LLU] = 1464LLU;
	22588	+ stack[base + 20LLU] = 1469LLU;
22527	22589	// arguments for call to reporttok
22528	22590	stack[base + 21LLU] = stack[base + 12]/variant/;
22529	22591	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -22532,24 +22594,24 @@
22532	22594	label = 18446744073709551583LLU; // reporttok
22533	22595	break;
22534	22596	}
22535		- case 1464LLU: // return from reporttok to procblock
	22597	+ case 1469LLU: // return from reporttok to procblock
22536	22598	{
22537	22599	// copy mutable arguments back from call to reporttok
22538	22600	fprintf(stderr, "%s", "\n");
22539	22601	exit(-1);
22540		- label = 1462LLU; // alternative complete
	22602	+ label = 1467LLU; // alternative complete
22541	22603	break;
22542	22604	}
22543		- case 1462LLU: // completed if-then-else
	22605	+ case 1467LLU: // completed if-then-else
22544	22606	{
22545		- label = 1458LLU; // consequent complete
	22607	+ label = 1463LLU; // consequent complete
22546	22608	break;
22547	22609	}
22548		- case 1457LLU: // alternative
	22610	+ case 1462LLU: // alternative
22549	22611	{
22550	22612	// call equ from procblock
22551	22613	stack[base + 19LLU] = base;
22552		- stack[base + 20LLU] = 1465LLU;
	22614	+ stack[base + 20LLU] = 1470LLU;
22553	22615	// arguments for call to equ
22554	22616	stack[base + 22LLU] = stack[base + 13]/content/;
22555	22617	stack[base + 23LLU] = 788334650111033344LLU;

		@@ -22558,7 +22620,7 @@
22558	22620	label = 18446744073709551600LLU; // equ
22559	22621	break;
22560	22622	}
22561		- case 1465LLU: // return from equ to procblock
	22623	+ case 1470LLU: // return from equ to procblock
22562	22624	{
22563	22625	// copy mutable arguments back from call to equ
22564	22626	// copy back results provided by call to equ

		@@ -22565,7 +22627,7 @@
22565	22627	stack[base + 18] = stack[base + 21LLU];
22566	22628	if(!stack[base + 18]/isequal/)
22567	22629	{
22568		- label = 1466LLU; // jump to alternative
	22630	+ label = 1471LLU; // jump to alternative
22569	22631	break;
22570	22632	}
22571	22633

		@@ -22572,7 +22634,7 @@
22572	22634	// consequent
22573	22635	// call matchsym from procblock
22574	22636	stack[base + 19LLU] = base;
22575		- stack[base + 20LLU] = 1468LLU;
	22637	+ stack[base + 20LLU] = 1473LLU;
22576	22638	// arguments for call to matchsym
22577	22639	stack[base + 21LLU] = 40LLU;
22578	22640	stack[base + 22LLU] = stack[base + 11]/lookahead/;

		@@ -22581,13 +22643,13 @@
22581	22643	label = 27LLU; // matchsym
22582	22644	break;
22583	22645	}
22584		- case 1468LLU: // return from matchsym to procblock
	22646	+ case 1473LLU: // return from matchsym to procblock
22585	22647	{
22586	22648	// copy mutable arguments back from call to matchsym
22587	22649	stack[base + 11]/lookahead/ = stack[base + 22LLU];
22588	22650	// call parsetoken from procblock
22589	22651	stack[base + 19LLU] = base;
22590		- stack[base + 20LLU] = 1469LLU;
	22652	+ stack[base + 20LLU] = 1474LLU;
22591	22653	// arguments for call to parsetoken
22592	22654	stack[base + 24LLU] = stack[base + 11]/lookahead/;
22593	22655	// set stack-base & callee-address

		@@ -22595,7 +22657,7 @@
22595	22657	label = 18446744073709551585LLU; // parsetoken
22596	22658	break;
22597	22659	}
22598		- case 1469LLU: // return from parsetoken to procblock
	22660	+ case 1474LLU: // return from parsetoken to procblock
22599	22661	{
22600	22662	// copy mutable arguments back from call to parsetoken
22601	22663	// copy back results provided by call to parsetoken

		@@ -22604,7 +22666,7 @@
22604	22666	stack[base + 11] = stack[base + 23LLU];
22605	22667	// call equ from procblock
22606	22668	stack[base + 19LLU] = base;
22607		- stack[base + 20LLU] = 1470LLU;
	22669	+ stack[base + 20LLU] = 1475LLU;
22608	22670	// arguments for call to equ
22609	22671	stack[base + 22LLU] = stack[base + 12]/variant/;
22610	22672	stack[base + 23LLU] = 4LLU;

		@@ -22613,7 +22675,7 @@
22613	22675	label = 18446744073709551600LLU; // equ
22614	22676	break;
22615	22677	}
22616		- case 1470LLU: // return from equ to procblock
	22678	+ case 1475LLU: // return from equ to procblock
22617	22679	{
22618	22680	// copy mutable arguments back from call to equ
22619	22681	// copy back results provided by call to equ

		@@ -22620,7 +22682,7 @@
22620	22682	stack[base + 18] = stack[base + 21LLU];
22621	22683	if(!stack[base + 18]/isequal/)
22622	22684	{
22623		- label = 1471LLU; // jump to alternative
	22685	+ label = 1476LLU; // jump to alternative
22624	22686	break;
22625	22687	}
22626	22688

		@@ -22631,7 +22693,7 @@
22631	22693	stack[base + 20/index/] = 0; // init
22632	22694	// call findlet from procblock
22633	22695	stack[base + 21LLU] = base;
22634		- stack[base + 22LLU] = 1473LLU;
	22696	+ stack[base + 22LLU] = 1478LLU;
22635	22697	// arguments for call to findlet
22636	22698	stack[base + 25LLU] = stack[base + 13]/content/;
22637	22699	stack[base + 26LLU] = stack[base + 2]/scopes/;

		@@ -22641,7 +22703,7 @@
22641	22703	label = 213LLU; // findlet
22642	22704	break;
22643	22705	}
22644		- case 1473LLU: // return from findlet to procblock
	22706	+ case 1478LLU: // return from findlet to procblock
22645	22707	{
22646	22708	// copy mutable arguments back from call to findlet
22647	22709	// copy back results provided by call to findlet

		@@ -22652,7 +22714,7 @@
22652	22714	printf("%s", "\n list->next = (struct listnode *)");
22653	22715	// call emitvar from procblock
22654	22716	stack[base + 20LLU] = base;
22655		- stack[base + 21LLU] = 1474LLU;
	22717	+ stack[base + 21LLU] = 1479LLU;
22656	22718	// arguments for call to emitvar
22657	22719	stack[base + 22LLU] = stack[base + 13]/content/;
22658	22720	stack[base + 23LLU] = stack[base + 2]/scopes/;

		@@ -22662,7 +22724,7 @@
22662	22724	label = 224LLU; // emitvar
22663	22725	break;
22664	22726	}
22665		- case 1474LLU: // return from emitvar to procblock
	22727	+ case 1479LLU: // return from emitvar to procblock
22666	22728	{
22667	22729	// copy mutable arguments back from call to emitvar
22668	22730	printf("%s", ";");

		@@ -22669,7 +22731,7 @@
22669	22731	printf("%s", "\n ");
22670	22732	// call emitvar from procblock
22671	22733	stack[base + 20LLU] = base;
22672		- stack[base + 21LLU] = 1475LLU;
	22734	+ stack[base + 21LLU] = 1480LLU;
22673	22735	// arguments for call to emitvar
22674	22736	stack[base + 22LLU] = stack[base + 13]/content/;
22675	22737	stack[base + 23LLU] = stack[base + 2]/scopes/;

		@@ -22679,13 +22741,13 @@
22679	22741	label = 224LLU; // emitvar
22680	22742	break;
22681	22743	}
22682		- case 1475LLU: // return from emitvar to procblock
	22744	+ case 1480LLU: // return from emitvar to procblock
22683	22745	{
22684	22746	// copy mutable arguments back from call to emitvar
22685	22747	printf("%s", " = (uint64_t)list;");
22686	22748	// call matchsym from procblock
22687	22749	stack[base + 20LLU] = base;
22688		- stack[base + 21LLU] = 1476LLU;
	22750	+ stack[base + 21LLU] = 1481LLU;
22689	22751	// arguments for call to matchsym
22690	22752	stack[base + 22LLU] = 44LLU;
22691	22753	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -22694,13 +22756,13 @@
22694	22756	label = 27LLU; // matchsym
22695	22757	break;
22696	22758	}
22697		- case 1476LLU: // return from matchsym to procblock
	22759	+ case 1481LLU: // return from matchsym to procblock
22698	22760	{
22699	22761	// copy mutable arguments back from call to matchsym
22700	22762	stack[base + 11]/lookahead/ = stack[base + 23LLU];
22701	22763	// call parsetoken from procblock
22702	22764	stack[base + 20LLU] = base;
22703		- stack[base + 21LLU] = 1477LLU;
	22765	+ stack[base + 21LLU] = 1482LLU;
22704	22766	// arguments for call to parsetoken
22705	22767	stack[base + 25LLU] = stack[base + 11]/lookahead/;
22706	22768	// set stack-base & callee-address

		@@ -22708,7 +22770,7 @@
22708	22770	label = 18446744073709551585LLU; // parsetoken
22709	22771	break;
22710	22772	}
22711		- case 1477LLU: // return from parsetoken to procblock
	22773	+ case 1482LLU: // return from parsetoken to procblock
22712	22774	{
22713	22775	// copy mutable arguments back from call to parsetoken
22714	22776	// copy back results provided by call to parsetoken

		@@ -22721,7 +22783,7 @@
22721	22783	stack[base + 21/index/] = 0; // init
22722	22784	// call findlet from procblock
22723	22785	stack[base + 22LLU] = base;
22724		- stack[base + 23LLU] = 1478LLU;
	22786	+ stack[base + 23LLU] = 1483LLU;
22725	22787	// arguments for call to findlet
22726	22788	stack[base + 26LLU] = stack[base + 13]/content/;
22727	22789	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -22731,7 +22793,7 @@
22731	22793	label = 213LLU; // findlet
22732	22794	break;
22733	22795	}
22734		- case 1478LLU: // return from findlet to procblock
	22796	+ case 1483LLU: // return from findlet to procblock
22735	22797	{
22736	22798	// copy mutable arguments back from call to findlet
22737	22799	// copy back results provided by call to findlet

		@@ -22739,7 +22801,7 @@
22739	22801	stack[base + 21] = stack[base + 25LLU];
22740	22802	if(/typelist/1 != ((uint64_t )(stack[base + 19]/listtype*/))[0])
22741	22803	{
22742		- label = 1479LLU; // jump to alternative
	22804	+ label = 1484LLU; // jump to alternative
22743	22805	break;
22744	22806	}
22745	22807

		@@ -22752,7 +22814,7 @@
22752	22814	// call equtype from procblock
22753	22815	newstack[0] = (uint64_t)stack; // backup stack location
22754	22816	newstack[1] = base;
22755		- newstack[2] = 1481LLU;
	22817	+ newstack[2] = 1486LLU;
22756	22818	// arguments for call to equtype
22757	22819	newstack[4LLU] = stack[base + 20]/elemtype/;
22758	22820	newstack[5LLU] = stack[base + 22]/subtype/;

		@@ -22762,7 +22824,7 @@
22762	22824	label = 90LLU; // equtype
22763	22825	break;
22764	22826	}
22765		- case 1481LLU: // return from equtype to procblock
	22827	+ case 1486LLU: // return from equtype to procblock
22766	22828	{
22767	22829	uint64_t oldstack = (uint64_t )stack[0];
22768	22830	// copy mutable arguments back from call to equtype

		@@ -22777,15 +22839,15 @@
22777	22839	stack = oldstack;
22778	22840	if(!stack[base + 18]/isequal/)
22779	22841	{
22780		- label = 1482LLU; // jump to alternative
	22842	+ label = 1487LLU; // jump to alternative
22781	22843	break;
22782	22844	}
22783	22845
22784	22846	// consequent
22785		- label = 1483LLU; // consequent complete
	22847	+ label = 1488LLU; // consequent complete
22786	22848	break;
22787	22849	}
22788		- case 1482LLU: // alternative
	22850	+ case 1487LLU: // alternative
22789	22851	{
22790	22852	fprintf(stderr, "%s", "can't push element of type ");
22791	22853	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -22793,7 +22855,7 @@
22793	22855	// call reporttype from procblock
22794	22856	newstack[0] = (uint64_t)stack; // backup stack location
22795	22857	newstack[1] = base;
22796		- newstack[2] = 1484LLU;
	22858	+ newstack[2] = 1489LLU;
22797	22859	// arguments for call to reporttype
22798	22860	newstack[3LLU] = stack[base + 20]/elemtype/;
22799	22861	stack = newstack;

		@@ -22802,7 +22864,7 @@
22802	22864	label = 75LLU; // reporttype
22803	22865	break;
22804	22866	}
22805		- case 1484LLU: // return from reporttype to procblock
	22867	+ case 1489LLU: // return from reporttype to procblock
22806	22868	{
22807	22869	uint64_t oldstack = (uint64_t )stack[0];
22808	22870	// copy mutable arguments back from call to reporttype

		@@ -22819,7 +22881,7 @@
22819	22881	// call reporttype from procblock
22820	22882	newstack[0] = (uint64_t)stack; // backup stack location
22821	22883	newstack[1] = base;
22822		- newstack[2] = 1485LLU;
	22884	+ newstack[2] = 1490LLU;
22823	22885	// arguments for call to reporttype
22824	22886	newstack[3LLU] = stack[base + 22]/subtype/;
22825	22887	stack = newstack;

		@@ -22828,7 +22890,7 @@
22828	22890	label = 75LLU; // reporttype
22829	22891	break;
22830	22892	}
22831		- case 1485LLU: // return from reporttype to procblock
	22893	+ case 1490LLU: // return from reporttype to procblock
22832	22894	{
22833	22895	uint64_t oldstack = (uint64_t )stack[0];
22834	22896	// copy mutable arguments back from call to reporttype

		@@ -22842,7 +22904,7 @@
22842	22904	fprintf(stderr, "%s", " at ");
22843	22905	// call reportid from procblock
22844	22906	stack[base + 23LLU] = base;
22845		- stack[base + 24LLU] = 1486LLU;
	22907	+ stack[base + 24LLU] = 1491LLU;
22846	22908	// arguments for call to reportid
22847	22909	stack[base + 25LLU] = stack[base + 13]/content/;
22848	22910	// set stack-base & callee-address

		@@ -22850,26 +22912,26 @@
22850	22912	label = 18446744073709551587LLU; // reportid
22851	22913	break;
22852	22914	}
22853		- case 1486LLU: // return from reportid to procblock
	22915	+ case 1491LLU: // return from reportid to procblock
22854	22916	{
22855	22917	// copy mutable arguments back from call to reportid
22856	22918	fprintf(stderr, "%s", "\n");
22857	22919	exit(-1);
22858		- label = 1483LLU; // alternative complete
	22920	+ label = 1488LLU; // alternative complete
22859	22921	break;
22860	22922	}
22861		- case 1483LLU: // completed if-then-else
	22923	+ case 1488LLU: // completed if-then-else
22862	22924	{
22863	22925	((uint64_t *)(stack[base + 19]/listtype/))[1][0] = stack[base + 22]/subtype*/;
22864		- label = 1480LLU; // consequent complete
	22926	+ label = 1485LLU; // consequent complete
22865	22927	break;
22866	22928	}
22867		- case 1479LLU: // alternative
	22929	+ case 1484LLU: // alternative
22868	22930	{
22869	22931	fprintf(stderr, "%s", "can only push to list but type of ");
22870	22932	// call reportid from procblock
22871	22933	stack[base + 22LLU] = base;
22872		- stack[base + 23LLU] = 1487LLU;
	22934	+ stack[base + 23LLU] = 1492LLU;
22873	22935	// arguments for call to reportid
22874	22936	stack[base + 24LLU] = stack[base + 13]/content/;
22875	22937	// set stack-base & callee-address

		@@ -22877,7 +22939,7 @@
22877	22939	label = 18446744073709551587LLU; // reportid
22878	22940	break;
22879	22941	}
22880		- case 1487LLU: // return from reportid to procblock
	22942	+ case 1492LLU: // return from reportid to procblock
22881	22943	{
22882	22944	// copy mutable arguments back from call to reportid
22883	22945	fprintf(stderr, "%s", " is ");

		@@ -22886,7 +22948,7 @@
22886	22948	// call reporttype from procblock
22887	22949	newstack[0] = (uint64_t)stack; // backup stack location
22888	22950	newstack[1] = base;
22889		- newstack[2] = 1488LLU;
	22951	+ newstack[2] = 1493LLU;
22890	22952	// arguments for call to reporttype
22891	22953	newstack[3LLU] = stack[base + 19]/listtype/;
22892	22954	stack = newstack;

		@@ -22895,7 +22957,7 @@
22895	22957	label = 75LLU; // reporttype
22896	22958	break;
22897	22959	}
22898		- case 1488LLU: // return from reporttype to procblock
	22960	+ case 1493LLU: // return from reporttype to procblock
22899	22961	{
22900	22962	uint64_t oldstack = (uint64_t )stack[0];
22901	22963	// copy mutable arguments back from call to reporttype

		@@ -22908,14 +22970,14 @@
22908	22970	stack = oldstack;
22909	22971	fprintf(stderr, "%s", "\n");
22910	22972	exit(-1);
22911		- label = 1480LLU; // alternative complete
	22973	+ label = 1485LLU; // alternative complete
22912	22974	break;
22913	22975	}
22914		- case 1480LLU: // completed if-then-else
	22976	+ case 1485LLU: // completed if-then-else
22915	22977	{
22916	22978	// call equ from procblock
22917	22979	stack[base + 20LLU] = base;
22918		- stack[base + 21LLU] = 1489LLU;
	22980	+ stack[base + 21LLU] = 1494LLU;
22919	22981	// arguments for call to equ
22920	22982	stack[base + 23LLU] = stack[base + 12]/variant/;
22921	22983	stack[base + 24LLU] = 4LLU;

		@@ -22924,7 +22986,7 @@
22924	22986	label = 18446744073709551600LLU; // equ
22925	22987	break;
22926	22988	}
22927		- case 1489LLU: // return from equ to procblock
	22989	+ case 1494LLU: // return from equ to procblock
22928	22990	{
22929	22991	// copy mutable arguments back from call to equ
22930	22992	// copy back results provided by call to equ

		@@ -22931,7 +22993,7 @@
22931	22993	stack[base + 18] = stack[base + 22LLU];
22932	22994	if(!stack[base + 18]/isequal/)
22933	22995	{
22934		- label = 1490LLU; // jump to alternative
	22996	+ label = 1495LLU; // jump to alternative
22935	22997	break;
22936	22998	}
22937	22999

		@@ -22939,7 +23001,7 @@
22939	23001	printf("%s", "\n list->data = ");
22940	23002	// call emitvar from procblock
22941	23003	stack[base + 20LLU] = base;
22942		- stack[base + 21LLU] = 1492LLU;
	23004	+ stack[base + 21LLU] = 1497LLU;
22943	23005	// arguments for call to emitvar
22944	23006	stack[base + 22LLU] = stack[base + 13]/content/;
22945	23007	stack[base + 23LLU] = stack[base + 2]/scopes/;

		@@ -22949,19 +23011,19 @@
22949	23011	label = 224LLU; // emitvar
22950	23012	break;
22951	23013	}
22952		- case 1492LLU: // return from emitvar to procblock
	23014	+ case 1497LLU: // return from emitvar to procblock
22953	23015	{
22954	23016	// copy mutable arguments back from call to emitvar
22955	23017	printf("%s", ";");
22956		- label = 1491LLU; // consequent complete
	23018	+ label = 1496LLU; // consequent complete
22957	23019	break;
22958	23020	}
22959		- case 1490LLU: // alternative
	23021	+ case 1495LLU: // alternative
22960	23022	{
22961	23023	fprintf(stderr, "%s", "expected identifier in listpush but found ");
22962	23024	// call reporttok from procblock
22963	23025	stack[base + 20LLU] = base;
22964		- stack[base + 21LLU] = 1493LLU;
	23026	+ stack[base + 21LLU] = 1498LLU;
22965	23027	// arguments for call to reporttok
22966	23028	stack[base + 22LLU] = stack[base + 12]/variant/;
22967	23029	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -22970,20 +23032,20 @@
22970	23032	label = 18446744073709551583LLU; // reporttok
22971	23033	break;
22972	23034	}
22973		- case 1493LLU: // return from reporttok to procblock
	23035	+ case 1498LLU: // return from reporttok to procblock
22974	23036	{
22975	23037	// copy mutable arguments back from call to reporttok
22976	23038	fprintf(stderr, "%s", "\n");
22977	23039	exit(-1);
22978		- label = 1491LLU; // alternative complete
	23040	+ label = 1496LLU; // alternative complete
22979	23041	break;
22980	23042	}
22981		- case 1491LLU: // completed if-then-else
	23043	+ case 1496LLU: // completed if-then-else
22982	23044	{
22983	23045	printf("%s", "\n }");
22984	23046	// call matchsym from procblock
22985	23047	stack[base + 20LLU] = base;
22986		- stack[base + 21LLU] = 1494LLU;
	23048	+ stack[base + 21LLU] = 1499LLU;
22987	23049	// arguments for call to matchsym
22988	23050	stack[base + 22LLU] = 41LLU;
22989	23051	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -22992,19 +23054,19 @@
22992	23054	label = 27LLU; // matchsym
22993	23055	break;
22994	23056	}
22995		- case 1494LLU: // return from matchsym to procblock
	23057	+ case 1499LLU: // return from matchsym to procblock
22996	23058	{
22997	23059	// copy mutable arguments back from call to matchsym
22998	23060	stack[base + 11]/lookahead/ = stack[base + 23LLU];
22999		- label = 1472LLU; // consequent complete
	23061	+ label = 1477LLU; // consequent complete
23000	23062	break;
23001	23063	}
23002		- case 1471LLU: // alternative
	23064	+ case 1476LLU: // alternative
23003	23065	{
23004	23066	fprintf(stderr, "%s", "expected identifier in push but found ");
23005	23067	// call reporttok from procblock
23006	23068	stack[base + 19LLU] = base;
23007		- stack[base + 20LLU] = 1495LLU;
	23069	+ stack[base + 20LLU] = 1500LLU;
23008	23070	// arguments for call to reporttok
23009	23071	stack[base + 21LLU] = stack[base + 12]/variant/;
23010	23072	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -23013,24 +23075,24 @@
23013	23075	label = 18446744073709551583LLU; // reporttok
23014	23076	break;
23015	23077	}
23016		- case 1495LLU: // return from reporttok to procblock
	23078	+ case 1500LLU: // return from reporttok to procblock
23017	23079	{
23018	23080	// copy mutable arguments back from call to reporttok
23019	23081	fprintf(stderr, "%s", "\n");
23020	23082	exit(-1);
23021		- label = 1472LLU; // alternative complete
	23083	+ label = 1477LLU; // alternative complete
23022	23084	break;
23023	23085	}
23024		- case 1472LLU: // completed if-then-else
	23086	+ case 1477LLU: // completed if-then-else
23025	23087	{
23026		- label = 1467LLU; // consequent complete
	23088	+ label = 1472LLU; // consequent complete
23027	23089	break;
23028	23090	}
23029		- case 1466LLU: // alternative
	23091	+ case 1471LLU: // alternative
23030	23092	{
23031	23093	// call equ from procblock
23032	23094	stack[base + 19LLU] = base;
23033		- stack[base + 20LLU] = 1496LLU;
	23095	+ stack[base + 20LLU] = 1501LLU;
23034	23096	// arguments for call to equ
23035	23097	stack[base + 22LLU] = stack[base + 13]/content/;
23036	23098	stack[base + 23LLU] = 58328220282664192LLU;

		@@ -23039,7 +23101,7 @@
23039	23101	label = 18446744073709551600LLU; // equ
23040	23102	break;
23041	23103	}
23042		- case 1496LLU: // return from equ to procblock
	23104	+ case 1501LLU: // return from equ to procblock
23043	23105	{
23044	23106	// copy mutable arguments back from call to equ
23045	23107	// copy back results provided by call to equ

		@@ -23046,7 +23108,7 @@
23046	23108	stack[base + 18] = stack[base + 21LLU];
23047	23109	if(!stack[base + 18]/isequal/)
23048	23110	{
23049		- label = 1497LLU; // jump to alternative
	23111	+ label = 1502LLU; // jump to alternative
23050	23112	break;
23051	23113	}
23052	23114

		@@ -23056,7 +23118,7 @@
23056	23118	stack[base + 19/variableid/] = 0; // init
23057	23119	// call parsetoken from procblock
23058	23120	stack[base + 20LLU] = base;
23059		- stack[base + 21LLU] = 1499LLU;
	23121	+ stack[base + 21LLU] = 1504LLU;
23060	23122	// arguments for call to parsetoken
23061	23123	stack[base + 25LLU] = stack[base + 11]/lookahead/;
23062	23124	// set stack-base & callee-address

		@@ -23064,7 +23126,7 @@
23064	23126	label = 18446744073709551585LLU; // parsetoken
23065	23127	break;
23066	23128	}
23067		- case 1499LLU: // return from parsetoken to procblock
	23129	+ case 1504LLU: // return from parsetoken to procblock
23068	23130	{
23069	23131	// copy mutable arguments back from call to parsetoken
23070	23132	// copy back results provided by call to parsetoken

		@@ -23073,7 +23135,7 @@
23073	23135	stack[base + 11] = stack[base + 24LLU];
23074	23136	// call equ from procblock
23075	23137	stack[base + 20LLU] = base;
23076		- stack[base + 21LLU] = 1500LLU;
	23138	+ stack[base + 21LLU] = 1505LLU;
23077	23139	// arguments for call to equ
23078	23140	stack[base + 23LLU] = stack[base + 12]/variant/;
23079	23141	stack[base + 24LLU] = 4LLU;

		@@ -23082,7 +23144,7 @@
23082	23144	label = 18446744073709551600LLU; // equ
23083	23145	break;
23084	23146	}
23085		- case 1500LLU: // return from equ to procblock
	23147	+ case 1505LLU: // return from equ to procblock
23086	23148	{
23087	23149	// copy mutable arguments back from call to equ
23088	23150	// copy back results provided by call to equ

		@@ -23089,21 +23151,21 @@
23089	23151	stack[base + 18] = stack[base + 22LLU];
23090	23152	if(!stack[base + 18]/isequal/)
23091	23153	{
23092		- label = 1501LLU; // jump to alternative
	23154	+ label = 1506LLU; // jump to alternative
23093	23155	break;
23094	23156	}
23095	23157
23096	23158	// consequent
23097	23159	stack[base + 19]/variableid/ = stack[base + 13]/content/;
23098		- label = 1502LLU; // consequent complete
	23160	+ label = 1507LLU; // consequent complete
23099	23161	break;
23100	23162	}
23101		- case 1501LLU: // alternative
	23163	+ case 1506LLU: // alternative
23102	23164	{
23103	23165	fprintf(stderr, "%s", "CONSTRUCT requires variable but found ");
23104	23166	// call reporttok from procblock
23105	23167	stack[base + 20LLU] = base;
23106		- stack[base + 21LLU] = 1503LLU;
	23168	+ stack[base + 21LLU] = 1508LLU;
23107	23169	// arguments for call to reporttok
23108	23170	stack[base + 22LLU] = stack[base + 12]/variant/;
23109	23171	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -23112,15 +23174,15 @@
23112	23174	label = 18446744073709551583LLU; // reporttok
23113	23175	break;
23114	23176	}
23115		- case 1503LLU: // return from reporttok to procblock
	23177	+ case 1508LLU: // return from reporttok to procblock
23116	23178	{
23117	23179	// copy mutable arguments back from call to reporttok
23118	23180	fprintf(stderr, "%s", "\n");
23119	23181	exit(-1);
23120		- label = 1502LLU; // alternative complete
	23182	+ label = 1507LLU; // alternative complete
23121	23183	break;
23122	23184	}
23123		- case 1502LLU: // completed if-then-else
	23185	+ case 1507LLU: // completed if-then-else
23124	23186	{
23125	23187	//#define reftypedef 20
23126	23188	stack[base + 20/reftypedef/] = 0; // init

		@@ -23130,7 +23192,7 @@
23130	23192	stack[base + 22/index/] = 0; // init
23131	23193	// call findlet from procblock
23132	23194	stack[base + 23LLU] = base;
23133		- stack[base + 24LLU] = 1504LLU;
	23195	+ stack[base + 24LLU] = 1509LLU;
23134	23196	// arguments for call to findlet
23135	23197	stack[base + 27LLU] = stack[base + 19]/variableid/;
23136	23198	stack[base + 28LLU] = stack[base + 2]/scopes/;

		@@ -23140,7 +23202,7 @@
23140	23202	label = 213LLU; // findlet
23141	23203	break;
23142	23204	}
23143		- case 1504LLU: // return from findlet to procblock
	23205	+ case 1509LLU: // return from findlet to procblock
23144	23206	{
23145	23207	// copy mutable arguments back from call to findlet
23146	23208	// copy back results provided by call to findlet

		@@ -23148,7 +23210,7 @@
23148	23210	stack[base + 22] = stack[base + 26LLU];
23149	23211	if(/typename/0 != ((uint64_t )(stack[base + 21]/type*/))[0])
23150	23212	{
23151		- label = 1505LLU; // jump to alternative
	23213	+ label = 1510LLU; // jump to alternative
23152	23214	break;
23153	23215	}
23154	23216

		@@ -23158,7 +23220,7 @@
23158	23220	stack[base + 23]/name/ = ((uint64_t *)(stack[base + 21]/type*/))[1][0];
23159	23221	// call finddata from procblock
23160	23222	stack[base + 24LLU] = base;
23161		- stack[base + 25LLU] = 1507LLU;
	23223	+ stack[base + 25LLU] = 1512LLU;
23162	23224	// arguments for call to finddata
23163	23225	stack[base + 27LLU] = stack[base + 1]/typedefs/;
23164	23226	stack[base + 28LLU] = stack[base + 23]/name/;

		@@ -23167,16 +23229,16 @@
23167	23229	label = 319LLU; // finddata
23168	23230	break;
23169	23231	}
23170		- case 1507LLU: // return from finddata to procblock
	23232	+ case 1512LLU: // return from finddata to procblock
23171	23233	{
23172	23234	// copy mutable arguments back from call to finddata
23173	23235	// copy back results provided by call to finddata
23174	23236	stack[base + 20] = stack[base + 26LLU];
23175	23237	((uint64_t *)(stack[base + 21]/type/))[1][0] = stack[base + 23]/name*/;
23176		- label = 1506LLU; // consequent complete
	23238	+ label = 1511LLU; // consequent complete
23177	23239	break;
23178	23240	}
23179		- case 1505LLU: // alternative
	23241	+ case 1510LLU: // alternative
23180	23242	{
23181	23243	fprintf(stderr, "%s", "can't construct type ");
23182	23244	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -23184,7 +23246,7 @@
23184	23246	// call reporttype from procblock
23185	23247	newstack[0] = (uint64_t)stack; // backup stack location
23186	23248	newstack[1] = base;
23187		- newstack[2] = 1508LLU;
	23249	+ newstack[2] = 1513LLU;
23188	23250	// arguments for call to reporttype
23189	23251	newstack[3LLU] = stack[base + 21]/type/;
23190	23252	stack = newstack;

		@@ -23193,7 +23255,7 @@
23193	23255	label = 75LLU; // reporttype
23194	23256	break;
23195	23257	}
23196		- case 1508LLU: // return from reporttype to procblock
	23258	+ case 1513LLU: // return from reporttype to procblock
23197	23259	{
23198	23260	uint64_t oldstack = (uint64_t )stack[0];
23199	23261	// copy mutable arguments back from call to reporttype

		@@ -23206,15 +23268,15 @@
23206	23268	stack = oldstack;
23207	23269	fprintf(stderr, "%s", "\n");
23208	23270	exit(-1);
23209		- label = 1506LLU; // alternative complete
	23271	+ label = 1511LLU; // alternative complete
23210	23272	break;
23211	23273	}
23212		- case 1506LLU: // completed if-then-else
	23274	+ case 1511LLU: // completed if-then-else
23213	23275	{
23214	23276	printf("%s", " ");
23215	23277	// call printid from procblock
23216	23278	stack[base + 21LLU] = base;
23217		- stack[base + 22LLU] = 1509LLU;
	23279	+ stack[base + 22LLU] = 1514LLU;
23218	23280	// arguments for call to printid
23219	23281	stack[base + 23LLU] = stack[base + 13]/content/;
23220	23282	// set stack-base & callee-address

		@@ -23222,12 +23284,12 @@
23222	23284	label = 18446744073709551588LLU; // printid
23223	23285	break;
23224	23286	}
23225		- case 1509LLU: // return from printid to procblock
	23287	+ case 1514LLU: // return from printid to procblock
23226	23288	{
23227	23289	// copy mutable arguments back from call to printid
23228	23290	if(/datadef/0 != ((uint64_t )(stack[base + 20]/reftypedef*/))[0])
23229	23291	{
23230		- label = 1510LLU; // jump to alternative
	23292	+ label = 1515LLU; // jump to alternative
23231	23293	break;
23232	23294	}
23233	23295

		@@ -23240,7 +23302,7 @@
23240	23302	stack[base + 22]/variants/ = ((uint64_t *)(stack[base + 20]/reftypedef*/))[1][1];
23241	23303	// call parsetoken from procblock
23242	23304	stack[base + 23LLU] = base;
23243		- stack[base + 24LLU] = 1512LLU;
	23305	+ stack[base + 24LLU] = 1517LLU;
23244	23306	// arguments for call to parsetoken
23245	23307	stack[base + 28LLU] = stack[base + 11]/lookahead/;
23246	23308	// set stack-base & callee-address

		@@ -23248,7 +23310,7 @@
23248	23310	label = 18446744073709551585LLU; // parsetoken
23249	23311	break;
23250	23312	}
23251		- case 1512LLU: // return from parsetoken to procblock
	23313	+ case 1517LLU: // return from parsetoken to procblock
23252	23314	{
23253	23315	// copy mutable arguments back from call to parsetoken
23254	23316	// copy back results provided by call to parsetoken

		@@ -23257,7 +23319,7 @@
23257	23319	stack[base + 11] = stack[base + 27LLU];
23258	23320	// call equ from procblock
23259	23321	stack[base + 23LLU] = base;
23260		- stack[base + 24LLU] = 1513LLU;
	23322	+ stack[base + 24LLU] = 1518LLU;
23261	23323	// arguments for call to equ
23262	23324	stack[base + 26LLU] = stack[base + 12]/variant/;
23263	23325	stack[base + 27LLU] = 4LLU;

		@@ -23266,7 +23328,7 @@
23266	23328	label = 18446744073709551600LLU; // equ
23267	23329	break;
23268	23330	}
23269		- case 1513LLU: // return from equ to procblock
	23331	+ case 1518LLU: // return from equ to procblock
23270	23332	{
23271	23333	// copy mutable arguments back from call to equ
23272	23334	// copy back results provided by call to equ

		@@ -23273,20 +23335,20 @@
23273	23335	stack[base + 18] = stack[base + 25LLU];
23274	23336	if(!stack[base + 18]/isequal/)
23275	23337	{
23276		- label = 1514LLU; // jump to alternative
	23338	+ label = 1519LLU; // jump to alternative
23277	23339	break;
23278	23340	}
23279	23341
23280	23342	// consequent
23281		- label = 1515LLU; // consequent complete
	23343	+ label = 1520LLU; // consequent complete
23282	23344	break;
23283	23345	}
23284		- case 1514LLU: // alternative
	23346	+ case 1519LLU: // alternative
23285	23347	{
23286	23348	fprintf(stderr, "%s", "construct requires constructor but found ");
23287	23349	// call reporttok from procblock
23288	23350	stack[base + 23LLU] = base;
23289		- stack[base + 24LLU] = 1516LLU;
	23351	+ stack[base + 24LLU] = 1521LLU;
23290	23352	// arguments for call to reporttok
23291	23353	stack[base + 25LLU] = stack[base + 12]/variant/;
23292	23354	stack[base + 26LLU] = stack[base + 13]/content/;

		@@ -23295,20 +23357,20 @@
23295	23357	label = 18446744073709551583LLU; // reporttok
23296	23358	break;
23297	23359	}
23298		- case 1516LLU: // return from reporttok to procblock
	23360	+ case 1521LLU: // return from reporttok to procblock
23299	23361	{
23300	23362	// copy mutable arguments back from call to reporttok
23301	23363	fprintf(stderr, "%s", "\n");
23302	23364	exit(-1);
23303		- label = 1515LLU; // alternative complete
	23365	+ label = 1520LLU; // alternative complete
23304	23366	break;
23305	23367	}
23306		- case 1515LLU: // completed if-then-else
	23368	+ case 1520LLU: // completed if-then-else
23307	23369	{
23308	23370	printf("%s", " ");
23309	23371	// call printid from procblock
23310	23372	stack[base + 23LLU] = base;
23311		- stack[base + 24LLU] = 1517LLU;
	23373	+ stack[base + 24LLU] = 1522LLU;
23312	23374	// arguments for call to printid
23313	23375	stack[base + 25LLU] = stack[base + 13]/content/;
23314	23376	// set stack-base & callee-address

		@@ -23316,7 +23378,7 @@
23316	23378	label = 18446744073709551588LLU; // printid
23317	23379	break;
23318	23380	}
23319		- case 1517LLU: // return from printid to procblock
	23381	+ case 1522LLU: // return from printid to procblock
23320	23382	{
23321	23383	// copy mutable arguments back from call to printid
23322	23384	//#define varnr 23

		@@ -23326,7 +23388,7 @@
23326	23388	stack[base + 24/constr/] = 0; // init
23327	23389	// call getvariant from procblock
23328	23390	stack[base + 25LLU] = base;
23329		- stack[base + 26LLU] = 1518LLU;
	23391	+ stack[base + 26LLU] = 1523LLU;
23330	23392	// arguments for call to getvariant
23331	23393	stack[base + 29LLU] = stack[base + 22]/variants/;
23332	23394	stack[base + 30LLU] = stack[base + 13]/content/;

		@@ -23335,7 +23397,7 @@
23335	23397	label = 296LLU; // getvariant
23336	23398	break;
23337	23399	}
23338		- case 1518LLU: // return from getvariant to procblock
	23400	+ case 1523LLU: // return from getvariant to procblock
23339	23401	{
23340	23402	// copy mutable arguments back from call to getvariant
23341	23403	// copy back results provided by call to getvariant

		@@ -23343,7 +23405,7 @@
23343	23405	stack[base + 24] = stack[base + 28LLU];
23344	23406	if(/variant/0 != ((uint64_t )(stack[base + 24]/constr*/))[0])
23345	23407	{
23346		- label = 1519LLU; // jump to alternative
	23408	+ label = 1524LLU; // jump to alternative
23347	23409	break;
23348	23410	}
23349	23411

		@@ -23357,7 +23419,7 @@
23357	23419	printf("%s", "\n ");
23358	23420	// call emitvar from procblock
23359	23421	stack[base + 27LLU] = base;
23360		- stack[base + 28LLU] = 1521LLU;
	23422	+ stack[base + 28LLU] = 1526LLU;
23361	23423	// arguments for call to emitvar
23362	23424	stack[base + 29LLU] = stack[base + 19]/variableid/;
23363	23425	stack[base + 30LLU] = stack[base + 2]/scopes/;

		@@ -23367,7 +23429,7 @@
23367	23429	label = 224LLU; // emitvar
23368	23430	break;
23369	23431	}
23370		- case 1521LLU: // return from emitvar to procblock
	23432	+ case 1526LLU: // return from emitvar to procblock
23371	23433	{
23372	23434	// copy mutable arguments back from call to emitvar
23373	23435	printf("%s", " = (uint64_t)Calloc(2, sizeof(uint64_t));");

		@@ -23377,7 +23439,7 @@
23377	23439	printf("%s", "\n ((uint64_t *)");
23378	23440	// call emitvar from procblock
23379	23441	stack[base + 28LLU] = base;
23380		- stack[base + 29LLU] = 1522LLU;
	23442	+ stack[base + 29LLU] = 1527LLU;
23381	23443	// arguments for call to emitvar
23382	23444	stack[base + 30LLU] = stack[base + 19]/variableid/;
23383	23445	stack[base + 31LLU] = stack[base + 2]/scopes/;

		@@ -23387,13 +23449,13 @@
23387	23449	label = 224LLU; // emitvar
23388	23450	break;
23389	23451	}
23390		- case 1522LLU: // return from emitvar to procblock
	23452	+ case 1527LLU: // return from emitvar to procblock
23391	23453	{
23392	23454	// copy mutable arguments back from call to emitvar
23393	23455	printf("%s", ")[0] = ");
23394	23456	// call printnr from procblock
23395	23457	stack[base + 28LLU] = base;
23396		- stack[base + 29LLU] = 1523LLU;
	23458	+ stack[base + 29LLU] = 1528LLU;
23397	23459	// arguments for call to printnr
23398	23460	stack[base + 30LLU] = stack[base + 23]/varnr/;
23399	23461	// set stack-base & callee-address

		@@ -23401,7 +23463,7 @@
23401	23463	label = 18446744073709551591LLU; // printnr
23402	23464	break;
23403	23465	}
23404		- case 1523LLU: // return from printnr to procblock
	23466	+ case 1528LLU: // return from printnr to procblock
23405	23467	{
23406	23468	// copy mutable arguments back from call to printnr
23407	23469	printf("%s", ";");

		@@ -23408,7 +23470,7 @@
23408	23470	printf("%s", "\n ((uint64_t *)");
23409	23471	// call emitvar from procblock
23410	23472	stack[base + 28LLU] = base;
23411		- stack[base + 29LLU] = 1524LLU;
	23473	+ stack[base + 29LLU] = 1529LLU;
23412	23474	// arguments for call to emitvar
23413	23475	stack[base + 30LLU] = stack[base + 19]/variableid/;
23414	23476	stack[base + 31LLU] = stack[base + 2]/scopes/;

		@@ -23418,13 +23480,13 @@
23418	23480	label = 224LLU; // emitvar
23419	23481	break;
23420	23482	}
23421		- case 1524LLU: // return from emitvar to procblock
	23483	+ case 1529LLU: // return from emitvar to procblock
23422	23484	{
23423	23485	// copy mutable arguments back from call to emitvar
23424	23486	printf("%s", ")[1] = (uint64_t)Calloc(");
23425	23487	// call printnr from procblock
23426	23488	stack[base + 28LLU] = base;
23427		- stack[base + 29LLU] = 1525LLU;
	23489	+ stack[base + 29LLU] = 1530LLU;
23428	23490	// arguments for call to printnr
23429	23491	stack[base + 30LLU] = stack[base + 27]/size/;
23430	23492	// set stack-base & callee-address

		@@ -23432,46 +23494,46 @@
23432	23494	label = 18446744073709551591LLU; // printnr
23433	23495	break;
23434	23496	}
23435		- case 1525LLU: // return from printnr to procblock
	23497	+ case 1530LLU: // return from printnr to procblock
23436	23498	{
23437	23499	// copy mutable arguments back from call to printnr
23438	23500	printf("%s", ", sizeof(uint64_t));");
23439	23501	((uint64_t *)(stack[base + 24]/constr/))[1][1] = stack[base + 26]/typeids*/;
23440	23502	((uint64_t *)(stack[base + 24]/constr/))[1][0] = stack[base + 25]/dummy*/;
23441		- label = 1520LLU; // consequent complete
	23503	+ label = 1525LLU; // consequent complete
23442	23504	break;
23443	23505	}
23444		- case 1519LLU: // alternative
	23506	+ case 1524LLU: // alternative
23445	23507	{
23446	23508	fprintf(stderr, "%s", "INTERNAL ERROR\n");
23447	23509	exit(-1);
23448		- label = 1520LLU; // alternative complete
	23510	+ label = 1525LLU; // alternative complete
23449	23511	break;
23450	23512	}
23451		- case 1520LLU: // completed if-then-else
	23513	+ case 1525LLU: // completed if-then-else
23452	23514	{
23453	23515	((uint64_t *)(stack[base + 20]/reftypedef/))[1][1] = stack[base + 22]/variants*/;
23454	23516	((uint64_t *)(stack[base + 20]/reftypedef/))[1][0] = stack[base + 21]/dummyid*/;
23455		- label = 1511LLU; // consequent complete
	23517	+ label = 1516LLU; // consequent complete
23456	23518	break;
23457	23519	}
23458		- case 1510LLU: // alternative
	23520	+ case 1515LLU: // alternative
23459	23521	{
23460	23522	fprintf(stderr, "%s", "INTERNAL ERROR\n");
23461	23523	exit(-1);
23462		- label = 1511LLU; // alternative complete
	23524	+ label = 1516LLU; // alternative complete
23463	23525	break;
23464	23526	}
23465		- case 1511LLU: // completed if-then-else
	23527	+ case 1516LLU: // completed if-then-else
23466	23528	{
23467		- label = 1498LLU; // consequent complete
	23529	+ label = 1503LLU; // consequent complete
23468	23530	break;
23469	23531	}
23470		- case 1497LLU: // alternative
	23532	+ case 1502LLU: // alternative
23471	23533	{
23472	23534	// call equ from procblock
23473	23535	stack[base + 19LLU] = base;
23474		- stack[base + 20LLU] = 1526LLU;
	23536	+ stack[base + 20LLU] = 1531LLU;
23475	23537	// arguments for call to equ
23476	23538	stack[base + 22LLU] = stack[base + 13]/content/;
23477	23539	stack[base + 23LLU] = 218791014736351232LLU;

		@@ -23480,7 +23542,7 @@
23480	23542	label = 18446744073709551600LLU; // equ
23481	23543	break;
23482	23544	}
23483		- case 1526LLU: // return from equ to procblock
	23545	+ case 1531LLU: // return from equ to procblock
23484	23546	{
23485	23547	// copy mutable arguments back from call to equ
23486	23548	// copy back results provided by call to equ

		@@ -23487,7 +23549,7 @@
23487	23549	stack[base + 18] = stack[base + 21LLU];
23488	23550	if(!stack[base + 18]/isequal/)
23489	23551	{
23490		- label = 1527LLU; // jump to alternative
	23552	+ label = 1532LLU; // jump to alternative
23491	23553	break;
23492	23554	}
23493	23555

		@@ -23496,7 +23558,7 @@
23496	23558	stack[base + 19/id/] = 0; // init
23497	23559	// call matchsym from procblock
23498	23560	stack[base + 20LLU] = base;
23499		- stack[base + 21LLU] = 1529LLU;
	23561	+ stack[base + 21LLU] = 1534LLU;
23500	23562	// arguments for call to matchsym
23501	23563	stack[base + 22LLU] = 40LLU;
23502	23564	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23505,13 +23567,13 @@
23505	23567	label = 27LLU; // matchsym
23506	23568	break;
23507	23569	}
23508		- case 1529LLU: // return from matchsym to procblock
	23570	+ case 1534LLU: // return from matchsym to procblock
23509	23571	{
23510	23572	// copy mutable arguments back from call to matchsym
23511	23573	stack[base + 11]/lookahead/ = stack[base + 23LLU];
23512	23574	// call parsetoken from procblock
23513	23575	stack[base + 20LLU] = base;
23514		- stack[base + 21LLU] = 1530LLU;
	23576	+ stack[base + 21LLU] = 1535LLU;
23515	23577	// arguments for call to parsetoken
23516	23578	stack[base + 25LLU] = stack[base + 11]/lookahead/;
23517	23579	// set stack-base & callee-address

		@@ -23519,7 +23581,7 @@
23519	23581	label = 18446744073709551585LLU; // parsetoken
23520	23582	break;
23521	23583	}
23522		- case 1530LLU: // return from parsetoken to procblock
	23584	+ case 1535LLU: // return from parsetoken to procblock
23523	23585	{
23524	23586	// copy mutable arguments back from call to parsetoken
23525	23587	// copy back results provided by call to parsetoken

		@@ -23528,7 +23590,7 @@
23528	23590	stack[base + 11] = stack[base + 24LLU];
23529	23591	// call equ from procblock
23530	23592	stack[base + 20LLU] = base;
23531		- stack[base + 21LLU] = 1531LLU;
	23593	+ stack[base + 21LLU] = 1536LLU;
23532	23594	// arguments for call to equ
23533	23595	stack[base + 23LLU] = stack[base + 12]/variant/;
23534	23596	stack[base + 24LLU] = 4LLU;

		@@ -23537,7 +23599,7 @@
23537	23599	label = 18446744073709551600LLU; // equ
23538	23600	break;
23539	23601	}
23540		- case 1531LLU: // return from equ to procblock
	23602	+ case 1536LLU: // return from equ to procblock
23541	23603	{
23542	23604	// copy mutable arguments back from call to equ
23543	23605	// copy back results provided by call to equ

		@@ -23544,21 +23606,21 @@
23544	23606	stack[base + 18] = stack[base + 22LLU];
23545	23607	if(!stack[base + 18]/isequal/)
23546	23608	{
23547		- label = 1532LLU; // jump to alternative
	23609	+ label = 1537LLU; // jump to alternative
23548	23610	break;
23549	23611	}
23550	23612
23551	23613	// consequent
23552	23614	stack[base + 19]/id/ = stack[base + 13]/content/;
23553		- label = 1533LLU; // consequent complete
	23615	+ label = 1538LLU; // consequent complete
23554	23616	break;
23555	23617	}
23556		- case 1532LLU: // alternative
	23618	+ case 1537LLU: // alternative
23557	23619	{
23558	23620	fprintf(stderr, "%s", "LISTSIZE requires list-variable but found ");
23559	23621	// call reporttok from procblock
23560	23622	stack[base + 20LLU] = base;
23561		- stack[base + 21LLU] = 1534LLU;
	23623	+ stack[base + 21LLU] = 1539LLU;
23562	23624	// arguments for call to reporttok
23563	23625	stack[base + 22LLU] = stack[base + 12]/variant/;
23564	23626	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -23567,15 +23629,15 @@
23567	23629	label = 18446744073709551583LLU; // reporttok
23568	23630	break;
23569	23631	}
23570		- case 1534LLU: // return from reporttok to procblock
	23632	+ case 1539LLU: // return from reporttok to procblock
23571	23633	{
23572	23634	// copy mutable arguments back from call to reporttok
23573	23635	fprintf(stderr, "%s", "\n");
23574	23636	exit(-1);
23575		- label = 1533LLU; // alternative complete
	23637	+ label = 1538LLU; // alternative complete
23576	23638	break;
23577	23639	}
23578		- case 1533LLU: // completed if-then-else
	23640	+ case 1538LLU: // completed if-then-else
23579	23641	{
23580	23642	//#define listtype 20
23581	23643	stack[base + 20/listtype/] = 0; // init

		@@ -23583,7 +23645,7 @@
23583	23645	stack[base + 21/index/] = 0; // init
23584	23646	// call findlet from procblock
23585	23647	stack[base + 22LLU] = base;
23586		- stack[base + 23LLU] = 1535LLU;
	23648	+ stack[base + 23LLU] = 1540LLU;
23587	23649	// arguments for call to findlet
23588	23650	stack[base + 26LLU] = stack[base + 13]/content/;
23589	23651	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -23593,7 +23655,7 @@
23593	23655	label = 213LLU; // findlet
23594	23656	break;
23595	23657	}
23596		- case 1535LLU: // return from findlet to procblock
	23658	+ case 1540LLU: // return from findlet to procblock
23597	23659	{
23598	23660	// copy mutable arguments back from call to findlet
23599	23661	// copy back results provided by call to findlet

		@@ -23601,7 +23663,7 @@
23601	23663	stack[base + 21] = stack[base + 25LLU];
23602	23664	if(/typelist/1 != ((uint64_t )(stack[base + 20]/listtype*/))[0])
23603	23665	{
23604		- label = 1536LLU; // jump to alternative
	23666	+ label = 1541LLU; // jump to alternative
23605	23667	break;
23606	23668	}
23607	23669

		@@ -23610,10 +23672,10 @@
23610	23672	stack[base + 22/subtype/] = 0; // init
23611	23673	stack[base + 22]/subtype/ = ((uint64_t *)(stack[base + 20]/listtype*/))[1][0];
23612	23674	((uint64_t *)(stack[base + 20]/listtype/))[1][0] = stack[base + 22]/subtype*/;
23613		- label = 1537LLU; // consequent complete
	23675	+ label = 1542LLU; // consequent complete
23614	23676	break;
23615	23677	}
23616		- case 1536LLU: // alternative
	23678	+ case 1541LLU: // alternative
23617	23679	{
23618	23680	fprintf(stderr, "%s", "LISTSIZE requires argument of type list but found type ");
23619	23681	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -23621,7 +23683,7 @@
23621	23683	// call reporttype from procblock
23622	23684	newstack[0] = (uint64_t)stack; // backup stack location
23623	23685	newstack[1] = base;
23624		- newstack[2] = 1538LLU;
	23686	+ newstack[2] = 1543LLU;
23625	23687	// arguments for call to reporttype
23626	23688	newstack[3LLU] = stack[base + 20]/listtype/;
23627	23689	stack = newstack;

		@@ -23630,7 +23692,7 @@
23630	23692	label = 75LLU; // reporttype
23631	23693	break;
23632	23694	}
23633		- case 1538LLU: // return from reporttype to procblock
	23695	+ case 1543LLU: // return from reporttype to procblock
23634	23696	{
23635	23697	uint64_t oldstack = (uint64_t )stack[0];
23636	23698	// copy mutable arguments back from call to reporttype

		@@ -23644,7 +23706,7 @@
23644	23706	fprintf(stderr, "%s", " at ");
23645	23707	// call reportid from procblock
23646	23708	stack[base + 22LLU] = base;
23647		- stack[base + 23LLU] = 1539LLU;
	23709	+ stack[base + 23LLU] = 1544LLU;
23648	23710	// arguments for call to reportid
23649	23711	stack[base + 24LLU] = stack[base + 13]/content/;
23650	23712	// set stack-base & callee-address

		@@ -23652,19 +23714,19 @@
23652	23714	label = 18446744073709551587LLU; // reportid
23653	23715	break;
23654	23716	}
23655		- case 1539LLU: // return from reportid to procblock
	23717	+ case 1544LLU: // return from reportid to procblock
23656	23718	{
23657	23719	// copy mutable arguments back from call to reportid
23658	23720	fprintf(stderr, "%s", "\n");
23659	23721	exit(-1);
23660		- label = 1537LLU; // alternative complete
	23722	+ label = 1542LLU; // alternative complete
23661	23723	break;
23662	23724	}
23663		- case 1537LLU: // completed if-then-else
	23725	+ case 1542LLU: // completed if-then-else
23664	23726	{
23665	23727	// call matchsym from procblock
23666	23728	stack[base + 20LLU] = base;
23667		- stack[base + 21LLU] = 1540LLU;
	23729	+ stack[base + 21LLU] = 1545LLU;
23668	23730	// arguments for call to matchsym
23669	23731	stack[base + 22LLU] = 41LLU;
23670	23732	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23673,13 +23735,13 @@
23673	23735	label = 27LLU; // matchsym
23674	23736	break;
23675	23737	}
23676		- case 1540LLU: // return from matchsym to procblock
	23738	+ case 1545LLU: // return from matchsym to procblock
23677	23739	{
23678	23740	// copy mutable arguments back from call to matchsym
23679	23741	stack[base + 11]/lookahead/ = stack[base + 23LLU];
23680	23742	// call matchsym from procblock
23681	23743	stack[base + 20LLU] = base;
23682		- stack[base + 21LLU] = 1541LLU;
	23744	+ stack[base + 21LLU] = 1546LLU;
23683	23745	// arguments for call to matchsym
23684	23746	stack[base + 22LLU] = 45LLU;
23685	23747	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23688,13 +23750,13 @@
23688	23750	label = 27LLU; // matchsym
23689	23751	break;
23690	23752	}
23691		- case 1541LLU: // return from matchsym to procblock
	23753	+ case 1546LLU: // return from matchsym to procblock
23692	23754	{
23693	23755	// copy mutable arguments back from call to matchsym
23694	23756	stack[base + 11]/lookahead/ = stack[base + 23LLU];
23695	23757	// call matchsym from procblock
23696	23758	stack[base + 20LLU] = base;
23697		- stack[base + 21LLU] = 1542LLU;
	23759	+ stack[base + 21LLU] = 1547LLU;
23698	23760	// arguments for call to matchsym
23699	23761	stack[base + 22LLU] = 62LLU;
23700	23762	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23703,13 +23765,13 @@
23703	23765	label = 27LLU; // matchsym
23704	23766	break;
23705	23767	}
23706		- case 1542LLU: // return from matchsym to procblock
	23768	+ case 1547LLU: // return from matchsym to procblock
23707	23769	{
23708	23770	// copy mutable arguments back from call to matchsym
23709	23771	stack[base + 11]/lookahead/ = stack[base + 23LLU];
23710	23772	// call matchsym from procblock
23711	23773	stack[base + 20LLU] = base;
23712		- stack[base + 21LLU] = 1543LLU;
	23774	+ stack[base + 21LLU] = 1548LLU;
23713	23775	// arguments for call to matchsym
23714	23776	stack[base + 22LLU] = 40LLU;
23715	23777	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23718,13 +23780,13 @@
23718	23780	label = 27LLU; // matchsym
23719	23781	break;
23720	23782	}
23721		- case 1543LLU: // return from matchsym to procblock
	23783	+ case 1548LLU: // return from matchsym to procblock
23722	23784	{
23723	23785	// copy mutable arguments back from call to matchsym
23724	23786	stack[base + 11]/lookahead/ = stack[base + 23LLU];
23725	23787	// call parsetoken from procblock
23726	23788	stack[base + 20LLU] = base;
23727		- stack[base + 21LLU] = 1544LLU;
	23789	+ stack[base + 21LLU] = 1549LLU;
23728	23790	// arguments for call to parsetoken
23729	23791	stack[base + 25LLU] = stack[base + 11]/lookahead/;
23730	23792	// set stack-base & callee-address

		@@ -23732,7 +23794,7 @@
23732	23794	label = 18446744073709551585LLU; // parsetoken
23733	23795	break;
23734	23796	}
23735		- case 1544LLU: // return from parsetoken to procblock
	23797	+ case 1549LLU: // return from parsetoken to procblock
23736	23798	{
23737	23799	// copy mutable arguments back from call to parsetoken
23738	23800	// copy back results provided by call to parsetoken

		@@ -23741,7 +23803,7 @@
23741	23803	stack[base + 11] = stack[base + 24LLU];
23742	23804	// call equ from procblock
23743	23805	stack[base + 20LLU] = base;
23744		- stack[base + 21LLU] = 1545LLU;
	23806	+ stack[base + 21LLU] = 1550LLU;
23745	23807	// arguments for call to equ
23746	23808	stack[base + 23LLU] = stack[base + 12]/variant/;
23747	23809	stack[base + 24LLU] = 4LLU;

		@@ -23750,7 +23812,7 @@
23750	23812	label = 18446744073709551600LLU; // equ
23751	23813	break;
23752	23814	}
23753		- case 1545LLU: // return from equ to procblock
	23815	+ case 1550LLU: // return from equ to procblock
23754	23816	{
23755	23817	// copy mutable arguments back from call to equ
23756	23818	// copy back results provided by call to equ

		@@ -23757,7 +23819,7 @@
23757	23819	stack[base + 18] = stack[base + 22LLU];
23758	23820	if(!stack[base + 18]/isequal/)
23759	23821	{
23760		- label = 1546LLU; // jump to alternative
	23822	+ label = 1551LLU; // jump to alternative
23761	23823	break;
23762	23824	}
23763	23825

		@@ -23765,7 +23827,7 @@
23765	23827	printf("%s", "\n ");
23766	23828	// call emitvar from procblock
23767	23829	stack[base + 20LLU] = base;
23768		- stack[base + 21LLU] = 1548LLU;
	23830	+ stack[base + 21LLU] = 1553LLU;
23769	23831	// arguments for call to emitvar
23770	23832	stack[base + 22LLU] = stack[base + 13]/content/;
23771	23833	stack[base + 23LLU] = stack[base + 2]/scopes/;

		@@ -23775,7 +23837,7 @@
23775	23837	label = 224LLU; // emitvar
23776	23838	break;
23777	23839	}
23778		- case 1548LLU: // return from emitvar to procblock
	23840	+ case 1553LLU: // return from emitvar to procblock
23779	23841	{
23780	23842	// copy mutable arguments back from call to emitvar
23781	23843	printf("%s", " = ");

		@@ -23782,7 +23844,7 @@
23782	23844	printf("%s", "list_size(((struct listnode *)(");
23783	23845	// call emitvar from procblock
23784	23846	stack[base + 20LLU] = base;
23785		- stack[base + 21LLU] = 1549LLU;
	23847	+ stack[base + 21LLU] = 1554LLU;
23786	23848	// arguments for call to emitvar
23787	23849	stack[base + 22LLU] = stack[base + 19]/id/;
23788	23850	stack[base + 23LLU] = stack[base + 2]/scopes/;

		@@ -23792,19 +23854,19 @@
23792	23854	label = 224LLU; // emitvar
23793	23855	break;
23794	23856	}
23795		- case 1549LLU: // return from emitvar to procblock
	23857	+ case 1554LLU: // return from emitvar to procblock
23796	23858	{
23797	23859	// copy mutable arguments back from call to emitvar
23798	23860	printf("%s", ")));");
23799		- label = 1547LLU; // consequent complete
	23861	+ label = 1552LLU; // consequent complete
23800	23862	break;
23801	23863	}
23802		- case 1546LLU: // alternative
	23864	+ case 1551LLU: // alternative
23803	23865	{
23804	23866	fprintf(stderr, "%s", "LISTSIZE requires variable for size but found ");
23805	23867	// call reporttok from procblock
23806	23868	stack[base + 20LLU] = base;
23807		- stack[base + 21LLU] = 1550LLU;
	23869	+ stack[base + 21LLU] = 1555LLU;
23808	23870	// arguments for call to reporttok
23809	23871	stack[base + 22LLU] = stack[base + 12]/variant/;
23810	23872	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -23813,15 +23875,15 @@
23813	23875	label = 18446744073709551583LLU; // reporttok
23814	23876	break;
23815	23877	}
23816		- case 1550LLU: // return from reporttok to procblock
	23878	+ case 1555LLU: // return from reporttok to procblock
23817	23879	{
23818	23880	// copy mutable arguments back from call to reporttok
23819	23881	fprintf(stderr, "%s", "\n");
23820	23882	exit(-1);
23821		- label = 1547LLU; // alternative complete
	23883	+ label = 1552LLU; // alternative complete
23822	23884	break;
23823	23885	}
23824		- case 1547LLU: // completed if-then-else
	23886	+ case 1552LLU: // completed if-then-else
23825	23887	{
23826	23888	//#define sizetype 20
23827	23889	stack[base + 20/sizetype/] = 0; // init

		@@ -23829,7 +23891,7 @@
23829	23891	stack[base + 21/index/] = 0; // init
23830	23892	// call findlet from procblock
23831	23893	stack[base + 22LLU] = base;
23832		- stack[base + 23LLU] = 1551LLU;
	23894	+ stack[base + 23LLU] = 1556LLU;
23833	23895	// arguments for call to findlet
23834	23896	stack[base + 26LLU] = stack[base + 13]/content/;
23835	23897	stack[base + 27LLU] = stack[base + 2]/scopes/;

		@@ -23839,7 +23901,7 @@
23839	23901	label = 213LLU; // findlet
23840	23902	break;
23841	23903	}
23842		- case 1551LLU: // return from findlet to procblock
	23904	+ case 1556LLU: // return from findlet to procblock
23843	23905	{
23844	23906	// copy mutable arguments back from call to findlet
23845	23907	// copy back results provided by call to findlet

		@@ -23847,7 +23909,7 @@
23847	23909	stack[base + 21] = stack[base + 25LLU];
23848	23910	if(/typename/0 != ((uint64_t )(stack[base + 20]/sizetype*/))[0])
23849	23911	{
23850		- label = 1552LLU; // jump to alternative
	23912	+ label = 1557LLU; // jump to alternative
23851	23913	break;
23852	23914	}
23853	23915

		@@ -23857,7 +23919,7 @@
23857	23919	stack[base + 22]/name/ = ((uint64_t *)(stack[base + 20]/sizetype*/))[1][0];
23858	23920	// call equ from procblock
23859	23921	stack[base + 23LLU] = base;
23860		- stack[base + 24LLU] = 1554LLU;
	23922	+ stack[base + 24LLU] = 1559LLU;
23861	23923	// arguments for call to equ
23862	23924	stack[base + 26LLU] = stack[base + 22]/name/;
23863	23925	stack[base + 27LLU] = 881834713755418624LLU;

		@@ -23866,7 +23928,7 @@
23866	23928	label = 18446744073709551600LLU; // equ
23867	23929	break;
23868	23930	}
23869		- case 1554LLU: // return from equ to procblock
	23931	+ case 1559LLU: // return from equ to procblock
23870	23932	{
23871	23933	// copy mutable arguments back from call to equ
23872	23934	// copy back results provided by call to equ

		@@ -23873,15 +23935,15 @@
23873	23935	stack[base + 18] = stack[base + 25LLU];
23874	23936	if(!stack[base + 18]/isequal/)
23875	23937	{
23876		- label = 1555LLU; // jump to alternative
	23938	+ label = 1560LLU; // jump to alternative
23877	23939	break;
23878	23940	}
23879	23941
23880	23942	// consequent
23881		- label = 1556LLU; // consequent complete
	23943	+ label = 1561LLU; // consequent complete
23882	23944	break;
23883	23945	}
23884		- case 1555LLU: // alternative
	23946	+ case 1560LLU: // alternative
23885	23947	{
23886	23948	fprintf(stderr, "%s", "LISTSIZE provides result of type u64 but found type ");
23887	23949	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -23889,7 +23951,7 @@
23889	23951	// call reporttype from procblock
23890	23952	newstack[0] = (uint64_t)stack; // backup stack location
23891	23953	newstack[1] = base;
23892		- newstack[2] = 1557LLU;
	23954	+ newstack[2] = 1562LLU;
23893	23955	// arguments for call to reporttype
23894	23956	newstack[3LLU] = stack[base + 20]/sizetype/;
23895	23957	stack = newstack;

		@@ -23898,7 +23960,7 @@
23898	23960	label = 75LLU; // reporttype
23899	23961	break;
23900	23962	}
23901		- case 1557LLU: // return from reporttype to procblock
	23963	+ case 1562LLU: // return from reporttype to procblock
23902	23964	{
23903	23965	uint64_t oldstack = (uint64_t )stack[0];
23904	23966	// copy mutable arguments back from call to reporttype

		@@ -23912,7 +23974,7 @@
23912	23974	fprintf(stderr, "%s", " at ");
23913	23975	// call reportid from procblock
23914	23976	stack[base + 23LLU] = base;
23915		- stack[base + 24LLU] = 1558LLU;
	23977	+ stack[base + 24LLU] = 1563LLU;
23916	23978	// arguments for call to reportid
23917	23979	stack[base + 25LLU] = stack[base + 13]/content/;
23918	23980	// set stack-base & callee-address

		@@ -23920,21 +23982,21 @@
23920	23982	label = 18446744073709551587LLU; // reportid
23921	23983	break;
23922	23984	}
23923		- case 1558LLU: // return from reportid to procblock
	23985	+ case 1563LLU: // return from reportid to procblock
23924	23986	{
23925	23987	// copy mutable arguments back from call to reportid
23926	23988	fprintf(stderr, "%s", "\n");
23927	23989	exit(-1);
23928		- label = 1556LLU; // alternative complete
	23990	+ label = 1561LLU; // alternative complete
23929	23991	break;
23930	23992	}
23931		- case 1556LLU: // completed if-then-else
	23993	+ case 1561LLU: // completed if-then-else
23932	23994	{
23933	23995	((uint64_t *)(stack[base + 20]/sizetype/))[1][0] = stack[base + 22]/name*/;
23934		- label = 1553LLU; // consequent complete
	23996	+ label = 1558LLU; // consequent complete
23935	23997	break;
23936	23998	}
23937		- case 1552LLU: // alternative
	23999	+ case 1557LLU: // alternative
23938	24000	{
23939	24001	fprintf(stderr, "%s", "LISTSIZE provides result of type u64 but found type ");
23940	24002	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -23942,7 +24004,7 @@
23942	24004	// call reporttype from procblock
23943	24005	newstack[0] = (uint64_t)stack; // backup stack location
23944	24006	newstack[1] = base;
23945		- newstack[2] = 1559LLU;
	24007	+ newstack[2] = 1564LLU;
23946	24008	// arguments for call to reporttype
23947	24009	newstack[3LLU] = stack[base + 20]/sizetype/;
23948	24010	stack = newstack;

		@@ -23951,7 +24013,7 @@
23951	24013	label = 75LLU; // reporttype
23952	24014	break;
23953	24015	}
23954		- case 1559LLU: // return from reporttype to procblock
	24016	+ case 1564LLU: // return from reporttype to procblock
23955	24017	{
23956	24018	uint64_t oldstack = (uint64_t )stack[0];
23957	24019	// copy mutable arguments back from call to reporttype

		@@ -23965,7 +24027,7 @@
23965	24027	fprintf(stderr, "%s", " at ");
23966	24028	// call reportid from procblock
23967	24029	stack[base + 22LLU] = base;
23968		- stack[base + 23LLU] = 1560LLU;
	24030	+ stack[base + 23LLU] = 1565LLU;
23969	24031	// arguments for call to reportid
23970	24032	stack[base + 24LLU] = stack[base + 13]/content/;
23971	24033	// set stack-base & callee-address

		@@ -23973,19 +24035,19 @@
23973	24035	label = 18446744073709551587LLU; // reportid
23974	24036	break;
23975	24037	}
23976		- case 1560LLU: // return from reportid to procblock
	24038	+ case 1565LLU: // return from reportid to procblock
23977	24039	{
23978	24040	// copy mutable arguments back from call to reportid
23979	24041	fprintf(stderr, "%s", "\n");
23980	24042	exit(-1);
23981		- label = 1553LLU; // alternative complete
	24043	+ label = 1558LLU; // alternative complete
23982	24044	break;
23983	24045	}
23984		- case 1553LLU: // completed if-then-else
	24046	+ case 1558LLU: // completed if-then-else
23985	24047	{
23986	24048	// call matchsym from procblock
23987	24049	stack[base + 20LLU] = base;
23988		- stack[base + 21LLU] = 1561LLU;
	24050	+ stack[base + 21LLU] = 1566LLU;
23989	24051	// arguments for call to matchsym
23990	24052	stack[base + 22LLU] = 41LLU;
23991	24053	stack[base + 23LLU] = stack[base + 11]/lookahead/;

		@@ -23994,18 +24056,18 @@
23994	24056	label = 27LLU; // matchsym
23995	24057	break;
23996	24058	}
23997		- case 1561LLU: // return from matchsym to procblock
	24059	+ case 1566LLU: // return from matchsym to procblock
23998	24060	{
23999	24061	// copy mutable arguments back from call to matchsym
24000	24062	stack[base + 11]/lookahead/ = stack[base + 23LLU];
24001		- label = 1528LLU; // consequent complete
	24063	+ label = 1533LLU; // consequent complete
24002	24064	break;
24003	24065	}
24004		- case 1527LLU: // alternative
	24066	+ case 1532LLU: // alternative
24005	24067	{
24006	24068	// call equ from procblock
24007	24069	stack[base + 19LLU] = base;
24008		- stack[base + 20LLU] = 1562LLU;
	24070	+ stack[base + 20LLU] = 1567LLU;
24009	24071	// arguments for call to equ
24010	24072	stack[base + 22LLU] = stack[base + 13]/content/;
24011	24073	stack[base + 23LLU] = 325763668322287616LLU;

		@@ -24014,7 +24076,7 @@
24014	24076	label = 18446744073709551600LLU; // equ
24015	24077	break;
24016	24078	}
24017		- case 1562LLU: // return from equ to procblock
	24079	+ case 1567LLU: // return from equ to procblock
24018	24080	{
24019	24081	// copy mutable arguments back from call to equ
24020	24082	// copy back results provided by call to equ

		@@ -24021,7 +24083,7 @@
24021	24083	stack[base + 18] = stack[base + 21LLU];
24022	24084	if(!stack[base + 18]/isequal/)
24023	24085	{
24024		- label = 1563LLU; // jump to alternative
	24086	+ label = 1568LLU; // jump to alternative
24025	24087	break;
24026	24088	}
24027	24089

		@@ -24028,7 +24090,7 @@
24028	24090	// consequent
24029	24091	// call parsetoken from procblock
24030	24092	stack[base + 19LLU] = base;
24031		- stack[base + 20LLU] = 1565LLU;
	24093	+ stack[base + 20LLU] = 1570LLU;
24032	24094	// arguments for call to parsetoken
24033	24095	stack[base + 24LLU] = stack[base + 11]/lookahead/;
24034	24096	// set stack-base & callee-address

		@@ -24036,7 +24098,7 @@
24036	24098	label = 18446744073709551585LLU; // parsetoken
24037	24099	break;
24038	24100	}
24039		- case 1565LLU: // return from parsetoken to procblock
	24101	+ case 1570LLU: // return from parsetoken to procblock
24040	24102	{
24041	24103	// copy mutable arguments back from call to parsetoken
24042	24104	// copy back results provided by call to parsetoken

		@@ -24045,7 +24107,7 @@
24045	24107	stack[base + 11] = stack[base + 23LLU];
24046	24108	// call equ from procblock
24047	24109	stack[base + 19LLU] = base;
24048		- stack[base + 20LLU] = 1566LLU;
	24110	+ stack[base + 20LLU] = 1571LLU;
24049	24111	// arguments for call to equ
24050	24112	stack[base + 22LLU] = stack[base + 12]/variant/;
24051	24113	stack[base + 23LLU] = 4LLU;

		@@ -24054,7 +24116,7 @@
24054	24116	label = 18446744073709551600LLU; // equ
24055	24117	break;
24056	24118	}
24057		- case 1566LLU: // return from equ to procblock
	24119	+ case 1571LLU: // return from equ to procblock
24058	24120	{
24059	24121	// copy mutable arguments back from call to equ
24060	24122	// copy back results provided by call to equ

		@@ -24061,7 +24123,7 @@
24061	24123	stack[base + 18] = stack[base + 21LLU];
24062	24124	if(!stack[base + 18]/isequal/)
24063	24125	{
24064		- label = 1567LLU; // jump to alternative
	24126	+ label = 1572LLU; // jump to alternative
24065	24127	break;
24066	24128	}
24067	24129

		@@ -24069,7 +24131,7 @@
24069	24131	printf("%s", "\n list_reverse(((struct listnode **)(&");
24070	24132	// call emitvar from procblock
24071	24133	stack[base + 19LLU] = base;
24072		- stack[base + 20LLU] = 1569LLU;
	24134	+ stack[base + 20LLU] = 1574LLU;
24073	24135	// arguments for call to emitvar
24074	24136	stack[base + 21LLU] = stack[base + 13]/content/;
24075	24137	stack[base + 22LLU] = stack[base + 2]/scopes/;

		@@ -24079,19 +24141,19 @@
24079	24141	label = 224LLU; // emitvar
24080	24142	break;
24081	24143	}
24082		- case 1569LLU: // return from emitvar to procblock
	24144	+ case 1574LLU: // return from emitvar to procblock
24083	24145	{
24084	24146	// copy mutable arguments back from call to emitvar
24085	24147	printf("%s", ")));");
24086		- label = 1568LLU; // consequent complete
	24148	+ label = 1573LLU; // consequent complete
24087	24149	break;
24088	24150	}
24089		- case 1567LLU: // alternative
	24151	+ case 1572LLU: // alternative
24090	24152	{
24091	24153	fprintf(stderr, "%s", "REVERSE requires list-variable but found ");
24092	24154	// call reporttok from procblock
24093	24155	stack[base + 19LLU] = base;
24094		- stack[base + 20LLU] = 1570LLU;
	24156	+ stack[base + 20LLU] = 1575LLU;
24095	24157	// arguments for call to reporttok
24096	24158	stack[base + 21LLU] = stack[base + 12]/variant/;
24097	24159	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -24100,15 +24162,15 @@
24100	24162	label = 18446744073709551583LLU; // reporttok
24101	24163	break;
24102	24164	}
24103		- case 1570LLU: // return from reporttok to procblock
	24165	+ case 1575LLU: // return from reporttok to procblock
24104	24166	{
24105	24167	// copy mutable arguments back from call to reporttok
24106	24168	fprintf(stderr, "%s", "\n");
24107	24169	exit(-1);
24108		- label = 1568LLU; // alternative complete
	24170	+ label = 1573LLU; // alternative complete
24109	24171	break;
24110	24172	}
24111		- case 1568LLU: // completed if-then-else
	24173	+ case 1573LLU: // completed if-then-else
24112	24174	{
24113	24175	//#define listtype 19
24114	24176	stack[base + 19/listtype/] = 0; // init

		@@ -24116,7 +24178,7 @@
24116	24178	stack[base + 20/index/] = 0; // init
24117	24179	// call findlet from procblock
24118	24180	stack[base + 21LLU] = base;
24119		- stack[base + 22LLU] = 1571LLU;
	24181	+ stack[base + 22LLU] = 1576LLU;
24120	24182	// arguments for call to findlet
24121	24183	stack[base + 25LLU] = stack[base + 13]/content/;
24122	24184	stack[base + 26LLU] = stack[base + 2]/scopes/;

		@@ -24126,7 +24188,7 @@
24126	24188	label = 213LLU; // findlet
24127	24189	break;
24128	24190	}
24129		- case 1571LLU: // return from findlet to procblock
	24191	+ case 1576LLU: // return from findlet to procblock
24130	24192	{
24131	24193	// copy mutable arguments back from call to findlet
24132	24194	// copy back results provided by call to findlet

		@@ -24134,7 +24196,7 @@
24134	24196	stack[base + 20] = stack[base + 24LLU];
24135	24197	if(/typelist/1 != ((uint64_t )(stack[base + 19]/listtype*/))[0])
24136	24198	{
24137		- label = 1572LLU; // jump to alternative
	24199	+ label = 1577LLU; // jump to alternative
24138	24200	break;
24139	24201	}
24140	24202

		@@ -24143,10 +24205,10 @@
24143	24205	stack[base + 21/subtype/] = 0; // init
24144	24206	stack[base + 21]/subtype/ = ((uint64_t *)(stack[base + 19]/listtype*/))[1][0];
24145	24207	((uint64_t *)(stack[base + 19]/listtype/))[1][0] = stack[base + 21]/subtype*/;
24146		- label = 1573LLU; // consequent complete
	24208	+ label = 1578LLU; // consequent complete
24147	24209	break;
24148	24210	}
24149		- case 1572LLU: // alternative
	24211	+ case 1577LLU: // alternative
24150	24212	{
24151	24213	fprintf(stderr, "%s", "REVERSE requires list but found type ");
24152	24214	uint64_t newstack = (uint64_t )Calloc(8LLU + 1, sizeof(uint64_t));

		@@ -24154,7 +24216,7 @@
24154	24216	// call reporttype from procblock
24155	24217	newstack[0] = (uint64_t)stack; // backup stack location
24156	24218	newstack[1] = base;
24157		- newstack[2] = 1574LLU;
	24219	+ newstack[2] = 1579LLU;
24158	24220	// arguments for call to reporttype
24159	24221	newstack[3LLU] = stack[base + 19]/listtype/;
24160	24222	stack = newstack;

		@@ -24163,7 +24225,7 @@
24163	24225	label = 75LLU; // reporttype
24164	24226	break;
24165	24227	}
24166		- case 1574LLU: // return from reporttype to procblock
	24228	+ case 1579LLU: // return from reporttype to procblock
24167	24229	{
24168	24230	uint64_t oldstack = (uint64_t )stack[0];
24169	24231	// copy mutable arguments back from call to reporttype

		@@ -24177,7 +24239,7 @@
24177	24239	fprintf(stderr, "%s", " at ");
24178	24240	// call reportid from procblock
24179	24241	stack[base + 21LLU] = base;
24180		- stack[base + 22LLU] = 1575LLU;
	24242	+ stack[base + 22LLU] = 1580LLU;
24181	24243	// arguments for call to reportid
24182	24244	stack[base + 23LLU] = stack[base + 13]/content/;
24183	24245	// set stack-base & callee-address

		@@ -24185,24 +24247,24 @@
24185	24247	label = 18446744073709551587LLU; // reportid
24186	24248	break;
24187	24249	}
24188		- case 1575LLU: // return from reportid to procblock
	24250	+ case 1580LLU: // return from reportid to procblock
24189	24251	{
24190	24252	// copy mutable arguments back from call to reportid
24191	24253	fprintf(stderr, "%s", "\n");
24192	24254	exit(-1);
24193		- label = 1573LLU; // alternative complete
	24255	+ label = 1578LLU; // alternative complete
24194	24256	break;
24195	24257	}
24196		- case 1573LLU: // completed if-then-else
	24258	+ case 1578LLU: // completed if-then-else
24197	24259	{
24198		- label = 1564LLU; // consequent complete
	24260	+ label = 1569LLU; // consequent complete
24199	24261	break;
24200	24262	}
24201		- case 1563LLU: // alternative
	24263	+ case 1568LLU: // alternative
24202	24264	{
24203	24265	// call equ from procblock
24204	24266	stack[base + 19LLU] = base;
24205		- stack[base + 20LLU] = 1576LLU;
	24267	+ stack[base + 20LLU] = 1581LLU;
24206	24268	// arguments for call to equ
24207	24269	stack[base + 22LLU] = stack[base + 13]/content/;
24208	24270	stack[base + 23LLU] = 348752993702641664LLU;

		@@ -24211,7 +24273,7 @@
24211	24273	label = 18446744073709551600LLU; // equ
24212	24274	break;
24213	24275	}
24214		- case 1576LLU: // return from equ to procblock
	24276	+ case 1581LLU: // return from equ to procblock
24215	24277	{
24216	24278	// copy mutable arguments back from call to equ
24217	24279	// copy back results provided by call to equ

		@@ -24218,7 +24280,7 @@
24218	24280	stack[base + 18] = stack[base + 21LLU];
24219	24281	if(!stack[base + 18]/isequal/)
24220	24282	{
24221		- label = 1577LLU; // jump to alternative
	24283	+ label = 1582LLU; // jump to alternative
24222	24284	break;
24223	24285	}
24224	24286

		@@ -24225,7 +24287,7 @@
24225	24287	// consequent
24226	24288	// call parsetoken from procblock
24227	24289	stack[base + 19LLU] = base;
24228		- stack[base + 20LLU] = 1579LLU;
	24290	+ stack[base + 20LLU] = 1584LLU;
24229	24291	// arguments for call to parsetoken
24230	24292	stack[base + 24LLU] = stack[base + 11]/lookahead/;
24231	24293	// set stack-base & callee-address

		@@ -24233,7 +24295,7 @@
24233	24295	label = 18446744073709551585LLU; // parsetoken
24234	24296	break;
24235	24297	}
24236		- case 1579LLU: // return from parsetoken to procblock
	24298	+ case 1584LLU: // return from parsetoken to procblock
24237	24299	{
24238	24300	// copy mutable arguments back from call to parsetoken
24239	24301	// copy back results provided by call to parsetoken

		@@ -24242,7 +24304,7 @@
24242	24304	stack[base + 11] = stack[base + 23LLU];
24243	24305	// call equ from procblock
24244	24306	stack[base + 19LLU] = base;
24245		- stack[base + 20LLU] = 1580LLU;
	24307	+ stack[base + 20LLU] = 1585LLU;
24246	24308	// arguments for call to equ
24247	24309	stack[base + 22LLU] = stack[base + 12]/variant/;
24248	24310	stack[base + 23LLU] = 4LLU;

		@@ -24251,7 +24313,7 @@
24251	24313	label = 18446744073709551600LLU; // equ
24252	24314	break;
24253	24315	}
24254		- case 1580LLU: // return from equ to procblock
	24316	+ case 1585LLU: // return from equ to procblock
24255	24317	{
24256	24318	// copy mutable arguments back from call to equ
24257	24319	// copy back results provided by call to equ

		@@ -24258,20 +24320,20 @@
24258	24320	stack[base + 18] = stack[base + 21LLU];
24259	24321	if(!stack[base + 18]/isequal/)
24260	24322	{
24261		- label = 1581LLU; // jump to alternative
	24323	+ label = 1586LLU; // jump to alternative
24262	24324	break;
24263	24325	}
24264	24326
24265	24327	// consequent
24266		- label = 1582LLU; // consequent complete
	24328	+ label = 1587LLU; // consequent complete
24267	24329	break;
24268	24330	}
24269		- case 1581LLU: // alternative
	24331	+ case 1586LLU: // alternative
24270	24332	{
24271	24333	fprintf(stderr, "%s", "swap requires identifiers but found ");
24272	24334	// call reporttok from procblock
24273	24335	stack[base + 19LLU] = base;
24274		- stack[base + 20LLU] = 1583LLU;
	24336	+ stack[base + 20LLU] = 1588LLU;
24275	24337	// arguments for call to reporttok
24276	24338	stack[base + 21LLU] = stack[base + 12]/variant/;
24277	24339	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -24280,21 +24342,21 @@
24280	24342	label = 18446744073709551583LLU; // reporttok
24281	24343	break;
24282	24344	}
24283		- case 1583LLU: // return from reporttok to procblock
	24345	+ case 1588LLU: // return from reporttok to procblock
24284	24346	{
24285	24347	// copy mutable arguments back from call to reporttok
24286	24348	fprintf(stderr, "%s", "\n");
24287	24349	exit(-1);
24288		- label = 1582LLU; // alternative complete
	24350	+ label = 1587LLU; // alternative complete
24289	24351	break;
24290	24352	}
24291		- case 1582LLU: // completed if-then-else
	24353	+ case 1587LLU: // completed if-then-else
24292	24354	{
24293	24355	//#define x 19
24294	24356	stack[base + 19/x/] = 0; // init
24295	24357	// call FindLet from procblock
24296	24358	stack[base + 20LLU] = base;
24297		- stack[base + 21LLU] = 1584LLU;
	24359	+ stack[base + 21LLU] = 1589LLU;
24298	24360	// arguments for call to FindLet
24299	24361	stack[base + 23LLU] = stack[base + 13]/content/;
24300	24362	stack[base + 24LLU] = stack[base + 2]/scopes/;

		@@ -24304,7 +24366,7 @@
24304	24366	label = 210LLU; // FindLet
24305	24367	break;
24306	24368	}
24307		- case 1584LLU: // return from FindLet to procblock
	24369	+ case 1589LLU: // return from FindLet to procblock
24308	24370	{
24309	24371	// copy mutable arguments back from call to FindLet
24310	24372	// copy back results provided by call to FindLet

		@@ -24311,7 +24373,7 @@
24311	24373	stack[base + 19] = stack[base + 22LLU];
24312	24374	if(/letdef/0 != ((uint64_t )(stack[base + 19]/x*/))[0])
24313	24375	{
24314		- label = 1585LLU; // jump to alternative
	24376	+ label = 1590LLU; // jump to alternative
24315	24377	break;
24316	24378	}
24317	24379

		@@ -24330,7 +24392,7 @@
24330	24392	stack[base + 23]/xmutable/ = ((uint64_t *)(stack[base + 19]/x*/))[1][3];
24331	24393	// call parsetoken from procblock
24332	24394	stack[base + 24LLU] = base;
24333		- stack[base + 25LLU] = 1587LLU;
	24395	+ stack[base + 25LLU] = 1592LLU;
24334	24396	// arguments for call to parsetoken
24335	24397	stack[base + 29LLU] = stack[base + 11]/lookahead/;
24336	24398	// set stack-base & callee-address

		@@ -24338,7 +24400,7 @@
24338	24400	label = 18446744073709551585LLU; // parsetoken
24339	24401	break;
24340	24402	}
24341		- case 1587LLU: // return from parsetoken to procblock
	24403	+ case 1592LLU: // return from parsetoken to procblock
24342	24404	{
24343	24405	// copy mutable arguments back from call to parsetoken
24344	24406	// copy back results provided by call to parsetoken

		@@ -24347,7 +24409,7 @@
24347	24409	stack[base + 11] = stack[base + 28LLU];
24348	24410	// call equ from procblock
24349	24411	stack[base + 24LLU] = base;
24350		- stack[base + 25LLU] = 1588LLU;
	24412	+ stack[base + 25LLU] = 1593LLU;
24351	24413	// arguments for call to equ
24352	24414	stack[base + 27LLU] = stack[base + 12]/variant/;
24353	24415	stack[base + 28LLU] = 4LLU;

		@@ -24356,7 +24418,7 @@
24356	24418	label = 18446744073709551600LLU; // equ
24357	24419	break;
24358	24420	}
24359		- case 1588LLU: // return from equ to procblock
	24421	+ case 1593LLU: // return from equ to procblock
24360	24422	{
24361	24423	// copy mutable arguments back from call to equ
24362	24424	// copy back results provided by call to equ

		@@ -24363,20 +24425,20 @@
24363	24425	stack[base + 18] = stack[base + 26LLU];
24364	24426	if(!stack[base + 18]/isequal/)
24365	24427	{
24366		- label = 1589LLU; // jump to alternative
	24428	+ label = 1594LLU; // jump to alternative
24367	24429	break;
24368	24430	}
24369	24431
24370	24432	// consequent
24371		- label = 1590LLU; // consequent complete
	24433	+ label = 1595LLU; // consequent complete
24372	24434	break;
24373	24435	}
24374		- case 1589LLU: // alternative
	24436	+ case 1594LLU: // alternative
24375	24437	{
24376	24438	fprintf(stderr, "%s", "swap requires identifiers but found ");
24377	24439	// call reporttok from procblock
24378	24440	stack[base + 24LLU] = base;
24379		- stack[base + 25LLU] = 1591LLU;
	24441	+ stack[base + 25LLU] = 1596LLU;
24380	24442	// arguments for call to reporttok
24381	24443	stack[base + 26LLU] = stack[base + 12]/variant/;
24382	24444	stack[base + 27LLU] = stack[base + 13]/content/;

		@@ -24385,21 +24447,21 @@
24385	24447	label = 18446744073709551583LLU; // reporttok
24386	24448	break;
24387	24449	}
24388		- case 1591LLU: // return from reporttok to procblock
	24450	+ case 1596LLU: // return from reporttok to procblock
24389	24451	{
24390	24452	// copy mutable arguments back from call to reporttok
24391	24453	fprintf(stderr, "%s", "\n");
24392	24454	exit(-1);
24393		- label = 1590LLU; // alternative complete
	24455	+ label = 1595LLU; // alternative complete
24394	24456	break;
24395	24457	}
24396		- case 1590LLU: // completed if-then-else
	24458	+ case 1595LLU: // completed if-then-else
24397	24459	{
24398	24460	//#define y 24
24399	24461	stack[base + 24/y/] = 0; // init
24400	24462	// call FindLet from procblock
24401	24463	stack[base + 25LLU] = base;
24402		- stack[base + 26LLU] = 1592LLU;
	24464	+ stack[base + 26LLU] = 1597LLU;
24403	24465	// arguments for call to FindLet
24404	24466	stack[base + 28LLU] = stack[base + 13]/content/;
24405	24467	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -24409,7 +24471,7 @@
24409	24471	label = 210LLU; // FindLet
24410	24472	break;
24411	24473	}
24412		- case 1592LLU: // return from FindLet to procblock
	24474	+ case 1597LLU: // return from FindLet to procblock
24413	24475	{
24414	24476	// copy mutable arguments back from call to FindLet
24415	24477	// copy back results provided by call to FindLet

		@@ -24416,7 +24478,7 @@
24416	24478	stack[base + 24] = stack[base + 27LLU];
24417	24479	if(/letdef/0 != ((uint64_t )(stack[base + 24]/y*/))[0])
24418	24480	{
24419		- label = 1593LLU; // jump to alternative
	24481	+ label = 1598LLU; // jump to alternative
24420	24482	break;
24421	24483	}
24422	24484

		@@ -24438,7 +24500,7 @@
24438	24500	// call equtype from procblock
24439	24501	newstack[0] = (uint64_t)stack; // backup stack location
24440	24502	newstack[1] = base;
24441		- newstack[2] = 1595LLU;
	24503	+ newstack[2] = 1600LLU;
24442	24504	// arguments for call to equtype
24443	24505	newstack[4LLU] = stack[base + 20]/xtype/;
24444	24506	newstack[5LLU] = stack[base + 25]/ytype/;

		@@ -24448,7 +24510,7 @@
24448	24510	label = 90LLU; // equtype
24449	24511	break;
24450	24512	}
24451		- case 1595LLU: // return from equtype to procblock
	24513	+ case 1600LLU: // return from equtype to procblock
24452	24514	{
24453	24515	uint64_t oldstack = (uint64_t )stack[0];
24454	24516	// copy mutable arguments back from call to equtype

		@@ -24463,20 +24525,20 @@
24463	24525	stack = oldstack;
24464	24526	if(!stack[base + 18]/isequal/)
24465	24527	{
24466		- label = 1596LLU; // jump to alternative
	24528	+ label = 1601LLU; // jump to alternative
24467	24529	break;
24468	24530	}
24469	24531
24470	24532	// consequent
24471		- label = 1597LLU; // consequent complete
	24533	+ label = 1602LLU; // consequent complete
24472	24534	break;
24473	24535	}
24474		- case 1596LLU: // alternative
	24536	+ case 1601LLU: // alternative
24475	24537	{
24476	24538	fprintf(stderr, "%s", "in function ");
24477	24539	// call reportid from procblock
24478	24540	stack[base + 29LLU] = base;
24479		- stack[base + 30LLU] = 1598LLU;
	24541	+ stack[base + 30LLU] = 1603LLU;
24480	24542	// arguments for call to reportid
24481	24543	stack[base + 31LLU] = stack[base + 5]/fnid/;
24482	24544	// set stack-base & callee-address

		@@ -24484,7 +24546,7 @@
24484	24546	label = 18446744073709551587LLU; // reportid
24485	24547	break;
24486	24548	}
24487		- case 1598LLU: // return from reportid to procblock
	24549	+ case 1603LLU: // return from reportid to procblock
24488	24550	{
24489	24551	// copy mutable arguments back from call to reportid
24490	24552	fprintf(stderr, "%s", ": can't swap different types ");

		@@ -24493,7 +24555,7 @@
24493	24555	// call reporttype from procblock
24494	24556	newstack[0] = (uint64_t)stack; // backup stack location
24495	24557	newstack[1] = base;
24496		- newstack[2] = 1599LLU;
	24558	+ newstack[2] = 1604LLU;
24497	24559	// arguments for call to reporttype
24498	24560	newstack[3LLU] = stack[base + 20]/xtype/;
24499	24561	stack = newstack;

		@@ -24502,7 +24564,7 @@
24502	24564	label = 75LLU; // reporttype
24503	24565	break;
24504	24566	}
24505		- case 1599LLU: // return from reporttype to procblock
	24567	+ case 1604LLU: // return from reporttype to procblock
24506	24568	{
24507	24569	uint64_t oldstack = (uint64_t )stack[0];
24508	24570	// copy mutable arguments back from call to reporttype

		@@ -24519,7 +24581,7 @@
24519	24581	// call reporttype from procblock
24520	24582	newstack[0] = (uint64_t)stack; // backup stack location
24521	24583	newstack[1] = base;
24522		- newstack[2] = 1600LLU;
	24584	+ newstack[2] = 1605LLU;
24523	24585	// arguments for call to reporttype
24524	24586	newstack[3LLU] = stack[base + 25]/ytype/;
24525	24587	stack = newstack;

		@@ -24528,7 +24590,7 @@
24528	24590	label = 75LLU; // reporttype
24529	24591	break;
24530	24592	}
24531		- case 1600LLU: // return from reporttype to procblock
	24593	+ case 1605LLU: // return from reporttype to procblock
24532	24594	{
24533	24595	uint64_t oldstack = (uint64_t )stack[0];
24534	24596	// copy mutable arguments back from call to reporttype

		@@ -24541,27 +24603,27 @@
24541	24603	stack = oldstack;
24542	24604	fprintf(stderr, "%s", "\n");
24543	24605	exit(-1);
24544		- label = 1597LLU; // alternative complete
	24606	+ label = 1602LLU; // alternative complete
24545	24607	break;
24546	24608	}
24547		- case 1597LLU: // completed if-then-else
	24609	+ case 1602LLU: // completed if-then-else
24548	24610	{
24549	24611	if(!stack[base + 23]/xmutable/)
24550	24612	{
24551		- label = 1601LLU; // jump to alternative
	24613	+ label = 1606LLU; // jump to alternative
24552	24614	break;
24553	24615	}
24554	24616
24555	24617	// consequent
24556		- label = 1602LLU; // consequent complete
	24618	+ label = 1607LLU; // consequent complete
24557	24619	break;
24558	24620	}
24559		- case 1601LLU: // alternative
	24621	+ case 1606LLU: // alternative
24560	24622	{
24561	24623	fprintf(stderr, "%s", "can't swap constant ");
24562	24624	// call reportid from procblock
24563	24625	stack[base + 29LLU] = base;
24564		- stack[base + 30LLU] = 1603LLU;
	24626	+ stack[base + 30LLU] = 1608LLU;
24565	24627	// arguments for call to reportid
24566	24628	stack[base + 31LLU] = stack[base + 21]/xid/;
24567	24629	// set stack-base & callee-address

		@@ -24569,7 +24631,7 @@
24569	24631	label = 18446744073709551587LLU; // reportid
24570	24632	break;
24571	24633	}
24572		- case 1603LLU: // return from reportid to procblock
	24634	+ case 1608LLU: // return from reportid to procblock
24573	24635	{
24574	24636	// copy mutable arguments back from call to reportid
24575	24637	fprintf(stderr, "%s", " of type ");

		@@ -24578,7 +24640,7 @@
24578	24640	// call reporttype from procblock
24579	24641	newstack[0] = (uint64_t)stack; // backup stack location
24580	24642	newstack[1] = base;
24581		- newstack[2] = 1604LLU;
	24643	+ newstack[2] = 1609LLU;
24582	24644	// arguments for call to reporttype
24583	24645	newstack[3LLU] = stack[base + 20]/xtype/;
24584	24646	stack = newstack;

		@@ -24587,7 +24649,7 @@
24587	24649	label = 75LLU; // reporttype
24588	24650	break;
24589	24651	}
24590		- case 1604LLU: // return from reporttype to procblock
	24652	+ case 1609LLU: // return from reporttype to procblock
24591	24653	{
24592	24654	uint64_t oldstack = (uint64_t )stack[0];
24593	24655	// copy mutable arguments back from call to reporttype

		@@ -24600,27 +24662,27 @@
24600	24662	stack = oldstack;
24601	24663	fprintf(stderr, "%s", "\n");
24602	24664	exit(-1);
24603		- label = 1602LLU; // alternative complete
	24665	+ label = 1607LLU; // alternative complete
24604	24666	break;
24605	24667	}
24606		- case 1602LLU: // completed if-then-else
	24668	+ case 1607LLU: // completed if-then-else
24607	24669	{
24608	24670	if(!stack[base + 28]/ymutable/)
24609	24671	{
24610		- label = 1605LLU; // jump to alternative
	24672	+ label = 1610LLU; // jump to alternative
24611	24673	break;
24612	24674	}
24613	24675
24614	24676	// consequent
24615		- label = 1606LLU; // consequent complete
	24677	+ label = 1611LLU; // consequent complete
24616	24678	break;
24617	24679	}
24618		- case 1605LLU: // alternative
	24680	+ case 1610LLU: // alternative
24619	24681	{
24620	24682	fprintf(stderr, "%s", "can't swap constant ");
24621	24683	// call reportid from procblock
24622	24684	stack[base + 29LLU] = base;
24623		- stack[base + 30LLU] = 1607LLU;
	24685	+ stack[base + 30LLU] = 1612LLU;
24624	24686	// arguments for call to reportid
24625	24687	stack[base + 31LLU] = stack[base + 26]/yid/;
24626	24688	// set stack-base & callee-address

		@@ -24628,7 +24690,7 @@
24628	24690	label = 18446744073709551587LLU; // reportid
24629	24691	break;
24630	24692	}
24631		- case 1607LLU: // return from reportid to procblock
	24693	+ case 1612LLU: // return from reportid to procblock
24632	24694	{
24633	24695	// copy mutable arguments back from call to reportid
24634	24696	fprintf(stderr, "%s", " of type ");

		@@ -24637,7 +24699,7 @@
24637	24699	// call reporttype from procblock
24638	24700	newstack[0] = (uint64_t)stack; // backup stack location
24639	24701	newstack[1] = base;
24640		- newstack[2] = 1608LLU;
	24702	+ newstack[2] = 1613LLU;
24641	24703	// arguments for call to reporttype
24642	24704	newstack[3LLU] = stack[base + 25]/ytype/;
24643	24705	stack = newstack;

		@@ -24646,7 +24708,7 @@
24646	24708	label = 75LLU; // reporttype
24647	24709	break;
24648	24710	}
24649		- case 1608LLU: // return from reporttype to procblock
	24711	+ case 1613LLU: // return from reporttype to procblock
24650	24712	{
24651	24713	uint64_t oldstack = (uint64_t )stack[0];
24652	24714	// copy mutable arguments back from call to reporttype

		@@ -24659,15 +24721,15 @@
24659	24721	stack = oldstack;
24660	24722	fprintf(stderr, "%s", "\n");
24661	24723	exit(-1);
24662		- label = 1606LLU; // alternative complete
	24724	+ label = 1611LLU; // alternative complete
24663	24725	break;
24664	24726	}
24665		- case 1606LLU: // completed if-then-else
	24727	+ case 1611LLU: // completed if-then-else
24666	24728	{
24667	24729	printf("%s", "\n swap(&");
24668	24730	// call emitvaridx from procblock
24669	24731	stack[base + 29LLU] = base;
24670		- stack[base + 30LLU] = 1609LLU;
	24732	+ stack[base + 30LLU] = 1614LLU;
24671	24733	// arguments for call to emitvaridx
24672	24734	stack[base + 31LLU] = stack[base + 22]/xindex/;
24673	24735	// set stack-base & callee-address

		@@ -24675,13 +24737,13 @@
24675	24737	label = 222LLU; // emitvaridx
24676	24738	break;
24677	24739	}
24678		- case 1609LLU: // return from emitvaridx to procblock
	24740	+ case 1614LLU: // return from emitvaridx to procblock
24679	24741	{
24680	24742	// copy mutable arguments back from call to emitvaridx
24681	24743	printf("%s", ", &");
24682	24744	// call emitvaridx from procblock
24683	24745	stack[base + 29LLU] = base;
24684		- stack[base + 30LLU] = 1610LLU;
	24746	+ stack[base + 30LLU] = 1615LLU;
24685	24747	// arguments for call to emitvaridx
24686	24748	stack[base + 31LLU] = stack[base + 27]/yindex/;
24687	24749	// set stack-base & callee-address

		@@ -24689,7 +24751,7 @@
24689	24751	label = 222LLU; // emitvaridx
24690	24752	break;
24691	24753	}
24692		- case 1610LLU: // return from emitvaridx to procblock
	24754	+ case 1615LLU: // return from emitvaridx to procblock
24693	24755	{
24694	24756	// copy mutable arguments back from call to emitvaridx
24695	24757	printf("%s", ");");

		@@ -24697,38 +24759,38 @@
24697	24759	((uint64_t *)(stack[base + 24]/y/))[1][2] = stack[base + 27]/yindex*/;
24698	24760	((uint64_t *)(stack[base + 24]/y/))[1][1] = stack[base + 26]/yid*/;
24699	24761	((uint64_t *)(stack[base + 24]/y/))[1][0] = stack[base + 25]/ytype*/;
24700		- label = 1594LLU; // consequent complete
	24762	+ label = 1599LLU; // consequent complete
24701	24763	break;
24702	24764	}
24703		- case 1593LLU: // alternative
	24765	+ case 1598LLU: // alternative
24704	24766	{
24705	24767	fprintf(stderr, "%s", "INTERNAL ERROR accessing letdef\n");
24706	24768	exit(-1);
24707		- label = 1594LLU; // alternative complete
	24769	+ label = 1599LLU; // alternative complete
24708	24770	break;
24709	24771	}
24710		- case 1594LLU: // completed if-then-else
	24772	+ case 1599LLU: // completed if-then-else
24711	24773	{
24712	24774	((uint64_t *)(stack[base + 19]/x/))[1][3] = stack[base + 23]/xmutable*/;
24713	24775	((uint64_t *)(stack[base + 19]/x/))[1][2] = stack[base + 22]/xindex*/;
24714	24776	((uint64_t *)(stack[base + 19]/x/))[1][1] = stack[base + 21]/xid*/;
24715	24777	((uint64_t *)(stack[base + 19]/x/))[1][0] = stack[base + 20]/xtype*/;
24716		- label = 1586LLU; // consequent complete
	24778	+ label = 1591LLU; // consequent complete
24717	24779	break;
24718	24780	}
24719		- case 1585LLU: // alternative
	24781	+ case 1590LLU: // alternative
24720	24782	{
24721	24783	fprintf(stderr, "%s", "INTERNAL ERROR accessing letdef\n");
24722	24784	exit(-1);
24723		- label = 1586LLU; // alternative complete
	24785	+ label = 1591LLU; // alternative complete
24724	24786	break;
24725	24787	}
24726		- case 1586LLU: // completed if-then-else
	24788	+ case 1591LLU: // completed if-then-else
24727	24789	{
24728		- label = 1578LLU; // consequent complete
	24790	+ label = 1583LLU; // consequent complete
24729	24791	break;
24730	24792	}
24731		- case 1577LLU: // alternative
	24793	+ case 1582LLU: // alternative
24732	24794	{
24733	24795	//#define id 19
24734	24796	stack[base + 19/id/] = 0; // init

		@@ -24735,7 +24797,7 @@
24735	24797	stack[base + 19]/id/ = stack[base + 13]/content/;
24736	24798	// call parsetoken from procblock
24737	24799	stack[base + 20LLU] = base;
24738		- stack[base + 21LLU] = 1611LLU;
	24800	+ stack[base + 21LLU] = 1616LLU;
24739	24801	// arguments for call to parsetoken
24740	24802	stack[base + 25LLU] = stack[base + 11]/lookahead/;
24741	24803	// set stack-base & callee-address

		@@ -24743,7 +24805,7 @@
24743	24805	label = 18446744073709551585LLU; // parsetoken
24744	24806	break;
24745	24807	}
24746		- case 1611LLU: // return from parsetoken to procblock
	24808	+ case 1616LLU: // return from parsetoken to procblock
24747	24809	{
24748	24810	// copy mutable arguments back from call to parsetoken
24749	24811	// copy back results provided by call to parsetoken

		@@ -24752,7 +24814,7 @@
24752	24814	stack[base + 11] = stack[base + 24LLU];
24753	24815	// call issimple from procblock
24754	24816	stack[base + 20LLU] = base;
24755		- stack[base + 21LLU] = 1612LLU;
	24817	+ stack[base + 21LLU] = 1617LLU;
24756	24818	// arguments for call to issimple
24757	24819	stack[base + 23LLU] = stack[base + 12]/variant/;
24758	24820	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -24762,7 +24824,7 @@
24762	24824	label = 18LLU; // issimple
24763	24825	break;
24764	24826	}
24765		- case 1612LLU: // return from issimple to procblock
	24827	+ case 1617LLU: // return from issimple to procblock
24766	24828	{
24767	24829	// copy mutable arguments back from call to issimple
24768	24830	// copy back results provided by call to issimple

		@@ -24769,7 +24831,7 @@
24769	24831	stack[base + 18] = stack[base + 22LLU];
24770	24832	if(!stack[base + 18]/isequal/)
24771	24833	{
24772		- label = 1613LLU; // jump to alternative
	24834	+ label = 1618LLU; // jump to alternative
24773	24835	break;
24774	24836	}
24775	24837

		@@ -24782,7 +24844,7 @@
24782	24844	stack[base + 22/mutable/] = 0; // init
24783	24845	// call FINDLET from procblock
24784	24846	stack[base + 23LLU] = base;
24785		- stack[base + 24LLU] = 1615LLU;
	24847	+ stack[base + 24LLU] = 1620LLU;
24786	24848	// arguments for call to FINDLET
24787	24849	stack[base + 28LLU] = stack[base + 19]/id/;
24788	24850	stack[base + 29LLU] = stack[base + 2]/scopes/;

		@@ -24792,7 +24854,7 @@
24792	24854	label = 186LLU; // FINDLET
24793	24855	break;
24794	24856	}
24795		- case 1615LLU: // return from FINDLET to procblock
	24857	+ case 1620LLU: // return from FINDLET to procblock
24796	24858	{
24797	24859	// copy mutable arguments back from call to FINDLET
24798	24860	// copy back results provided by call to FINDLET

		@@ -24801,20 +24863,20 @@
24801	24863	stack[base + 22] = stack[base + 27LLU];
24802	24864	if(!stack[base + 22]/mutable/)
24803	24865	{
24804		- label = 1616LLU; // jump to alternative
	24866	+ label = 1621LLU; // jump to alternative
24805	24867	break;
24806	24868	}
24807	24869
24808	24870	// consequent
24809		- label = 1617LLU; // consequent complete
	24871	+ label = 1622LLU; // consequent complete
24810	24872	break;
24811	24873	}
24812		- case 1616LLU: // alternative
	24874	+ case 1621LLU: // alternative
24813	24875	{
24814	24876	fprintf(stderr, "%s", "in function ");
24815	24877	// call reportid from procblock
24816	24878	stack[base + 23LLU] = base;
24817		- stack[base + 24LLU] = 1618LLU;
	24879	+ stack[base + 24LLU] = 1623LLU;
24818	24880	// arguments for call to reportid
24819	24881	stack[base + 25LLU] = stack[base + 5]/fnid/;
24820	24882	// set stack-base & callee-address

		@@ -24822,13 +24884,13 @@
24822	24884	label = 18446744073709551587LLU; // reportid
24823	24885	break;
24824	24886	}
24825		- case 1618LLU: // return from reportid to procblock
	24887	+ case 1623LLU: // return from reportid to procblock
24826	24888	{
24827	24889	// copy mutable arguments back from call to reportid
24828	24890	fprintf(stderr, "%s", ": assignment to constant ");
24829	24891	// call reportid from procblock
24830	24892	stack[base + 23LLU] = base;
24831		- stack[base + 24LLU] = 1619LLU;
	24893	+ stack[base + 24LLU] = 1624LLU;
24832	24894	// arguments for call to reportid
24833	24895	stack[base + 25LLU] = stack[base + 19]/id/;
24834	24896	// set stack-base & callee-address

		@@ -24836,19 +24898,19 @@
24836	24898	label = 18446744073709551587LLU; // reportid
24837	24899	break;
24838	24900	}
24839		- case 1619LLU: // return from reportid to procblock
	24901	+ case 1624LLU: // return from reportid to procblock
24840	24902	{
24841	24903	// copy mutable arguments back from call to reportid
24842	24904	fprintf(stderr, "%s", "\n");
24843	24905	exit(-1);
24844		- label = 1617LLU; // alternative complete
	24906	+ label = 1622LLU; // alternative complete
24845	24907	break;
24846	24908	}
24847		- case 1617LLU: // completed if-then-else
	24909	+ case 1622LLU: // completed if-then-else
24848	24910	{
24849	24911	// call parsetoken from procblock
24850	24912	stack[base + 23LLU] = base;
24851		- stack[base + 24LLU] = 1620LLU;
	24913	+ stack[base + 24LLU] = 1625LLU;
24852	24914	// arguments for call to parsetoken
24853	24915	stack[base + 28LLU] = stack[base + 11]/lookahead/;
24854	24916	// set stack-base & callee-address

		@@ -24856,7 +24918,7 @@
24856	24918	label = 18446744073709551585LLU; // parsetoken
24857	24919	break;
24858	24920	}
24859		- case 1620LLU: // return from parsetoken to procblock
	24921	+ case 1625LLU: // return from parsetoken to procblock
24860	24922	{
24861	24923	// copy mutable arguments back from call to parsetoken
24862	24924	// copy back results provided by call to parsetoken

		@@ -24865,7 +24927,7 @@
24865	24927	stack[base + 11] = stack[base + 27LLU];
24866	24928	// call AssignFrom from procblock
24867	24929	stack[base + 23LLU] = base;
24868		- stack[base + 24LLU] = 1621LLU;
	24930	+ stack[base + 24LLU] = 1626LLU;
24869	24931	// arguments for call to AssignFrom
24870	24932	stack[base + 25LLU] = stack[base + 5]/fnid/;
24871	24933	stack[base + 26LLU] = stack[base + 19]/id/;

		@@ -24885,7 +24947,7 @@
24885	24947	label = 883LLU; // AssignFrom
24886	24948	break;
24887	24949	}
24888		- case 1621LLU: // return from AssignFrom to procblock
	24950	+ case 1626LLU: // return from AssignFrom to procblock
24889	24951	{
24890	24952	// copy mutable arguments back from call to AssignFrom
24891	24953	stack[base + 13]/content/ = stack[base + 37LLU];

		@@ -24894,14 +24956,14 @@
24894	24956	stack[base + 16]/varcount/ = stack[base + 34LLU];
24895	24957	stack[base + 9]/fnmaxcount/ = stack[base + 33LLU];
24896	24958	stack[base + 3]/scope/ = stack[base + 30LLU];
24897		- label = 1614LLU; // consequent complete
	24959	+ label = 1619LLU; // consequent complete
24898	24960	break;
24899	24961	}
24900		- case 1613LLU: // alternative
	24962	+ case 1618LLU: // alternative
24901	24963	{
24902	24964	// call issimple from procblock
24903	24965	stack[base + 20LLU] = base;
24904		- stack[base + 21LLU] = 1622LLU;
	24966	+ stack[base + 21LLU] = 1627LLU;
24905	24967	// arguments for call to issimple
24906	24968	stack[base + 23LLU] = stack[base + 12]/variant/;
24907	24969	stack[base + 24LLU] = stack[base + 13]/content/;

		@@ -24911,7 +24973,7 @@
24911	24973	label = 18LLU; // issimple
24912	24974	break;
24913	24975	}
24914		- case 1622LLU: // return from issimple to procblock
	24976	+ case 1627LLU: // return from issimple to procblock
24915	24977	{
24916	24978	// copy mutable arguments back from call to issimple
24917	24979	// copy back results provided by call to issimple

		@@ -24918,7 +24980,7 @@
24918	24980	stack[base + 18] = stack[base + 22LLU];
24919	24981	if(!stack[base + 18]/isequal/)
24920	24982	{
24921		- label = 1623LLU; // jump to alternative
	24983	+ label = 1628LLU; // jump to alternative
24922	24984	break;
24923	24985	}
24924	24986

		@@ -24927,7 +24989,7 @@
24927	24989	stack[base + 20/calleedef/] = 0; // init
24928	24990	// call findfn from procblock
24929	24991	stack[base + 21LLU] = base;
24930		- stack[base + 22LLU] = 1625LLU;
	24992	+ stack[base + 22LLU] = 1630LLU;
24931	24993	// arguments for call to findfn
24932	24994	stack[base + 24LLU] = stack[base + 0]/fndefs/;
24933	24995	stack[base + 25LLU] = stack[base + 19]/id/;

		@@ -24936,7 +24998,7 @@
24936	24998	label = 386LLU; // findfn
24937	24999	break;
24938	25000	}
24939		- case 1625LLU: // return from findfn to procblock
	25001	+ case 1630LLU: // return from findfn to procblock
24940	25002	{
24941	25003	// copy mutable arguments back from call to findfn
24942	25004	// copy back results provided by call to findfn

		@@ -24943,7 +25005,7 @@
24943	25005	stack[base + 20] = stack[base + 23LLU];
24944	25006	if(/fndef/0 != ((uint64_t )(stack[base + 20]/calleedef*/))[0])
24945	25007	{
24946		- label = 1626LLU; // jump to alternative
	25008	+ label = 1631LLU; // jump to alternative
24947	25009	break;
24948	25010	}
24949	25011

		@@ -24972,7 +25034,7 @@
24972	25034	stack[base + 28/locked/] = 0; // init
24973	25035	// call ProcCall from procblock
24974	25036	stack[base + 29LLU] = base;
24975		- stack[base + 30LLU] = 1628LLU;
	25037	+ stack[base + 30LLU] = 1633LLU;
24976	25038	// arguments for call to ProcCall
24977	25039	stack[base + 31LLU] = stack[base + 27]/verified/;
24978	25040	stack[base + 32LLU] = stack[base + 28]/locked/;

		@@ -24996,7 +25058,7 @@
24996	25058	label = 430LLU; // ProcCall
24997	25059	break;
24998	25060	}
24999		- case 1628LLU: // return from ProcCall to procblock
	25061	+ case 1633LLU: // return from ProcCall to procblock
25000	25062	{
25001	25063	// copy mutable arguments back from call to ProcCall
25002	25064	stack[base + 14]/label/ = stack[base + 47LLU];

		@@ -25012,27 +25074,27 @@
25012	25074	((uint64_t *)(stack[base + 20]/calleedef/))[1][2] = stack[base + 23]/ceargtypes*/;
25013	25075	((uint64_t *)(stack[base + 20]/calleedef/))[1][1] = stack[base + 22]/cerestypes*/;
25014	25076	((uint64_t *)(stack[base + 20]/calleedef/))[1][0] = stack[base + 21]/celabel*/;
25015		- label = 1627LLU; // consequent complete
	25077	+ label = 1632LLU; // consequent complete
25016	25078	break;
25017	25079	}
25018		- case 1626LLU: // alternative
	25080	+ case 1631LLU: // alternative
25019	25081	{
25020	25082	fprintf(stderr, "%s", "INTERNAL ERROR accessing fndef\n");
25021	25083	exit(-1);
25022		- label = 1627LLU; // alternative complete
	25084	+ label = 1632LLU; // alternative complete
25023	25085	break;
25024	25086	}
25025		- case 1627LLU: // completed if-then-else
	25087	+ case 1632LLU: // completed if-then-else
25026	25088	{
25027		- label = 1624LLU; // consequent complete
	25089	+ label = 1629LLU; // consequent complete
25028	25090	break;
25029	25091	}
25030		- case 1623LLU: // alternative
	25092	+ case 1628LLU: // alternative
25031	25093	{
25032	25094	fprintf(stderr, "%s", "expected assignment or call but found unexpected token ");
25033	25095	// call reporttok from procblock
25034	25096	stack[base + 20LLU] = base;
25035		- stack[base + 21LLU] = 1629LLU;
	25097	+ stack[base + 21LLU] = 1634LLU;
25036	25098	// arguments for call to reporttok
25037	25099	stack[base + 22LLU] = stack[base + 12]/variant/;
25038	25100	stack[base + 23LLU] = stack[base + 13]/content/;

		@@ -25041,85 +25103,85 @@
25041	25103	label = 18446744073709551583LLU; // reporttok
25042	25104	break;
25043	25105	}
25044		- case 1629LLU: // return from reporttok to procblock
	25106	+ case 1634LLU: // return from reporttok to procblock
25045	25107	{
25046	25108	// copy mutable arguments back from call to reporttok
25047	25109	fprintf(stderr, "%s", "\n");
25048	25110	exit(-1);
25049		- label = 1624LLU; // alternative complete
	25111	+ label = 1629LLU; // alternative complete
25050	25112	break;
25051	25113	}
25052		- case 1624LLU: // completed if-then-else
	25114	+ case 1629LLU: // completed if-then-else
25053	25115	{
25054		- label = 1614LLU; // alternative complete
	25116	+ label = 1619LLU; // alternative complete
25055	25117	break;
25056	25118	}
25057		- case 1614LLU: // completed if-then-else
	25119	+ case 1619LLU: // completed if-then-else
25058	25120	{
25059		- label = 1578LLU; // alternative complete
	25121	+ label = 1583LLU; // alternative complete
25060	25122	break;
25061	25123	}
25062		- case 1578LLU: // completed if-then-else
	25124	+ case 1583LLU: // completed if-then-else
25063	25125	{
25064		- label = 1564LLU; // alternative complete
	25126	+ label = 1569LLU; // alternative complete
25065	25127	break;
25066	25128	}
25067		- case 1564LLU: // completed if-then-else
	25129	+ case 1569LLU: // completed if-then-else
25068	25130	{
25069		- label = 1528LLU; // alternative complete
	25131	+ label = 1533LLU; // alternative complete
25070	25132	break;
25071	25133	}
25072		- case 1528LLU: // completed if-then-else
	25134	+ case 1533LLU: // completed if-then-else
25073	25135	{
25074		- label = 1498LLU; // alternative complete
	25136	+ label = 1503LLU; // alternative complete
25075	25137	break;
25076	25138	}
25077		- case 1498LLU: // completed if-then-else
	25139	+ case 1503LLU: // completed if-then-else
25078	25140	{
25079		- label = 1467LLU; // alternative complete
	25141	+ label = 1472LLU; // alternative complete
25080	25142	break;
25081	25143	}
25082		- case 1467LLU: // completed if-then-else
	25144	+ case 1472LLU: // completed if-then-else
25083	25145	{
25084		- label = 1458LLU; // alternative complete
	25146	+ label = 1463LLU; // alternative complete
25085	25147	break;
25086	25148	}
25087		- case 1458LLU: // completed if-then-else
	25149	+ case 1463LLU: // completed if-then-else
25088	25150	{
25089		- label = 1448LLU; // alternative complete
	25151	+ label = 1453LLU; // alternative complete
25090	25152	break;
25091	25153	}
25092		- case 1448LLU: // completed if-then-else
	25154	+ case 1453LLU: // completed if-then-else
25093	25155	{
25094		- label = 1366LLU; // alternative complete
	25156	+ label = 1371LLU; // alternative complete
25095	25157	break;
25096	25158	}
25097		- case 1366LLU: // completed if-then-else
	25159	+ case 1371LLU: // completed if-then-else
25098	25160	{
25099		- label = 1348LLU; // alternative complete
	25161	+ label = 1353LLU; // alternative complete
25100	25162	break;
25101	25163	}
25102		- case 1348LLU: // completed if-then-else
	25164	+ case 1353LLU: // completed if-then-else
25103	25165	{
25104		- label = 1342LLU; // alternative complete
	25166	+ label = 1347LLU; // alternative complete
25105	25167	break;
25106	25168	}
25107		- case 1342LLU: // completed if-then-else
	25169	+ case 1347LLU: // completed if-then-else
25108	25170	{
25109		- label = 1336LLU; // alternative complete
	25171	+ label = 1341LLU; // alternative complete
25110	25172	break;
25111	25173	}
25112		- case 1336LLU: // completed if-then-else
	25174	+ case 1341LLU: // completed if-then-else
25113	25175	{
25114		- label = 1333LLU; // alternative complete
	25176	+ label = 1338LLU; // alternative complete
25115	25177	break;
25116	25178	}
25117		- case 1333LLU: // completed if-then-else
	25179	+ case 1338LLU: // completed if-then-else
25118	25180	{
25119		- label = 1251LLU; // alternative complete
	25181	+ label = 1256LLU; // alternative complete
25120	25182	break;
25121	25183	}
25122		- case 1251LLU: // completed if-then-else
	25184	+ case 1256LLU: // completed if-then-else
25123	25185	{
25124	25186	label = 1002LLU; // alternative complete
25125	25187	break;

		@@ -25134,7 +25196,7 @@
25134	25196	fprintf(stderr, "%s", "parsing block unexpected token ");
25135	25197	// call reporttok from procblock
25136	25198	stack[base + 19LLU] = base;
25137		- stack[base + 20LLU] = 1630LLU;
	25199	+ stack[base + 20LLU] = 1635LLU;
25138	25200	// arguments for call to reporttok
25139	25201	stack[base + 21LLU] = stack[base + 12]/variant/;
25140	25202	stack[base + 22LLU] = stack[base + 13]/content/;

		@@ -25143,7 +25205,7 @@
25143	25205	label = 18446744073709551583LLU; // reporttok
25144	25206	break;
25145	25207	}
25146		- case 1630LLU: // return from reporttok to procblock
	25208	+ case 1635LLU: // return from reporttok to procblock
25147	25209	{
25148	25210	// copy mutable arguments back from call to reporttok
25149	25211	fprintf(stderr, "%s", "\n");

		@@ -25173,14 +25235,14 @@
25173	25235	}
25174	25236	case 963LLU: // loop finished
25175	25237	{
25176		- label = 1631LLU; // start to repeat
	25238	+ label = 1636LLU; // start to repeat
25177	25239	break;
25178	25240	}
25179		- case 1631LLU: // repeat from here
	25241	+ case 1636LLU: // repeat from here
25180	25242	{
25181	25243	if(!stack[base + 3]/scope/)
25182	25244	{
25183		- label = 1632LLU; // break loop
	25245	+ label = 1637LLU; // break loop
25184	25246	break;
25185	25247	}
25186	25248

		@@ -25191,7 +25253,7 @@
25191	25253	struct listnode list = (struct listnode )stack[base + 3]/scope/;
25192	25254	if(!list)
25193	25255	{
25194		- label = 1633LLU; // jump to alternative
	25256	+ label = 1638LLU; // jump to alternative
25195	25257	break;
25196	25258	}
25197	25259

		@@ -25203,7 +25265,7 @@
25203	25265	}
25204	25266	// call dellet from procblock
25205	25267	stack[base + 19LLU] = base;
25206		- stack[base + 20LLU] = 1635LLU;
	25268	+ stack[base + 20LLU] = 1640LLU;
25207	25269	// arguments for call to dellet
25208	25270	stack[base + 21LLU] = stack[base + 18]/current/;
25209	25271	// set stack-base & callee-address

		@@ -25211,31 +25273,31 @@
25211	25273	label = 166LLU; // dellet
25212	25274	break;
25213	25275	}
25214		- case 1635LLU: // return from dellet to procblock
	25276	+ case 1640LLU: // return from dellet to procblock
25215	25277	{
25216	25278	// copy mutable arguments back from call to dellet
25217		- label = 1634LLU; // consequent complete
	25279	+ label = 1639LLU; // consequent complete
25218	25280	break;
25219	25281	}
25220		- case 1633LLU: // alternative
	25282	+ case 1638LLU: // alternative
25221	25283	{
25222	25284	fprintf(stderr, "%s", "internal error cleaning up lets in block\n");
25223	25285	exit(-1);
25224		- label = 1634LLU; // alternative complete
	25286	+ label = 1639LLU; // alternative complete
25225	25287	break;
25226	25288	}
25227		- case 1634LLU: // completed if-then-else
	25289	+ case 1639LLU: // completed if-then-else
25228	25290	{
25229		- label = 1631LLU; // repeat
	25291	+ label = 1636LLU; // repeat
25230	25292	break;
25231	25293	}
25232		- case 1632LLU: // loop finished
	25294	+ case 1637LLU: // loop finished
25233	25295	{
25234	25296	{ // if pop
25235	25297	struct listnode list = (struct listnode )stack[base + 2]/scopes/;
25236	25298	if(!list)
25237	25299	{
25238		- label = 1636LLU; // jump to alternative
	25300	+ label = 1641LLU; // jump to alternative
25239	25301	break;
25240	25302	}
25241	25303

		@@ -25245,17 +25307,17 @@
25245	25307	Free(1, sizeof(struct listnode), list);
25246	25308	stack[base + 2]/scopes/ = (uint64_t)next;
25247	25309	}
25248		- label = 1637LLU; // consequent complete
	25310	+ label = 1642LLU; // consequent complete
25249	25311	break;
25250	25312	}
25251		- case 1636LLU: // alternative
	25313	+ case 1641LLU: // alternative
25252	25314	{
25253	25315	fprintf(stderr, "%s", "internal error poping scope in block\n");
25254	25316	exit(-1);
25255		- label = 1637LLU; // alternative complete
	25317	+ label = 1642LLU; // alternative complete
25256	25318	break;
25257	25319	}
25258		- case 1637LLU: // completed if-then-else
	25320	+ case 1642LLU: // completed if-then-else
25259	25321	{
25260	25322	// return from procblock
25261	25323	label = stack[base - 1];

		@@ -25262,7 +25324,7 @@
25262	25324	base = stack[base - 2];
25263	25325	break;
25264	25326	}
25265		- case 1638LLU: // procfn
	25327	+ case 1643LLU: // procfn
25266	25328	{
25267	25329	//#define arg0 0
25268	25330	//#define arg1 1

		@@ -25299,7 +25361,7 @@
25299	25361	stack[base + 16]/fnargtypes/ = 0;
25300	25362	// call issimple from procfn
25301	25363	stack[base + 17LLU] = base;
25302		- stack[base + 18LLU] = 1639LLU;
	25364	+ stack[base + 18LLU] = 1644LLU;
25303	25365	// arguments for call to issimple
25304	25366	stack[base + 20LLU] = stack[base + 3]/variant/;
25305	25367	stack[base + 21LLU] = stack[base + 4]/content/;

		@@ -25309,7 +25371,7 @@
25309	25371	label = 18LLU; // issimple
25310	25372	break;
25311	25373	}
25312		- case 1639LLU: // return from issimple to procfn
	25374	+ case 1644LLU: // return from issimple to procfn
25313	25375	{
25314	25376	// copy mutable arguments back from call to issimple
25315	25377	// copy back results provided by call to issimple

		@@ -25316,7 +25378,7 @@
25316	25378	stack[base + 13] = stack[base + 19LLU];
25317	25379	if(!stack[base + 13]/isequal/)
25318	25380	{
25319		- label = 1640LLU; // jump to alternative
	25381	+ label = 1645LLU; // jump to alternative
25320	25382	break;
25321	25383	}
25322	25384

		@@ -25323,7 +25385,7 @@
25323	25385	// consequent
25324	25386	// call skipwscmnt from procfn
25325	25387	stack[base + 17LLU] = base;
25326		- stack[base + 18LLU] = 1642LLU;
	25388	+ stack[base + 18LLU] = 1647LLU;
25327	25389	// arguments for call to skipwscmnt
25328	25390	stack[base + 20LLU] = stack[base + 2]/lookahead/;
25329	25391	// set stack-base & callee-address

		@@ -25331,7 +25393,7 @@
25331	25393	label = 18446744073709551581LLU; // skipwscmnt
25332	25394	break;
25333	25395	}
25334		- case 1642LLU: // return from skipwscmnt to procfn
	25396	+ case 1647LLU: // return from skipwscmnt to procfn
25335	25397	{
25336	25398	// copy mutable arguments back from call to skipwscmnt
25337	25399	// copy back results provided by call to skipwscmnt

		@@ -25338,7 +25400,7 @@
25338	25400	stack[base + 2] = stack[base + 19LLU];
25339	25401	// call equ from procfn
25340	25402	stack[base + 17LLU] = base;
25341		- stack[base + 18LLU] = 1643LLU;
	25403	+ stack[base + 18LLU] = 1648LLU;
25342	25404	// arguments for call to equ
25343	25405	stack[base + 20LLU] = stack[base + 2]/lookahead/;
25344	25406	stack[base + 21LLU] = 41LLU;

		@@ -25347,7 +25409,7 @@
25347	25409	label = 18446744073709551600LLU; // equ
25348	25410	break;
25349	25411	}
25350		- case 1643LLU: // return from equ to procfn
	25412	+ case 1648LLU: // return from equ to procfn
25351	25413	{
25352	25414	// copy mutable arguments back from call to equ
25353	25415	// copy back results provided by call to equ

		@@ -25354,15 +25416,15 @@
25354	25416	stack[base + 13] = stack[base + 19LLU];
25355	25417	if(!stack[base + 13]/isequal/)
25356	25418	{
25357		- label = 1644LLU; // jump to alternative
	25419	+ label = 1649LLU; // jump to alternative
25358	25420	break;
25359	25421	}
25360	25422
25361	25423	// consequent
25362		- label = 1645LLU; // consequent complete
	25424	+ label = 1650LLU; // consequent complete
25363	25425	break;
25364	25426	}
25365		- case 1644LLU: // alternative
	25427	+ case 1649LLU: // alternative
25366	25428	{
25367	25429	//#define continue 17
25368	25430	stack[base + 17/continue/] = 0; // init

		@@ -25370,14 +25432,14 @@
25370	25432	//#define position 18
25371	25433	stack[base + 18/position/] = 0; // init
25372	25434	stack[base + 18]/position/ = 0;
25373		- label = 1646LLU; // start to repeat
	25435	+ label = 1651LLU; // start to repeat
25374	25436	break;
25375	25437	}
25376		- case 1646LLU: // repeat from here
	25438	+ case 1651LLU: // repeat from here
25377	25439	{
25378	25440	if(!stack[base + 17]/continue/)
25379	25441	{
25380		- label = 1647LLU; // break loop
	25442	+ label = 1652LLU; // break loop
25381	25443	break;
25382	25444	}
25383	25445

		@@ -25386,7 +25448,7 @@
25386	25448	stack[base + 19/restype/] = 0; // init
25387	25449	// call parsetoken from procfn
25388	25450	stack[base + 20LLU] = base;
25389		- stack[base + 21LLU] = 1648LLU;
	25451	+ stack[base + 21LLU] = 1653LLU;
25390	25452	// arguments for call to parsetoken
25391	25453	stack[base + 25LLU] = stack[base + 2]/lookahead/;
25392	25454	// set stack-base & callee-address

		@@ -25394,7 +25456,7 @@
25394	25456	label = 18446744073709551585LLU; // parsetoken
25395	25457	break;
25396	25458	}
25397		- case 1648LLU: // return from parsetoken to procfn
	25459	+ case 1653LLU: // return from parsetoken to procfn
25398	25460	{
25399	25461	// copy mutable arguments back from call to parsetoken
25400	25462	// copy back results provided by call to parsetoken

		@@ -25406,7 +25468,7 @@
25406	25468	stack[base + 20]/mutable/ = 0;
25407	25469	// call equ from procfn
25408	25470	stack[base + 21LLU] = base;
25409		- stack[base + 22LLU] = 1649LLU;
	25471	+ stack[base + 22LLU] = 1654LLU;
25410	25472	// arguments for call to equ
25411	25473	stack[base + 24LLU] = stack[base + 3]/variant/;
25412	25474	stack[base + 25LLU] = 4LLU;

		@@ -25415,7 +25477,7 @@
25415	25477	label = 18446744073709551600LLU; // equ
25416	25478	break;
25417	25479	}
25418		- case 1649LLU: // return from equ to procfn
	25480	+ case 1654LLU: // return from equ to procfn
25419	25481	{
25420	25482	// copy mutable arguments back from call to equ
25421	25483	// copy back results provided by call to equ

		@@ -25422,7 +25484,7 @@
25422	25484	stack[base + 13] = stack[base + 23LLU];
25423	25485	if(!stack[base + 13]/isequal/)
25424	25486	{
25425		- label = 1650LLU; // jump to alternative
	25487	+ label = 1655LLU; // jump to alternative
25426	25488	break;
25427	25489	}
25428	25490

		@@ -25429,7 +25491,7 @@
25429	25491	// consequent
25430	25492	// call equ from procfn
25431	25493	stack[base + 21LLU] = base;
25432		- stack[base + 22LLU] = 1652LLU;
	25494	+ stack[base + 22LLU] = 1657LLU;
25433	25495	// arguments for call to equ
25434	25496	stack[base + 24LLU] = stack[base + 4]/content/;
25435	25497	stack[base + 25LLU] = 734293447447412736LLU;

		@@ -25438,7 +25500,7 @@
25438	25500	label = 18446744073709551600LLU; // equ
25439	25501	break;
25440	25502	}
25441		- case 1652LLU: // return from equ to procfn
	25503	+ case 1657LLU: // return from equ to procfn
25442	25504	{
25443	25505	// copy mutable arguments back from call to equ
25444	25506	// copy back results provided by call to equ

		@@ -25445,7 +25507,7 @@
25445	25507	stack[base + 13] = stack[base + 23LLU];
25446	25508	if(!stack[base + 13]/isequal/)
25447	25509	{
25448		- label = 1653LLU; // jump to alternative
	25510	+ label = 1658LLU; // jump to alternative
25449	25511	break;
25450	25512	}
25451	25513

		@@ -25453,7 +25515,7 @@
25453	25515	stack[base + 20]/mutable/ = 1;
25454	25516	// call parsetoken from procfn
25455	25517	stack[base + 21LLU] = base;
25456		- stack[base + 22LLU] = 1655LLU;
	25518	+ stack[base + 22LLU] = 1660LLU;
25457	25519	// arguments for call to parsetoken
25458	25520	stack[base + 26LLU] = stack[base + 2]/lookahead/;
25459	25521	// set stack-base & callee-address

		@@ -25461,7 +25523,7 @@
25461	25523	label = 18446744073709551585LLU; // parsetoken
25462	25524	break;
25463	25525	}
25464		- case 1655LLU: // return from parsetoken to procfn
	25526	+ case 1660LLU: // return from parsetoken to procfn
25465	25527	{
25466	25528	// copy mutable arguments back from call to parsetoken
25467	25529	// copy back results provided by call to parsetoken

		@@ -25468,25 +25530,25 @@
25468	25530	stack[base + 3] = stack[base + 23LLU];
25469	25531	stack[base + 4] = stack[base + 24LLU];
25470	25532	stack[base + 2] = stack[base + 25LLU];
25471		- label = 1654LLU; // consequent complete
	25533	+ label = 1659LLU; // consequent complete
25472	25534	break;
25473	25535	}
25474		- case 1653LLU: // alternative
	25536	+ case 1658LLU: // alternative
25475	25537	{
25476		- label = 1654LLU; // alternative complete
	25538	+ label = 1659LLU; // alternative complete
25477	25539	break;
25478	25540	}
25479		- case 1654LLU: // completed if-then-else
	25541	+ case 1659LLU: // completed if-then-else
25480	25542	{
25481		- label = 1651LLU; // consequent complete
	25543	+ label = 1656LLU; // consequent complete
25482	25544	break;
25483	25545	}
25484		- case 1650LLU: // alternative
	25546	+ case 1655LLU: // alternative
25485	25547	{
25486		- label = 1651LLU; // alternative complete
	25548	+ label = 1656LLU; // alternative complete
25487	25549	break;
25488	25550	}
25489		- case 1651LLU: // completed if-then-else
	25551	+ case 1656LLU: // completed if-then-else
25490	25552	{
25491	25553	uint64_t newstack = (uint64_t )Calloc(27LLU + 1, sizeof(uint64_t));
25492	25554	newstack[27LLU] = 9876543210LLU; // overflow-marker

		@@ -25493,7 +25555,7 @@
25493	25555	// call PARSETYPE from procfn
25494	25556	newstack[0] = (uint64_t)stack; // backup stack location
25495	25557	newstack[1] = base;
25496		- newstack[2] = 1656LLU;
	25558	+ newstack[2] = 1661LLU;
25497	25559	// arguments for call to PARSETYPE
25498	25560	newstack[4LLU] = stack[base + 3]/variant/;
25499	25561	newstack[5LLU] = stack[base + 4]/content/;

		@@ -25504,7 +25566,7 @@
25504	25566	label = 265LLU; // PARSETYPE
25505	25567	break;
25506	25568	}
25507		- case 1656LLU: // return from PARSETYPE to procfn
	25569	+ case 1661LLU: // return from PARSETYPE to procfn
25508	25570	{
25509	25571	uint64_t oldstack = (uint64_t )stack[0];
25510	25572	// copy mutable arguments back from call to PARSETYPE

		@@ -25524,7 +25586,7 @@
25524	25586	stack[base + 21/id/] = 0; // init
25525	25587	// call skipwscmnt from procfn
25526	25588	stack[base + 22LLU] = base;
25527		- stack[base + 23LLU] = 1657LLU;
	25589	+ stack[base + 23LLU] = 1662LLU;
25528	25590	// arguments for call to skipwscmnt
25529	25591	stack[base + 25LLU] = stack[base + 2]/lookahead/;
25530	25592	// set stack-base & callee-address

		@@ -25532,7 +25594,7 @@
25532	25594	label = 18446744073709551581LLU; // skipwscmnt
25533	25595	break;
25534	25596	}
25535		- case 1657LLU: // return from skipwscmnt to procfn
	25597	+ case 1662LLU: // return from skipwscmnt to procfn
25536	25598	{
25537	25599	// copy mutable arguments back from call to skipwscmnt
25538	25600	// copy back results provided by call to skipwscmnt

		@@ -25539,7 +25601,7 @@
25539	25601	stack[base + 2] = stack[base + 24LLU];
25540	25602	// call isalpha from procfn
25541	25603	stack[base + 22LLU] = base;
25542		- stack[base + 23LLU] = 1658LLU;
	25604	+ stack[base + 23LLU] = 1663LLU;
25543	25605	// arguments for call to isalpha
25544	25606	stack[base + 25LLU] = stack[base + 2]/lookahead/;
25545	25607	// set stack-base & callee-address

		@@ -25547,7 +25609,7 @@
25547	25609	label = 2LLU; // isalpha
25548	25610	break;
25549	25611	}
25550		- case 1658LLU: // return from isalpha to procfn
	25612	+ case 1663LLU: // return from isalpha to procfn
25551	25613	{
25552	25614	// copy mutable arguments back from call to isalpha
25553	25615	// copy back results provided by call to isalpha

		@@ -25554,7 +25616,7 @@
25554	25616	stack[base + 13] = stack[base + 24LLU];
25555	25617	if(!stack[base + 13]/isequal/)
25556	25618	{
25557		- label = 1659LLU; // jump to alternative
	25619	+ label = 1664LLU; // jump to alternative
25558	25620	break;
25559	25621	}
25560	25622

		@@ -25561,7 +25623,7 @@
25561	25623	// consequent
25562	25624	// call parseid from procfn
25563	25625	stack[base + 22LLU] = base;
25564		- stack[base + 23LLU] = 1661LLU;
	25626	+ stack[base + 23LLU] = 1666LLU;
25565	25627	// arguments for call to parseid
25566	25628	stack[base + 26LLU] = stack[base + 2]/lookahead/;
25567	25629	// set stack-base & callee-address

		@@ -25569,20 +25631,20 @@
25569	25631	label = 18446744073709551586LLU; // parseid
25570	25632	break;
25571	25633	}
25572		- case 1661LLU: // return from parseid to procfn
	25634	+ case 1666LLU: // return from parseid to procfn
25573	25635	{
25574	25636	// copy mutable arguments back from call to parseid
25575	25637	// copy back results provided by call to parseid
25576	25638	stack[base + 21] = stack[base + 24LLU];
25577	25639	stack[base + 2] = stack[base + 25LLU];
25578		- label = 1660LLU; // consequent complete
	25640	+ label = 1665LLU; // consequent complete
25579	25641	break;
25580	25642	}
25581		- case 1659LLU: // alternative
	25643	+ case 1664LLU: // alternative
25582	25644	{
25583	25645	// call idwithnr from procfn
25584	25646	stack[base + 22LLU] = base;
25585		- stack[base + 23LLU] = 1662LLU;
	25647	+ stack[base + 23LLU] = 1667LLU;
25586	25648	// arguments for call to idwithnr
25587	25649	stack[base + 25LLU] = 819857442320941056LLU;
25588	25650	stack[base + 26LLU] = stack[base + 18]/position/;

		@@ -25591,21 +25653,21 @@
25591	25653	label = 18446744073709551580LLU; // idwithnr
25592	25654	break;
25593	25655	}
25594		- case 1662LLU: // return from idwithnr to procfn
	25656	+ case 1667LLU: // return from idwithnr to procfn
25595	25657	{
25596	25658	// copy mutable arguments back from call to idwithnr
25597	25659	// copy back results provided by call to idwithnr
25598	25660	stack[base + 21] = stack[base + 24LLU];
25599		- label = 1660LLU; // alternative complete
	25661	+ label = 1665LLU; // alternative complete
25600	25662	break;
25601	25663	}
25602		- case 1660LLU: // completed if-then-else
	25664	+ case 1665LLU: // completed if-then-else
25603	25665	{
25604	25666	//#define exists 22
25605	25667	stack[base + 22/exists/] = 0; // init
25606	25668	// call lookresult from procfn
25607	25669	stack[base + 23LLU] = base;
25608		- stack[base + 24LLU] = 1663LLU;
	25670	+ stack[base + 24LLU] = 1668LLU;
25609	25671	// arguments for call to lookresult
25610	25672	stack[base + 26LLU] = stack[base + 15]/fnrestypes/;
25611	25673	stack[base + 27LLU] = stack[base + 21]/id/;

		@@ -25614,7 +25676,7 @@
25614	25676	label = 130LLU; // lookresult
25615	25677	break;
25616	25678	}
25617		- case 1663LLU: // return from lookresult to procfn
	25679	+ case 1668LLU: // return from lookresult to procfn
25618	25680	{
25619	25681	// copy mutable arguments back from call to lookresult
25620	25682	// copy back results provided by call to lookresult

		@@ -25621,7 +25683,7 @@
25621	25683	stack[base + 22] = stack[base + 25LLU];
25622	25684	if(!stack[base + 22]/exists/)
25623	25685	{
25624		- label = 1664LLU; // jump to alternative
	25686	+ label = 1669LLU; // jump to alternative
25625	25687	break;
25626	25688	}
25627	25689

		@@ -25629,7 +25691,7 @@
25629	25691	fprintf(stderr, "%s", "duplicate result ");
25630	25692	// call reportid from procfn
25631	25693	stack[base + 23LLU] = base;
25632		- stack[base + 24LLU] = 1666LLU;
	25694	+ stack[base + 24LLU] = 1671LLU;
25633	25695	// arguments for call to reportid
25634	25696	stack[base + 25LLU] = stack[base + 21]/id/;
25635	25697	// set stack-base & callee-address

		@@ -25637,26 +25699,26 @@
25637	25699	label = 18446744073709551587LLU; // reportid
25638	25700	break;
25639	25701	}
25640		- case 1666LLU: // return from reportid to procfn
	25702	+ case 1671LLU: // return from reportid to procfn
25641	25703	{
25642	25704	// copy mutable arguments back from call to reportid
25643	25705	fprintf(stderr, "%s", "\n");
25644	25706	exit(-1);
25645		- label = 1665LLU; // consequent complete
	25707	+ label = 1670LLU; // consequent complete
25646	25708	break;
25647	25709	}
25648		- case 1664LLU: // alternative
	25710	+ case 1669LLU: // alternative
25649	25711	{
25650		- label = 1665LLU; // alternative complete
	25712	+ label = 1670LLU; // alternative complete
25651	25713	break;
25652	25714	}
25653		- case 1665LLU: // completed if-then-else
	25715	+ case 1670LLU: // completed if-then-else
25654	25716	{
25655	25717	//#define restypeid 22
25656	25718	stack[base + 22/restypeid/] = 0; // init
25657	25719	// call mktypeid from procfn
25658	25720	stack[base + 23LLU] = base;
25659		- stack[base + 24LLU] = 1667LLU;
	25721	+ stack[base + 24LLU] = 1672LLU;
25660	25722	// arguments for call to mktypeid
25661	25723	stack[base + 26LLU] = stack[base + 19]/restype/;
25662	25724	stack[base + 27LLU] = stack[base + 21]/id/;

		@@ -25665,7 +25727,7 @@
25665	25727	label = 105LLU; // mktypeid
25666	25728	break;
25667	25729	}
25668		- case 1667LLU: // return from mktypeid to procfn
	25730	+ case 1672LLU: // return from mktypeid to procfn
25669	25731	{
25670	25732	// copy mutable arguments back from call to mktypeid
25671	25733	// copy back results provided by call to mktypeid

		@@ -25674,7 +25736,7 @@
25674	25736	stack[base + 23/result/] = 0; // init
25675	25737	// call mkresult from procfn
25676	25738	stack[base + 24LLU] = base;
25677		- stack[base + 25LLU] = 1668LLU;
	25739	+ stack[base + 25LLU] = 1673LLU;
25678	25740	// arguments for call to mkresult
25679	25741	stack[base + 27LLU] = stack[base + 22]/restypeid/;
25680	25742	stack[base + 28LLU] = 1LLU;

		@@ -25683,7 +25745,7 @@
25683	25745	label = 117LLU; // mkresult
25684	25746	break;
25685	25747	}
25686		- case 1668LLU: // return from mkresult to procfn
	25748	+ case 1673LLU: // return from mkresult to procfn
25687	25749	{
25688	25750	// copy mutable arguments back from call to mkresult
25689	25751	// copy back results provided by call to mkresult

		@@ -25696,7 +25758,7 @@
25696	25758	}
25697	25759	// call skipwscmnt from procfn
25698	25760	stack[base + 24LLU] = base;
25699		- stack[base + 25LLU] = 1669LLU;
	25761	+ stack[base + 25LLU] = 1674LLU;
25700	25762	// arguments for call to skipwscmnt
25701	25763	stack[base + 27LLU] = stack[base + 2]/lookahead/;
25702	25764	// set stack-base & callee-address

		@@ -25704,7 +25766,7 @@
25704	25766	label = 18446744073709551581LLU; // skipwscmnt
25705	25767	break;
25706	25768	}
25707		- case 1669LLU: // return from skipwscmnt to procfn
	25769	+ case 1674LLU: // return from skipwscmnt to procfn
25708	25770	{
25709	25771	// copy mutable arguments back from call to skipwscmnt
25710	25772	// copy back results provided by call to skipwscmnt

		@@ -25711,7 +25773,7 @@
25711	25773	stack[base + 2] = stack[base + 26LLU];
25712	25774	// call neq from procfn
25713	25775	stack[base + 24LLU] = base;
25714		- stack[base + 25LLU] = 1670LLU;
	25776	+ stack[base + 25LLU] = 1675LLU;
25715	25777	// arguments for call to neq
25716	25778	stack[base + 27LLU] = stack[base + 2]/lookahead/;
25717	25779	stack[base + 28LLU] = 41LLU;

		@@ -25720,7 +25782,7 @@
25720	25782	label = 18446744073709551599LLU; // neq
25721	25783	break;
25722	25784	}
25723		- case 1670LLU: // return from neq to procfn
	25785	+ case 1675LLU: // return from neq to procfn
25724	25786	{
25725	25787	// copy mutable arguments back from call to neq
25726	25788	// copy back results provided by call to neq

		@@ -25727,7 +25789,7 @@
25727	25789	stack[base + 17] = stack[base + 26LLU];
25728	25790	if(!stack[base + 17]/continue/)
25729	25791	{
25730		- label = 1671LLU; // jump to alternative
	25792	+ label = 1676LLU; // jump to alternative
25731	25793	break;
25732	25794	}
25733	25795

		@@ -25734,7 +25796,7 @@
25734	25796	// consequent
25735	25797	// call matchsym from procfn
25736	25798	stack[base + 24LLU] = base;
25737		- stack[base + 25LLU] = 1673LLU;
	25799	+ stack[base + 25LLU] = 1678LLU;
25738	25800	// arguments for call to matchsym
25739	25801	stack[base + 26LLU] = 44LLU;
25740	25802	stack[base + 27LLU] = stack[base + 2]/lookahead/;

		@@ -25743,23 +25805,23 @@
25743	25805	label = 27LLU; // matchsym
25744	25806	break;
25745	25807	}
25746		- case 1673LLU: // return from matchsym to procfn
	25808	+ case 1678LLU: // return from matchsym to procfn
25747	25809	{
25748	25810	// copy mutable arguments back from call to matchsym
25749	25811	stack[base + 2]/lookahead/ = stack[base + 27LLU];
25750		- label = 1672LLU; // consequent complete
	25812	+ label = 1677LLU; // consequent complete
25751	25813	break;
25752	25814	}
25753		- case 1671LLU: // alternative
	25815	+ case 1676LLU: // alternative
25754	25816	{
25755		- label = 1672LLU; // alternative complete
	25817	+ label = 1677LLU; // alternative complete
25756	25818	break;
25757	25819	}
25758		- case 1672LLU: // completed if-then-else
	25820	+ case 1677LLU: // completed if-then-else
25759	25821	{
25760	25822	// call add from procfn
25761	25823	stack[base + 24LLU] = base;
25762		- stack[base + 25LLU] = 1674LLU;
	25824	+ stack[base + 25LLU] = 1679LLU;
25763	25825	// arguments for call to add
25764	25826	stack[base + 27LLU] = 1LLU;
25765	25827	stack[base + 28LLU] = stack[base + 18]/position/;

		@@ -25768,24 +25830,24 @@
25768	25830	label = 18446744073709551605LLU; // add
25769	25831	break;
25770	25832	}
25771		- case 1674LLU: // return from add to procfn
	25833	+ case 1679LLU: // return from add to procfn
25772	25834	{
25773	25835	// copy mutable arguments back from call to add
25774	25836	// copy back results provided by call to add
25775	25837	stack[base + 18] = stack[base + 26LLU];
25776		- label = 1646LLU; // repeat
	25838	+ label = 1651LLU; // repeat
25777	25839	break;
25778	25840	}
25779		- case 1647LLU: // loop finished
	25841	+ case 1652LLU: // loop finished
25780	25842	{
25781		- label = 1645LLU; // alternative complete
	25843	+ label = 1650LLU; // alternative complete
25782	25844	break;
25783	25845	}
25784		- case 1645LLU: // completed if-then-else
	25846	+ case 1650LLU: // completed if-then-else
25785	25847	{
25786	25848	// call matchsym from procfn
25787	25849	stack[base + 17LLU] = base;
25788		- stack[base + 18LLU] = 1675LLU;
	25850	+ stack[base + 18LLU] = 1680LLU;
25789	25851	// arguments for call to matchsym
25790	25852	stack[base + 19LLU] = 41LLU;
25791	25853	stack[base + 20LLU] = stack[base + 2]/lookahead/;

		@@ -25794,7 +25856,7 @@
25794	25856	label = 27LLU; // matchsym
25795	25857	break;
25796	25858	}
25797		- case 1675LLU: // return from matchsym to procfn
	25859	+ case 1680LLU: // return from matchsym to procfn
25798	25860	{
25799	25861	// copy mutable arguments back from call to matchsym
25800	25862	stack[base + 2]/lookahead/ = stack[base + 20LLU];

		@@ -25801,7 +25863,7 @@
25801	25863	list_reverse(((struct listnode *)(&stack[base + 15]/fnrestypes*/)));
25802	25864	// call parsetoken from procfn
25803	25865	stack[base + 17LLU] = base;
25804		- stack[base + 18LLU] = 1676LLU;
	25866	+ stack[base + 18LLU] = 1681LLU;
25805	25867	// arguments for call to parsetoken
25806	25868	stack[base + 22LLU] = stack[base + 2]/lookahead/;
25807	25869	// set stack-base & callee-address

		@@ -25809,7 +25871,7 @@
25809	25871	label = 18446744073709551585LLU; // parsetoken
25810	25872	break;
25811	25873	}
25812		- case 1676LLU: // return from parsetoken to procfn
	25874	+ case 1681LLU: // return from parsetoken to procfn
25813	25875	{
25814	25876	// copy mutable arguments back from call to parsetoken
25815	25877	// copy back results provided by call to parsetoken

		@@ -25818,7 +25880,7 @@
25818	25880	stack[base + 2] = stack[base + 21LLU];
25819	25881	// call equ from procfn
25820	25882	stack[base + 17LLU] = base;
25821		- stack[base + 18LLU] = 1677LLU;
	25883	+ stack[base + 18LLU] = 1682LLU;
25822	25884	// arguments for call to equ
25823	25885	stack[base + 20LLU] = stack[base + 3]/variant/;
25824	25886	stack[base + 21LLU] = 4LLU;

		@@ -25827,7 +25889,7 @@
25827	25889	label = 18446744073709551600LLU; // equ
25828	25890	break;
25829	25891	}
25830		- case 1677LLU: // return from equ to procfn
	25892	+ case 1682LLU: // return from equ to procfn
25831	25893	{
25832	25894	// copy mutable arguments back from call to equ
25833	25895	// copy back results provided by call to equ

		@@ -25834,7 +25896,7 @@
25834	25896	stack[base + 13] = stack[base + 19LLU];
25835	25897	if(!stack[base + 13]/isequal/)
25836	25898	{
25837		- label = 1678LLU; // jump to alternative
	25899	+ label = 1683LLU; // jump to alternative
25838	25900	break;
25839	25901	}
25840	25902

		@@ -25844,7 +25906,7 @@
25844	25906	stack[base + 17/found/] = 0; // init
25845	25907	// call existsfn from procfn
25846	25908	stack[base + 18LLU] = base;
25847		- stack[base + 19LLU] = 1680LLU;
	25909	+ stack[base + 19LLU] = 1685LLU;
25848	25910	// arguments for call to existsfn
25849	25911	stack[base + 21LLU] = stack[base + 0]/fndefs/;
25850	25912	stack[base + 22LLU] = stack[base + 8]/fnid/;

		@@ -25853,7 +25915,7 @@
25853	25915	label = 397LLU; // existsfn
25854	25916	break;
25855	25917	}
25856		- case 1680LLU: // return from existsfn to procfn
	25918	+ case 1685LLU: // return from existsfn to procfn
25857	25919	{
25858	25920	// copy mutable arguments back from call to existsfn
25859	25921	// copy back results provided by call to existsfn

		@@ -25860,7 +25922,7 @@
25860	25922	stack[base + 17] = stack[base + 20LLU];
25861	25923	if(!stack[base + 17]/found/)
25862	25924	{
25863		- label = 1681LLU; // jump to alternative
	25925	+ label = 1686LLU; // jump to alternative
25864	25926	break;
25865	25927	}
25866	25928

		@@ -25868,7 +25930,7 @@
25868	25930	fprintf(stderr, "%s", "re-definition of function ");
25869	25931	// call reportid from procfn
25870	25932	stack[base + 18LLU] = base;
25871		- stack[base + 19LLU] = 1683LLU;
	25933	+ stack[base + 19LLU] = 1688LLU;
25872	25934	// arguments for call to reportid
25873	25935	stack[base + 20LLU] = stack[base + 8]/fnid/;
25874	25936	// set stack-base & callee-address

		@@ -25876,30 +25938,30 @@
25876	25938	label = 18446744073709551587LLU; // reportid
25877	25939	break;
25878	25940	}
25879		- case 1683LLU: // return from reportid to procfn
	25941	+ case 1688LLU: // return from reportid to procfn
25880	25942	{
25881	25943	// copy mutable arguments back from call to reportid
25882	25944	fprintf(stderr, "%s", "\n");
25883	25945	exit(-1);
25884		- label = 1682LLU; // consequent complete
	25946	+ label = 1687LLU; // consequent complete
25885	25947	break;
25886	25948	}
25887		- case 1681LLU: // alternative
	25949	+ case 1686LLU: // alternative
25888	25950	{
25889		- label = 1682LLU; // alternative complete
	25951	+ label = 1687LLU; // alternative complete
25890	25952	break;
25891	25953	}
25892		- case 1682LLU: // completed if-then-else
	25954	+ case 1687LLU: // completed if-then-else
25893	25955	{
25894		- label = 1679LLU; // consequent complete
	25956	+ label = 1684LLU; // consequent complete
25895	25957	break;
25896	25958	}
25897		- case 1678LLU: // alternative
	25959	+ case 1683LLU: // alternative
25898	25960	{
25899	25961	fprintf(stderr, "%s", "parsing function expected identifier but found token ");
25900	25962	// call reporttok from procfn
25901	25963	stack[base + 17LLU] = base;
25902		- stack[base + 18LLU] = 1684LLU;
	25964	+ stack[base + 18LLU] = 1689LLU;
25903	25965	// arguments for call to reporttok
25904	25966	stack[base + 19LLU] = stack[base + 3]/variant/;
25905	25967	stack[base + 20LLU] = stack[base + 4]/content/;

		@@ -25908,19 +25970,19 @@
25908	25970	label = 18446744073709551583LLU; // reporttok
25909	25971	break;
25910	25972	}
25911		- case 1684LLU: // return from reporttok to procfn
	25973	+ case 1689LLU: // return from reporttok to procfn
25912	25974	{
25913	25975	// copy mutable arguments back from call to reporttok
25914	25976	fprintf(stderr, "%s", "\n");
25915	25977	exit(-1);
25916		- label = 1679LLU; // alternative complete
	25978	+ label = 1684LLU; // alternative complete
25917	25979	break;
25918	25980	}
25919		- case 1679LLU: // completed if-then-else
	25981	+ case 1684LLU: // completed if-then-else
25920	25982	{
25921	25983	// call matchsym from procfn
25922	25984	stack[base + 17LLU] = base;
25923		- stack[base + 18LLU] = 1685LLU;
	25985	+ stack[base + 18LLU] = 1690LLU;
25924	25986	// arguments for call to matchsym
25925	25987	stack[base + 19LLU] = 40LLU;
25926	25988	stack[base + 20LLU] = stack[base + 2]/lookahead/;

		@@ -25929,13 +25991,13 @@
25929	25991	label = 27LLU; // matchsym
25930	25992	break;
25931	25993	}
25932		- case 1685LLU: // return from matchsym to procfn
	25994	+ case 1690LLU: // return from matchsym to procfn
25933	25995	{
25934	25996	// copy mutable arguments back from call to matchsym
25935	25997	stack[base + 2]/lookahead/ = stack[base + 20LLU];
25936	25998	// call skipwscmnt from procfn
25937	25999	stack[base + 17LLU] = base;
25938		- stack[base + 18LLU] = 1686LLU;
	26000	+ stack[base + 18LLU] = 1691LLU;
25939	26001	// arguments for call to skipwscmnt
25940	26002	stack[base + 20LLU] = stack[base + 2]/lookahead/;
25941	26003	// set stack-base & callee-address

		@@ -25943,7 +26005,7 @@
25943	26005	label = 18446744073709551581LLU; // skipwscmnt
25944	26006	break;
25945	26007	}
25946		- case 1686LLU: // return from skipwscmnt to procfn
	26008	+ case 1691LLU: // return from skipwscmnt to procfn
25947	26009	{
25948	26010	// copy mutable arguments back from call to skipwscmnt
25949	26011	// copy back results provided by call to skipwscmnt

		@@ -25950,7 +26012,7 @@
25950	26012	stack[base + 2] = stack[base + 19LLU];
25951	26013	// call equ from procfn
25952	26014	stack[base + 17LLU] = base;
25953		- stack[base + 18LLU] = 1687LLU;
	26015	+ stack[base + 18LLU] = 1692LLU;
25954	26016	// arguments for call to equ
25955	26017	stack[base + 20LLU] = stack[base + 2]/lookahead/;
25956	26018	stack[base + 21LLU] = 41LLU;

		@@ -25959,7 +26021,7 @@
25959	26021	label = 18446744073709551600LLU; // equ
25960	26022	break;
25961	26023	}
25962		- case 1687LLU: // return from equ to procfn
	26024	+ case 1692LLU: // return from equ to procfn
25963	26025	{
25964	26026	// copy mutable arguments back from call to equ
25965	26027	// copy back results provided by call to equ

		@@ -25966,15 +26028,15 @@
25966	26028	stack[base + 13] = stack[base + 19LLU];
25967	26029	if(!stack[base + 13]/isequal/)
25968	26030	{
25969		- label = 1688LLU; // jump to alternative
	26031	+ label = 1693LLU; // jump to alternative
25970	26032	break;
25971	26033	}
25972	26034
25973	26035	// consequent
25974		- label = 1689LLU; // consequent complete
	26036	+ label = 1694LLU; // consequent complete
25975	26037	break;
25976	26038	}
25977		- case 1688LLU: // alternative
	26039	+ case 1693LLU: // alternative
25978	26040	{
25979	26041	//#define continue 17
25980	26042	stack[base + 17/continue/] = 0; // init

		@@ -25982,14 +26044,14 @@
25982	26044	//#define position 18
25983	26045	stack[base + 18/position/] = 0; // init
25984	26046	stack[base + 18]/position/ = 0;
25985		- label = 1690LLU; // start to repeat
	26047	+ label = 1695LLU; // start to repeat
25986	26048	break;
25987	26049	}
25988		- case 1690LLU: // repeat from here
	26050	+ case 1695LLU: // repeat from here
25989	26051	{
25990	26052	if(!stack[base + 17]/continue/)
25991	26053	{
25992		- label = 1691LLU; // break loop
	26054	+ label = 1696LLU; // break loop
25993	26055	break;
25994	26056	}
25995	26057

		@@ -25998,7 +26060,7 @@
25998	26060	stack[base + 19/argtype/] = 0; // init
25999	26061	// call parsetoken from procfn
26000	26062	stack[base + 20LLU] = base;
26001		- stack[base + 21LLU] = 1692LLU;
	26063	+ stack[base + 21LLU] = 1697LLU;
26002	26064	// arguments for call to parsetoken
26003	26065	stack[base + 25LLU] = stack[base + 2]/lookahead/;
26004	26066	// set stack-base & callee-address

		@@ -26006,7 +26068,7 @@
26006	26068	label = 18446744073709551585LLU; // parsetoken
26007	26069	break;
26008	26070	}
26009		- case 1692LLU: // return from parsetoken to procfn
	26071	+ case 1697LLU: // return from parsetoken to procfn
26010	26072	{
26011	26073	// copy mutable arguments back from call to parsetoken
26012	26074	// copy back results provided by call to parsetoken

		@@ -26018,7 +26080,7 @@
26018	26080	stack[base + 20]/mutable/ = 0;
26019	26081	// call equ from procfn
26020	26082	stack[base + 21LLU] = base;
26021		- stack[base + 22LLU] = 1693LLU;
	26083	+ stack[base + 22LLU] = 1698LLU;
26022	26084	// arguments for call to equ
26023	26085	stack[base + 24LLU] = stack[base + 3]/variant/;
26024	26086	stack[base + 25LLU] = 4LLU;

		@@ -26027,7 +26089,7 @@
26027	26089	label = 18446744073709551600LLU; // equ
26028	26090	break;
26029	26091	}
26030		- case 1693LLU: // return from equ to procfn
	26092	+ case 1698LLU: // return from equ to procfn
26031	26093	{
26032	26094	// copy mutable arguments back from call to equ
26033	26095	// copy back results provided by call to equ

		@@ -26034,7 +26096,7 @@
26034	26096	stack[base + 13] = stack[base + 23LLU];
26035	26097	if(!stack[base + 13]/isequal/)
26036	26098	{
26037		- label = 1694LLU; // jump to alternative
	26099	+ label = 1699LLU; // jump to alternative
26038	26100	break;
26039	26101	}
26040	26102

		@@ -26041,7 +26103,7 @@
26041	26103	// consequent
26042	26104	// call equ from procfn
26043	26105	stack[base + 21LLU] = base;
26044		- stack[base + 22LLU] = 1696LLU;
	26106	+ stack[base + 22LLU] = 1701LLU;
26045	26107	// arguments for call to equ
26046	26108	stack[base + 24LLU] = stack[base + 4]/content/;
26047	26109	stack[base + 25LLU] = 734293447447412736LLU;

		@@ -26050,7 +26112,7 @@
26050	26112	label = 18446744073709551600LLU; // equ
26051	26113	break;
26052	26114	}
26053		- case 1696LLU: // return from equ to procfn
	26115	+ case 1701LLU: // return from equ to procfn
26054	26116	{
26055	26117	// copy mutable arguments back from call to equ
26056	26118	// copy back results provided by call to equ

		@@ -26057,7 +26119,7 @@
26057	26119	stack[base + 13] = stack[base + 23LLU];
26058	26120	if(!stack[base + 13]/isequal/)
26059	26121	{
26060		- label = 1697LLU; // jump to alternative
	26122	+ label = 1702LLU; // jump to alternative
26061	26123	break;
26062	26124	}
26063	26125

		@@ -26065,7 +26127,7 @@
26065	26127	stack[base + 20]/mutable/ = 1;
26066	26128	// call parsetoken from procfn
26067	26129	stack[base + 21LLU] = base;
26068		- stack[base + 22LLU] = 1699LLU;
	26130	+ stack[base + 22LLU] = 1704LLU;
26069	26131	// arguments for call to parsetoken
26070	26132	stack[base + 26LLU] = stack[base + 2]/lookahead/;
26071	26133	// set stack-base & callee-address

		@@ -26073,7 +26135,7 @@
26073	26135	label = 18446744073709551585LLU; // parsetoken
26074	26136	break;
26075	26137	}
26076		- case 1699LLU: // return from parsetoken to procfn
	26138	+ case 1704LLU: // return from parsetoken to procfn
26077	26139	{
26078	26140	// copy mutable arguments back from call to parsetoken
26079	26141	// copy back results provided by call to parsetoken

		@@ -26080,25 +26142,25 @@
26080	26142	stack[base + 3] = stack[base + 23LLU];
26081	26143	stack[base + 4] = stack[base + 24LLU];
26082	26144	stack[base + 2] = stack[base + 25LLU];
26083		- label = 1698LLU; // consequent complete
	26145	+ label = 1703LLU; // consequent complete
26084	26146	break;
26085	26147	}
26086		- case 1697LLU: // alternative
	26148	+ case 1702LLU: // alternative
26087	26149	{
26088		- label = 1698LLU; // alternative complete
	26150	+ label = 1703LLU; // alternative complete
26089	26151	break;
26090	26152	}
26091		- case 1698LLU: // completed if-then-else
	26153	+ case 1703LLU: // completed if-then-else
26092	26154	{
26093		- label = 1695LLU; // consequent complete
	26155	+ label = 1700LLU; // consequent complete
26094	26156	break;
26095	26157	}
26096		- case 1694LLU: // alternative
	26158	+ case 1699LLU: // alternative
26097	26159	{
26098		- label = 1695LLU; // alternative complete
	26160	+ label = 1700LLU; // alternative complete
26099	26161	break;
26100	26162	}
26101		- case 1695LLU: // completed if-then-else
	26163	+ case 1700LLU: // completed if-then-else
26102	26164	{
26103	26165	uint64_t newstack = (uint64_t )Calloc(27LLU + 1, sizeof(uint64_t));
26104	26166	newstack[27LLU] = 9876543210LLU; // overflow-marker

		@@ -26105,7 +26167,7 @@
26105	26167	// call PARSETYPE from procfn
26106	26168	newstack[0] = (uint64_t)stack; // backup stack location
26107	26169	newstack[1] = base;
26108		- newstack[2] = 1700LLU;
	26170	+ newstack[2] = 1705LLU;
26109	26171	// arguments for call to PARSETYPE
26110	26172	newstack[4LLU] = stack[base + 3]/variant/;
26111	26173	newstack[5LLU] = stack[base + 4]/content/;

		@@ -26116,7 +26178,7 @@
26116	26178	label = 265LLU; // PARSETYPE
26117	26179	break;
26118	26180	}
26119		- case 1700LLU: // return from PARSETYPE to procfn
	26181	+ case 1705LLU: // return from PARSETYPE to procfn
26120	26182	{
26121	26183	uint64_t oldstack = (uint64_t )stack[0];
26122	26184	// copy mutable arguments back from call to PARSETYPE

		@@ -26136,7 +26198,7 @@
26136	26198	stack[base + 21/id/] = 0; // init
26137	26199	// call skipwscmnt from procfn
26138	26200	stack[base + 22LLU] = base;
26139		- stack[base + 23LLU] = 1701LLU;
	26201	+ stack[base + 23LLU] = 1706LLU;
26140	26202	// arguments for call to skipwscmnt
26141	26203	stack[base + 25LLU] = stack[base + 2]/lookahead/;
26142	26204	// set stack-base & callee-address

		@@ -26144,7 +26206,7 @@
26144	26206	label = 18446744073709551581LLU; // skipwscmnt
26145	26207	break;
26146	26208	}
26147		- case 1701LLU: // return from skipwscmnt to procfn
	26209	+ case 1706LLU: // return from skipwscmnt to procfn
26148	26210	{
26149	26211	// copy mutable arguments back from call to skipwscmnt
26150	26212	// copy back results provided by call to skipwscmnt

		@@ -26151,7 +26213,7 @@
26151	26213	stack[base + 2] = stack[base + 24LLU];
26152	26214	// call isalpha from procfn
26153	26215	stack[base + 22LLU] = base;
26154		- stack[base + 23LLU] = 1702LLU;
	26216	+ stack[base + 23LLU] = 1707LLU;
26155	26217	// arguments for call to isalpha
26156	26218	stack[base + 25LLU] = stack[base + 2]/lookahead/;
26157	26219	// set stack-base & callee-address

		@@ -26159,7 +26221,7 @@
26159	26221	label = 2LLU; // isalpha
26160	26222	break;
26161	26223	}
26162		- case 1702LLU: // return from isalpha to procfn
	26224	+ case 1707LLU: // return from isalpha to procfn
26163	26225	{
26164	26226	// copy mutable arguments back from call to isalpha
26165	26227	// copy back results provided by call to isalpha

		@@ -26166,7 +26228,7 @@
26166	26228	stack[base + 13] = stack[base + 24LLU];
26167	26229	if(!stack[base + 13]/isequal/)
26168	26230	{
26169		- label = 1703LLU; // jump to alternative
	26231	+ label = 1708LLU; // jump to alternative
26170	26232	break;
26171	26233	}
26172	26234

		@@ -26173,7 +26235,7 @@
26173	26235	// consequent
26174	26236	// call parseid from procfn
26175	26237	stack[base + 22LLU] = base;
26176		- stack[base + 23LLU] = 1705LLU;
	26238	+ stack[base + 23LLU] = 1710LLU;
26177	26239	// arguments for call to parseid
26178	26240	stack[base + 26LLU] = stack[base + 2]/lookahead/;
26179	26241	// set stack-base & callee-address

		@@ -26181,20 +26243,20 @@
26181	26243	label = 18446744073709551586LLU; // parseid
26182	26244	break;
26183	26245	}
26184		- case 1705LLU: // return from parseid to procfn
	26246	+ case 1710LLU: // return from parseid to procfn
26185	26247	{
26186	26248	// copy mutable arguments back from call to parseid
26187	26249	// copy back results provided by call to parseid
26188	26250	stack[base + 21] = stack[base + 24LLU];
26189	26251	stack[base + 2] = stack[base + 25LLU];
26190		- label = 1704LLU; // consequent complete
	26252	+ label = 1709LLU; // consequent complete
26191	26253	break;
26192	26254	}
26193		- case 1703LLU: // alternative
	26255	+ case 1708LLU: // alternative
26194	26256	{
26195	26257	// call idwithnr from procfn
26196	26258	stack[base + 22LLU] = base;
26197		- stack[base + 23LLU] = 1706LLU;
	26259	+ stack[base + 23LLU] = 1711LLU;
26198	26260	// arguments for call to idwithnr
26199	26261	stack[base + 25LLU] = 517219065798852608LLU;
26200	26262	stack[base + 26LLU] = stack[base + 18]/position/;

		@@ -26203,21 +26265,21 @@
26203	26265	label = 18446744073709551580LLU; // idwithnr
26204	26266	break;
26205	26267	}
26206		- case 1706LLU: // return from idwithnr to procfn
	26268	+ case 1711LLU: // return from idwithnr to procfn
26207	26269	{
26208	26270	// copy mutable arguments back from call to idwithnr
26209	26271	// copy back results provided by call to idwithnr
26210	26272	stack[base + 21] = stack[base + 24LLU];
26211		- label = 1704LLU; // alternative complete
	26273	+ label = 1709LLU; // alternative complete
26212	26274	break;
26213	26275	}
26214		- case 1704LLU: // completed if-then-else
	26276	+ case 1709LLU: // completed if-then-else
26215	26277	{
26216	26278	//#define exists 22
26217	26279	stack[base + 22/exists/] = 0; // init
26218	26280	// call lookparam from procfn
26219	26281	stack[base + 23LLU] = base;
26220		- stack[base + 24LLU] = 1707LLU;
	26282	+ stack[base + 24LLU] = 1712LLU;
26221	26283	// arguments for call to lookparam
26222	26284	stack[base + 26LLU] = stack[base + 16]/fnargtypes/;
26223	26285	stack[base + 27LLU] = stack[base + 21]/id/;

		@@ -26226,7 +26288,7 @@
26226	26288	label = 153LLU; // lookparam
26227	26289	break;
26228	26290	}
26229		- case 1707LLU: // return from lookparam to procfn
	26291	+ case 1712LLU: // return from lookparam to procfn
26230	26292	{
26231	26293	// copy mutable arguments back from call to lookparam
26232	26294	// copy back results provided by call to lookparam

		@@ -26233,7 +26295,7 @@
26233	26295	stack[base + 22] = stack[base + 25LLU];
26234	26296	if(!stack[base + 22]/exists/)
26235	26297	{
26236		- label = 1708LLU; // jump to alternative
	26298	+ label = 1713LLU; // jump to alternative
26237	26299	break;
26238	26300	}
26239	26301

		@@ -26241,7 +26303,7 @@
26241	26303	fprintf(stderr, "%s", "duplicate parameter ");
26242	26304	// call reportid from procfn
26243	26305	stack[base + 23LLU] = base;
26244		- stack[base + 24LLU] = 1710LLU;
	26306	+ stack[base + 24LLU] = 1715LLU;
26245	26307	// arguments for call to reportid
26246	26308	stack[base + 25LLU] = stack[base + 21]/id/;
26247	26309	// set stack-base & callee-address

		@@ -26249,26 +26311,26 @@
26249	26311	label = 18446744073709551587LLU; // reportid
26250	26312	break;
26251	26313	}
26252		- case 1710LLU: // return from reportid to procfn
	26314	+ case 1715LLU: // return from reportid to procfn
26253	26315	{
26254	26316	// copy mutable arguments back from call to reportid
26255	26317	fprintf(stderr, "%s", "\n");
26256	26318	exit(-1);
26257		- label = 1709LLU; // consequent complete
	26319	+ label = 1714LLU; // consequent complete
26258	26320	break;
26259	26321	}
26260		- case 1708LLU: // alternative
	26322	+ case 1713LLU: // alternative
26261	26323	{
26262		- label = 1709LLU; // alternative complete
	26324	+ label = 1714LLU; // alternative complete
26263	26325	break;
26264	26326	}
26265		- case 1709LLU: // completed if-then-else
	26327	+ case 1714LLU: // completed if-then-else
26266	26328	{
26267	26329	//#define exists 23
26268	26330	stack[base + 23/exists/] = 0; // init
26269	26331	// call lookresult from procfn
26270	26332	stack[base + 24LLU] = base;
26271		- stack[base + 25LLU] = 1711LLU;
	26333	+ stack[base + 25LLU] = 1716LLU;
26272	26334	// arguments for call to lookresult
26273	26335	stack[base + 27LLU] = stack[base + 15]/fnrestypes/;
26274	26336	stack[base + 28LLU] = stack[base + 21]/id/;

		@@ -26277,7 +26339,7 @@
26277	26339	label = 130LLU; // lookresult
26278	26340	break;
26279	26341	}
26280		- case 1711LLU: // return from lookresult to procfn
	26342	+ case 1716LLU: // return from lookresult to procfn
26281	26343	{
26282	26344	// copy mutable arguments back from call to lookresult
26283	26345	// copy back results provided by call to lookresult

		@@ -26284,7 +26346,7 @@
26284	26346	stack[base + 23] = stack[base + 26LLU];
26285	26347	if(!stack[base + 23]/exists/)
26286	26348	{
26287		- label = 1712LLU; // jump to alternative
	26349	+ label = 1717LLU; // jump to alternative
26288	26350	break;
26289	26351	}
26290	26352

		@@ -26292,7 +26354,7 @@
26292	26354	fprintf(stderr, "%s", "parameter-name ");
26293	26355	// call reportid from procfn
26294	26356	stack[base + 24LLU] = base;
26295		- stack[base + 25LLU] = 1714LLU;
	26357	+ stack[base + 25LLU] = 1719LLU;
26296	26358	// arguments for call to reportid
26297	26359	stack[base + 26LLU] = stack[base + 21]/id/;
26298	26360	// set stack-base & callee-address

		@@ -26300,26 +26362,26 @@
26300	26362	label = 18446744073709551587LLU; // reportid
26301	26363	break;
26302	26364	}
26303		- case 1714LLU: // return from reportid to procfn
	26365	+ case 1719LLU: // return from reportid to procfn
26304	26366	{
26305	26367	// copy mutable arguments back from call to reportid
26306	26368	fprintf(stderr, "%s", " already used for result\n");
26307	26369	exit(-1);
26308		- label = 1713LLU; // consequent complete
	26370	+ label = 1718LLU; // consequent complete
26309	26371	break;
26310	26372	}
26311		- case 1712LLU: // alternative
	26373	+ case 1717LLU: // alternative
26312	26374	{
26313		- label = 1713LLU; // alternative complete
	26375	+ label = 1718LLU; // alternative complete
26314	26376	break;
26315	26377	}
26316		- case 1713LLU: // completed if-then-else
	26378	+ case 1718LLU: // completed if-then-else
26317	26379	{
26318	26380	//#define argtypeid 22
26319	26381	stack[base + 22/argtypeid/] = 0; // init
26320	26382	// call mktypeid from procfn
26321	26383	stack[base + 23LLU] = base;
26322		- stack[base + 24LLU] = 1715LLU;
	26384	+ stack[base + 24LLU] = 1720LLU;
26323	26385	// arguments for call to mktypeid
26324	26386	stack[base + 26LLU] = stack[base + 19]/argtype/;
26325	26387	stack[base + 27LLU] = stack[base + 21]/id/;

		@@ -26328,7 +26390,7 @@
26328	26390	label = 105LLU; // mktypeid
26329	26391	break;
26330	26392	}
26331		- case 1715LLU: // return from mktypeid to procfn
	26393	+ case 1720LLU: // return from mktypeid to procfn
26332	26394	{
26333	26395	// copy mutable arguments back from call to mktypeid
26334	26396	// copy back results provided by call to mktypeid

		@@ -26337,7 +26399,7 @@
26337	26399	stack[base + 23/param/] = 0; // init
26338	26400	// call mkparam from procfn
26339	26401	stack[base + 24LLU] = base;
26340		- stack[base + 25LLU] = 1716LLU;
	26402	+ stack[base + 25LLU] = 1721LLU;
26341	26403	// arguments for call to mkparam
26342	26404	stack[base + 27LLU] = stack[base + 22]/argtypeid/;
26343	26405	stack[base + 28LLU] = stack[base + 20]/mutable/;

		@@ -26346,7 +26408,7 @@
26346	26408	label = 140LLU; // mkparam
26347	26409	break;
26348	26410	}
26349		- case 1716LLU: // return from mkparam to procfn
	26411	+ case 1721LLU: // return from mkparam to procfn
26350	26412	{
26351	26413	// copy mutable arguments back from call to mkparam
26352	26414	// copy back results provided by call to mkparam

		@@ -26359,7 +26421,7 @@
26359	26421	}
26360	26422	// call skipwscmnt from procfn
26361	26423	stack[base + 24LLU] = base;
26362		- stack[base + 25LLU] = 1717LLU;
	26424	+ stack[base + 25LLU] = 1722LLU;
26363	26425	// arguments for call to skipwscmnt
26364	26426	stack[base + 27LLU] = stack[base + 2]/lookahead/;
26365	26427	// set stack-base & callee-address

		@@ -26367,7 +26429,7 @@
26367	26429	label = 18446744073709551581LLU; // skipwscmnt
26368	26430	break;
26369	26431	}
26370		- case 1717LLU: // return from skipwscmnt to procfn
	26432	+ case 1722LLU: // return from skipwscmnt to procfn
26371	26433	{
26372	26434	// copy mutable arguments back from call to skipwscmnt
26373	26435	// copy back results provided by call to skipwscmnt

		@@ -26374,7 +26436,7 @@
26374	26436	stack[base + 2] = stack[base + 26LLU];
26375	26437	// call neq from procfn
26376	26438	stack[base + 24LLU] = base;
26377		- stack[base + 25LLU] = 1718LLU;
	26439	+ stack[base + 25LLU] = 1723LLU;
26378	26440	// arguments for call to neq
26379	26441	stack[base + 27LLU] = stack[base + 2]/lookahead/;
26380	26442	stack[base + 28LLU] = 41LLU;

		@@ -26383,7 +26445,7 @@
26383	26445	label = 18446744073709551599LLU; // neq
26384	26446	break;
26385	26447	}
26386		- case 1718LLU: // return from neq to procfn
	26448	+ case 1723LLU: // return from neq to procfn
26387	26449	{
26388	26450	// copy mutable arguments back from call to neq
26389	26451	// copy back results provided by call to neq

		@@ -26390,7 +26452,7 @@
26390	26452	stack[base + 17] = stack[base + 26LLU];
26391	26453	if(!stack[base + 17]/continue/)
26392	26454	{
26393		- label = 1719LLU; // jump to alternative
	26455	+ label = 1724LLU; // jump to alternative
26394	26456	break;
26395	26457	}
26396	26458

		@@ -26397,7 +26459,7 @@
26397	26459	// consequent
26398	26460	// call matchsym from procfn
26399	26461	stack[base + 24LLU] = base;
26400		- stack[base + 25LLU] = 1721LLU;
	26462	+ stack[base + 25LLU] = 1726LLU;
26401	26463	// arguments for call to matchsym
26402	26464	stack[base + 26LLU] = 44LLU;
26403	26465	stack[base + 27LLU] = stack[base + 2]/lookahead/;

		@@ -26406,23 +26468,23 @@
26406	26468	label = 27LLU; // matchsym
26407	26469	break;
26408	26470	}
26409		- case 1721LLU: // return from matchsym to procfn
	26471	+ case 1726LLU: // return from matchsym to procfn
26410	26472	{
26411	26473	// copy mutable arguments back from call to matchsym
26412	26474	stack[base + 2]/lookahead/ = stack[base + 27LLU];
26413		- label = 1720LLU; // consequent complete
	26475	+ label = 1725LLU; // consequent complete
26414	26476	break;
26415	26477	}
26416		- case 1719LLU: // alternative
	26478	+ case 1724LLU: // alternative
26417	26479	{
26418		- label = 1720LLU; // alternative complete
	26480	+ label = 1725LLU; // alternative complete
26419	26481	break;
26420	26482	}
26421		- case 1720LLU: // completed if-then-else
	26483	+ case 1725LLU: // completed if-then-else
26422	26484	{
26423	26485	// call add from procfn
26424	26486	stack[base + 24LLU] = base;
26425		- stack[base + 25LLU] = 1722LLU;
	26487	+ stack[base + 25LLU] = 1727LLU;
26426	26488	// arguments for call to add
26427	26489	stack[base + 27LLU] = 1LLU;
26428	26490	stack[base + 28LLU] = stack[base + 18]/position/;

		@@ -26431,24 +26493,24 @@
26431	26493	label = 18446744073709551605LLU; // add
26432	26494	break;
26433	26495	}
26434		- case 1722LLU: // return from add to procfn
	26496	+ case 1727LLU: // return from add to procfn
26435	26497	{
26436	26498	// copy mutable arguments back from call to add
26437	26499	// copy back results provided by call to add
26438	26500	stack[base + 18] = stack[base + 26LLU];
26439		- label = 1690LLU; // repeat
	26501	+ label = 1695LLU; // repeat
26440	26502	break;
26441	26503	}
26442		- case 1691LLU: // loop finished
	26504	+ case 1696LLU: // loop finished
26443	26505	{
26444		- label = 1689LLU; // alternative complete
	26506	+ label = 1694LLU; // alternative complete
26445	26507	break;
26446	26508	}
26447		- case 1689LLU: // completed if-then-else
	26509	+ case 1694LLU: // completed if-then-else
26448	26510	{
26449	26511	// call matchsym from procfn
26450	26512	stack[base + 17LLU] = base;
26451		- stack[base + 18LLU] = 1723LLU;
	26513	+ stack[base + 18LLU] = 1728LLU;
26452	26514	// arguments for call to matchsym
26453	26515	stack[base + 19LLU] = 41LLU;
26454	26516	stack[base + 20LLU] = stack[base + 2]/lookahead/;

		@@ -26457,7 +26519,7 @@
26457	26519	label = 27LLU; // matchsym
26458	26520	break;
26459	26521	}
26460		- case 1723LLU: // return from matchsym to procfn
	26522	+ case 1728LLU: // return from matchsym to procfn
26461	26523	{
26462	26524	// copy mutable arguments back from call to matchsym
26463	26525	stack[base + 2]/lookahead/ = stack[base + 20LLU];

		@@ -26464,15 +26526,15 @@
26464	26526	list_reverse(((struct listnode *)(&stack[base + 16]/fnargtypes*/)));
26465	26527	stack[base + 10]/fnrescount/ = list_size(((struct listnode )(stack[base + 15]/fnrestypes*/)));
26466	26528	stack[base + 11]/fnargcount/ = list_size(((struct listnode )(stack[base + 16]/fnargtypes*/)));
26467		- label = 1641LLU; // consequent complete
	26529	+ label = 1646LLU; // consequent complete
26468	26530	break;
26469	26531	}
26470		- case 1640LLU: // alternative
	26532	+ case 1645LLU: // alternative
26471	26533	{
26472	26534	fprintf(stderr, "%s", "parsing function expected number of results but found token ");
26473	26535	// call reporttok from procfn
26474	26536	stack[base + 17LLU] = base;
26475		- stack[base + 18LLU] = 1724LLU;
	26537	+ stack[base + 18LLU] = 1729LLU;
26476	26538	// arguments for call to reporttok
26477	26539	stack[base + 19LLU] = stack[base + 3]/variant/;
26478	26540	stack[base + 20LLU] = stack[base + 4]/content/;

		@@ -26481,21 +26543,21 @@
26481	26543	label = 18446744073709551583LLU; // reporttok
26482	26544	break;
26483	26545	}
26484		- case 1724LLU: // return from reporttok to procfn
	26546	+ case 1729LLU: // return from reporttok to procfn
26485	26547	{
26486	26548	// copy mutable arguments back from call to reporttok
26487	26549	fprintf(stderr, "%s", "\n");
26488	26550	exit(-1);
26489		- label = 1641LLU; // alternative complete
	26551	+ label = 1646LLU; // alternative complete
26490	26552	break;
26491	26553	}
26492		- case 1641LLU: // completed if-then-else
	26554	+ case 1646LLU: // completed if-then-else
26493	26555	{
26494	26556	//#define sizelimit 17
26495	26557	stack[base + 17/sizelimit/] = 0; // init
26496	26558	// call sub from procfn
26497	26559	stack[base + 18LLU] = base;
26498		- stack[base + 19LLU] = 1725LLU;
	26560	+ stack[base + 19LLU] = 1730LLU;
26499	26561	// arguments for call to sub
26500	26562	stack[base + 21LLU] = 0LLU;
26501	26563	stack[base + 22LLU] = 1LLU;

		@@ -26504,7 +26566,7 @@
26504	26566	label = 18446744073709551604LLU; // sub
26505	26567	break;
26506	26568	}
26507		- case 1725LLU: // return from sub to procfn
	26569	+ case 1730LLU: // return from sub to procfn
26508	26570	{
26509	26571	// copy mutable arguments back from call to sub
26510	26572	// copy back results provided by call to sub

		@@ -26511,7 +26573,7 @@
26511	26573	stack[base + 17] = stack[base + 20LLU];
26512	26574	if(!stack[base + 7]/fnrec/)
26513	26575	{
26514		- label = 1726LLU; // jump to alternative
	26576	+ label = 1731LLU; // jump to alternative
26515	26577	break;
26516	26578	}
26517	26579

		@@ -26518,7 +26580,7 @@
26518	26580	// consequent
26519	26581	// call parsetoken from procfn
26520	26582	stack[base + 18LLU] = base;
26521		- stack[base + 19LLU] = 1728LLU;
	26583	+ stack[base + 19LLU] = 1733LLU;
26522	26584	// arguments for call to parsetoken
26523	26585	stack[base + 23LLU] = stack[base + 2]/lookahead/;
26524	26586	// set stack-base & callee-address

		@@ -26526,7 +26588,7 @@
26526	26588	label = 18446744073709551585LLU; // parsetoken
26527	26589	break;
26528	26590	}
26529		- case 1728LLU: // return from parsetoken to procfn
	26591	+ case 1733LLU: // return from parsetoken to procfn
26530	26592	{
26531	26593	// copy mutable arguments back from call to parsetoken
26532	26594	// copy back results provided by call to parsetoken

		@@ -26535,7 +26597,7 @@
26535	26597	stack[base + 2] = stack[base + 22LLU];
26536	26598	// call equ from procfn
26537	26599	stack[base + 18LLU] = base;
26538		- stack[base + 19LLU] = 1729LLU;
	26600	+ stack[base + 19LLU] = 1734LLU;
26539	26601	// arguments for call to equ
26540	26602	stack[base + 21LLU] = stack[base + 3]/variant/;
26541	26603	stack[base + 22LLU] = 1LLU;

		@@ -26544,7 +26606,7 @@
26544	26606	label = 18446744073709551600LLU; // equ
26545	26607	break;
26546	26608	}
26547		- case 1729LLU: // return from equ to procfn
	26609	+ case 1734LLU: // return from equ to procfn
26548	26610	{
26549	26611	// copy mutable arguments back from call to equ
26550	26612	// copy back results provided by call to equ

		@@ -26551,21 +26613,21 @@
26551	26613	stack[base + 14] = stack[base + 20LLU];
26552	26614	if(!stack[base + 14]/isnumber/)
26553	26615	{
26554		- label = 1730LLU; // jump to alternative
	26616	+ label = 1735LLU; // jump to alternative
26555	26617	break;
26556	26618	}
26557	26619
26558	26620	// consequent
26559	26621	stack[base + 17]/sizelimit/ = stack[base + 4]/content/;
26560		- label = 1731LLU; // consequent complete
	26622	+ label = 1736LLU; // consequent complete
26561	26623	break;
26562	26624	}
26563		- case 1730LLU: // alternative
	26625	+ case 1735LLU: // alternative
26564	26626	{
26565	26627	fprintf(stderr, "%s", "parsing recursive function expected size-limit but found token ");
26566	26628	// call reporttok from procfn
26567	26629	stack[base + 18LLU] = base;
26568		- stack[base + 19LLU] = 1732LLU;
	26630	+ stack[base + 19LLU] = 1737LLU;
26569	26631	// arguments for call to reporttok
26570	26632	stack[base + 20LLU] = stack[base + 3]/variant/;
26571	26633	stack[base + 21LLU] = stack[base + 4]/content/;

		@@ -26574,31 +26636,31 @@
26574	26636	label = 18446744073709551583LLU; // reporttok
26575	26637	break;
26576	26638	}
26577		- case 1732LLU: // return from reporttok to procfn
	26639	+ case 1737LLU: // return from reporttok to procfn
26578	26640	{
26579	26641	// copy mutable arguments back from call to reporttok
26580	26642	fprintf(stderr, "%s", "\n");
26581	26643	exit(-1);
26582		- label = 1731LLU; // alternative complete
	26644	+ label = 1736LLU; // alternative complete
26583	26645	break;
26584	26646	}
26585		- case 1731LLU: // completed if-then-else
	26647	+ case 1736LLU: // completed if-then-else
26586	26648	{
26587		- label = 1727LLU; // consequent complete
	26649	+ label = 1732LLU; // consequent complete
26588	26650	break;
26589	26651	}
26590		- case 1726LLU: // alternative
	26652	+ case 1731LLU: // alternative
26591	26653	{
26592		- label = 1727LLU; // alternative complete
	26654	+ label = 1732LLU; // alternative complete
26593	26655	break;
26594	26656	}
26595		- case 1727LLU: // completed if-then-else
	26657	+ case 1732LLU: // completed if-then-else
26596	26658	{
26597	26659	//#define ismain 18
26598	26660	stack[base + 18/ismain/] = 0; // init
26599	26661	// call equ from procfn
26600	26662	stack[base + 19LLU] = base;
26601		- stack[base + 20LLU] = 1733LLU;
	26663	+ stack[base + 20LLU] = 1738LLU;
26602	26664	// arguments for call to equ
26603	26665	stack[base + 22LLU] = 728618386900123648LLU;
26604	26666	stack[base + 23LLU] = stack[base + 8]/fnid/;

		@@ -26607,7 +26669,7 @@
26607	26669	label = 18446744073709551600LLU; // equ
26608	26670	break;
26609	26671	}
26610		- case 1733LLU: // return from equ to procfn
	26672	+ case 1738LLU: // return from equ to procfn
26611	26673	{
26612	26674	// copy mutable arguments back from call to equ
26613	26675	// copy back results provided by call to equ

		@@ -26614,7 +26676,7 @@
26614	26676	stack[base + 18] = stack[base + 21LLU];
26615	26677	if(!stack[base + 18]/ismain/)
26616	26678	{
26617		- label = 1734LLU; // jump to alternative
	26679	+ label = 1739LLU; // jump to alternative
26618	26680	break;
26619	26681	}
26620	26682

		@@ -26622,7 +26684,7 @@
26622	26684	stack[base + 9]/fnlabel/ = 1;
26623	26685	// call equ from procfn
26624	26686	stack[base + 19LLU] = base;
26625		- stack[base + 20LLU] = 1736LLU;
	26687	+ stack[base + 20LLU] = 1741LLU;
26626	26688	// arguments for call to equ
26627	26689	stack[base + 22LLU] = 1LLU;
26628	26690	stack[base + 23LLU] = stack[base + 10]/fnrescount/;

		@@ -26631,7 +26693,7 @@
26631	26693	label = 18446744073709551600LLU; // equ
26632	26694	break;
26633	26695	}
26634		- case 1736LLU: // return from equ to procfn
	26696	+ case 1741LLU: // return from equ to procfn
26635	26697	{
26636	26698	// copy mutable arguments back from call to equ
26637	26699	// copy back results provided by call to equ

		@@ -26638,20 +26700,20 @@
26638	26700	stack[base + 13] = stack[base + 21LLU];
26639	26701	if(!stack[base + 13]/isequal/)
26640	26702	{
26641		- label = 1737LLU; // jump to alternative
	26703	+ label = 1742LLU; // jump to alternative
26642	26704	break;
26643	26705	}
26644	26706
26645	26707	// consequent
26646		- label = 1738LLU; // consequent complete
	26708	+ label = 1743LLU; // consequent complete
26647	26709	break;
26648	26710	}
26649		- case 1737LLU: // alternative
	26711	+ case 1742LLU: // alternative
26650	26712	{
26651	26713	fprintf(stderr, "%s", "expected 1 result in definition of main but found ");
26652	26714	// call reportnr from procfn
26653	26715	stack[base + 19LLU] = base;
26654		- stack[base + 20LLU] = 1739LLU;
	26716	+ stack[base + 20LLU] = 1744LLU;
26655	26717	// arguments for call to reportnr
26656	26718	stack[base + 21LLU] = stack[base + 10]/fnrescount/;
26657	26719	// set stack-base & callee-address

		@@ -26659,19 +26721,19 @@
26659	26721	label = 18446744073709551590LLU; // reportnr
26660	26722	break;
26661	26723	}
26662		- case 1739LLU: // return from reportnr to procfn
	26724	+ case 1744LLU: // return from reportnr to procfn
26663	26725	{
26664	26726	// copy mutable arguments back from call to reportnr
26665	26727	fprintf(stderr, "%s", "\n");
26666	26728	exit(-1);
26667		- label = 1738LLU; // alternative complete
	26729	+ label = 1743LLU; // alternative complete
26668	26730	break;
26669	26731	}
26670		- case 1738LLU: // completed if-then-else
	26732	+ case 1743LLU: // completed if-then-else
26671	26733	{
26672	26734	// call equ from procfn
26673	26735	stack[base + 19LLU] = base;
26674		- stack[base + 20LLU] = 1740LLU;
	26736	+ stack[base + 20LLU] = 1745LLU;
26675	26737	// arguments for call to equ
26676	26738	stack[base + 22LLU] = 0LLU;
26677	26739	stack[base + 23LLU] = stack[base + 11]/fnargcount/;

		@@ -26680,7 +26742,7 @@
26680	26742	label = 18446744073709551600LLU; // equ
26681	26743	break;
26682	26744	}
26683		- case 1740LLU: // return from equ to procfn
	26745	+ case 1745LLU: // return from equ to procfn
26684	26746	{
26685	26747	// copy mutable arguments back from call to equ
26686	26748	// copy back results provided by call to equ

		@@ -26687,20 +26749,20 @@
26687	26749	stack[base + 13] = stack[base + 21LLU];
26688	26750	if(!stack[base + 13]/isequal/)
26689	26751	{
26690		- label = 1741LLU; // jump to alternative
	26752	+ label = 1746LLU; // jump to alternative
26691	26753	break;
26692	26754	}
26693	26755
26694	26756	// consequent
26695		- label = 1742LLU; // consequent complete
	26757	+ label = 1747LLU; // consequent complete
26696	26758	break;
26697	26759	}
26698		- case 1741LLU: // alternative
	26760	+ case 1746LLU: // alternative
26699	26761	{
26700	26762	fprintf(stderr, "%s", "expected 0 arguments in definition of main but found ");
26701	26763	// call reportnr from procfn
26702	26764	stack[base + 19LLU] = base;
26703		- stack[base + 20LLU] = 1743LLU;
	26765	+ stack[base + 20LLU] = 1748LLU;
26704	26766	// arguments for call to reportnr
26705	26767	stack[base + 21LLU] = stack[base + 11]/fnargcount/;
26706	26768	// set stack-base & callee-address

		@@ -26708,24 +26770,24 @@
26708	26770	label = 18446744073709551590LLU; // reportnr
26709	26771	break;
26710	26772	}
26711		- case 1743LLU: // return from reportnr to procfn
	26773	+ case 1748LLU: // return from reportnr to procfn
26712	26774	{
26713	26775	// copy mutable arguments back from call to reportnr
26714	26776	fprintf(stderr, "%s", "\n");
26715	26777	exit(-1);
26716		- label = 1742LLU; // alternative complete
	26778	+ label = 1747LLU; // alternative complete
26717	26779	break;
26718	26780	}
26719		- case 1742LLU: // completed if-then-else
	26781	+ case 1747LLU: // completed if-then-else
26720	26782	{
26721		- label = 1735LLU; // consequent complete
	26783	+ label = 1740LLU; // consequent complete
26722	26784	break;
26723	26785	}
26724		- case 1734LLU: // alternative
	26786	+ case 1739LLU: // alternative
26725	26787	{
26726	26788	// call add from procfn
26727	26789	stack[base + 19LLU] = base;
26728		- stack[base + 20LLU] = 1744LLU;
	26790	+ stack[base + 20LLU] = 1749LLU;
26729	26791	// arguments for call to add
26730	26792	stack[base + 22LLU] = 1LLU;
26731	26793	stack[base + 23LLU] = stack[base + 5]/label/;

		@@ -26734,21 +26796,21 @@
26734	26796	label = 18446744073709551605LLU; // add
26735	26797	break;
26736	26798	}
26737		- case 1744LLU: // return from add to procfn
	26799	+ case 1749LLU: // return from add to procfn
26738	26800	{
26739	26801	// copy mutable arguments back from call to add
26740	26802	// copy back results provided by call to add
26741	26803	stack[base + 5] = stack[base + 21LLU];
26742	26804	stack[base + 9]/fnlabel/ = stack[base + 5]/label/;
26743		- label = 1735LLU; // alternative complete
	26805	+ label = 1740LLU; // alternative complete
26744	26806	break;
26745	26807	}
26746		- case 1735LLU: // completed if-then-else
	26808	+ case 1740LLU: // completed if-then-else
26747	26809	{
26748	26810	printf("%s", "\n case ");
26749	26811	// call printnr from procfn
26750	26812	stack[base + 19LLU] = base;
26751		- stack[base + 20LLU] = 1745LLU;
	26813	+ stack[base + 20LLU] = 1750LLU;
26752	26814	// arguments for call to printnr
26753	26815	stack[base + 21LLU] = stack[base + 9]/fnlabel/;
26754	26816	// set stack-base & callee-address

		@@ -26756,13 +26818,13 @@
26756	26818	label = 18446744073709551591LLU; // printnr
26757	26819	break;
26758	26820	}
26759		- case 1745LLU: // return from printnr to procfn
	26821	+ case 1750LLU: // return from printnr to procfn
26760	26822	{
26761	26823	// copy mutable arguments back from call to printnr
26762	26824	printf("%s", "LLU: // ");
26763	26825	// call printid from procfn
26764	26826	stack[base + 19LLU] = base;
26765		- stack[base + 20LLU] = 1746LLU;
	26827	+ stack[base + 20LLU] = 1751LLU;
26766	26828	// arguments for call to printid
26767	26829	stack[base + 21LLU] = stack[base + 8]/fnid/;
26768	26830	// set stack-base & callee-address

		@@ -26770,7 +26832,7 @@
26770	26832	label = 18446744073709551588LLU; // printid
26771	26833	break;
26772	26834	}
26773		- case 1746LLU: // return from printid to procfn
	26835	+ case 1751LLU: // return from printid to procfn
26774	26836	{
26775	26837	// copy mutable arguments back from call to printid
26776	26838	printf("%s", "\n {");

		@@ -26781,14 +26843,14 @@
26781	26843	stack[base + 20/counter/] = 0; // init
26782	26844	stack[base + 20]/counter/ = stack[base + 10]/fnrescount/;
26783	26845	assign(stack[base + 15]/fnrestypes/, &stack[base + 21]/fnrestypes/);
26784		- label = 1747LLU; // start to repeat
	26846	+ label = 1752LLU; // start to repeat
26785	26847	break;
26786	26848	}
26787		- case 1747LLU: // repeat from here
	26849	+ case 1752LLU: // repeat from here
26788	26850	{
26789	26851	if(!stack[base + 21]/fnrestypes/)
26790	26852	{
26791		- label = 1748LLU; // break loop
	26853	+ label = 1753LLU; // break loop
26792	26854	break;
26793	26855	}
26794	26856

		@@ -26804,7 +26866,7 @@
26804	26866	stack[base + 24/ires/] = 0; // init
26805	26867	// call sub from procfn
26806	26868	stack[base + 25LLU] = base;
26807		- stack[base + 26LLU] = 1749LLU;
	26869	+ stack[base + 26LLU] = 1754LLU;
26808	26870	// arguments for call to sub
26809	26871	stack[base + 28LLU] = stack[base + 10]/fnrescount/;
26810	26872	stack[base + 29LLU] = stack[base + 20]/counter/;

		@@ -26813,7 +26875,7 @@
26813	26875	label = 18446744073709551604LLU; // sub
26814	26876	break;
26815	26877	}
26816		- case 1749LLU: // return from sub to procfn
	26878	+ case 1754LLU: // return from sub to procfn
26817	26879	{
26818	26880	// copy mutable arguments back from call to sub
26819	26881	// copy back results provided by call to sub

		@@ -26821,7 +26883,7 @@
26821	26883	printf("%s", "\n//#define res");
26822	26884	// call printnr from procfn
26823	26885	stack[base + 25LLU] = base;
26824		- stack[base + 26LLU] = 1750LLU;
	26886	+ stack[base + 26LLU] = 1755LLU;
26825	26887	// arguments for call to printnr
26826	26888	stack[base + 27LLU] = stack[base + 24]/ires/;
26827	26889	// set stack-base & callee-address

		@@ -26829,13 +26891,13 @@
26829	26891	label = 18446744073709551591LLU; // printnr
26830	26892	break;
26831	26893	}
26832		- case 1750LLU: // return from printnr to procfn
	26894	+ case 1755LLU: // return from printnr to procfn
26833	26895	{
26834	26896	// copy mutable arguments back from call to printnr
26835	26897	printf("%s", " ");
26836	26898	// call printnr from procfn
26837	26899	stack[base + 25LLU] = base;
26838		- stack[base + 26LLU] = 1751LLU;
	26900	+ stack[base + 26LLU] = 1756LLU;
26839	26901	// arguments for call to printnr
26840	26902	stack[base + 27LLU] = stack[base + 24]/ires/;
26841	26903	// set stack-base & callee-address

		@@ -26843,12 +26905,12 @@
26843	26905	label = 18446744073709551591LLU; // printnr
26844	26906	break;
26845	26907	}
26846		- case 1751LLU: // return from printnr to procfn
	26908	+ case 1756LLU: // return from printnr to procfn
26847	26909	{
26848	26910	// copy mutable arguments back from call to printnr
26849	26911	if(/result/0 != ((uint64_t )(stack[base + 22]/result*/))[0])
26850	26912	{
26851		- label = 1752LLU; // jump to alternative
	26913	+ label = 1757LLU; // jump to alternative
26852	26914	break;
26853	26915	}
26854	26916

		@@ -26861,7 +26923,7 @@
26861	26923	stack[base + 26]/mutable/ = ((uint64_t *)(stack[base + 22]/result*/))[1][1];
26862	26924	if(/typeid/0 != ((uint64_t )(stack[base + 25]/restypeid*/))[0])
26863	26925	{
26864		- label = 1754LLU; // jump to alternative
	26926	+ label = 1759LLU; // jump to alternative
26865	26927	break;
26866	26928	}
26867	26929

		@@ -26879,7 +26941,7 @@
26879	26941	// call copytype from procfn
26880	26942	newstack[0] = (uint64_t)stack; // backup stack location
26881	26943	newstack[1] = base;
26882		- newstack[2] = 1756LLU;
	26944	+ newstack[2] = 1761LLU;
26883	26945	// arguments for call to copytype
26884	26946	newstack[4LLU] = stack[base + 27]/restype/;
26885	26947	stack = newstack;

		@@ -26888,7 +26950,7 @@
26888	26950	label = 82LLU; // copytype
26889	26951	break;
26890	26952	}
26891		- case 1756LLU: // return from copytype to procfn
	26953	+ case 1761LLU: // return from copytype to procfn
26892	26954	{
26893	26955	uint64_t oldstack = (uint64_t )stack[0];
26894	26956	// copy mutable arguments back from call to copytype

		@@ -26905,7 +26967,7 @@
26905	26967	stack[base + 30/newletres/] = 0; // init
26906	26968	// call mklet from procfn
26907	26969	stack[base + 31LLU] = base;
26908		- stack[base + 32LLU] = 1757LLU;
	26970	+ stack[base + 32LLU] = 1762LLU;
26909	26971	// arguments for call to mklet
26910	26972	stack[base + 34LLU] = stack[base + 29]/type/;
26911	26973	stack[base + 35LLU] = stack[base + 28]/resid/;

		@@ -26916,7 +26978,7 @@
26916	26978	label = 163LLU; // mklet
26917	26979	break;
26918	26980	}
26919		- case 1757LLU: // return from mklet to procfn
	26981	+ case 1762LLU: // return from mklet to procfn
26920	26982	{
26921	26983	// copy mutable arguments back from call to mklet
26922	26984	// copy back results provided by call to mklet

		@@ -26929,35 +26991,35 @@
26929	26991	}
26930	26992	((uint64_t *)(stack[base + 25]/restypeid/))[1][1] = stack[base + 28]/resid*/;
26931	26993	((uint64_t *)(stack[base + 25]/restypeid/))[1][0] = stack[base + 27]/restype*/;
26932		- label = 1755LLU; // consequent complete
	26994	+ label = 1760LLU; // consequent complete
26933	26995	break;
26934	26996	}
26935		- case 1754LLU: // alternative
	26997	+ case 1759LLU: // alternative
26936	26998	{
26937	26999	fprintf(stderr, "%s", "INTERNAL ERROR accessing typeid\n");
26938	27000	exit(-1);
26939		- label = 1755LLU; // alternative complete
	27001	+ label = 1760LLU; // alternative complete
26940	27002	break;
26941	27003	}
26942		- case 1755LLU: // completed if-then-else
	27004	+ case 1760LLU: // completed if-then-else
26943	27005	{
26944	27006	((uint64_t *)(stack[base + 22]/result/))[1][1] = stack[base + 26]/mutable*/;
26945	27007	((uint64_t *)(stack[base + 22]/result/))[1][0] = stack[base + 25]/restypeid*/;
26946		- label = 1753LLU; // consequent complete
	27008	+ label = 1758LLU; // consequent complete
26947	27009	break;
26948	27010	}
26949		- case 1752LLU: // alternative
	27011	+ case 1757LLU: // alternative
26950	27012	{
26951	27013	fprintf(stderr, "%s", "INTERNAL ERROR accessing result\n");
26952	27014	exit(-1);
26953		- label = 1753LLU; // alternative complete
	27015	+ label = 1758LLU; // alternative complete
26954	27016	break;
26955	27017	}
26956		- case 1753LLU: // completed if-then-else
	27018	+ case 1758LLU: // completed if-then-else
26957	27019	{
26958	27020	// call sub from procfn
26959	27021	stack[base + 25LLU] = base;
26960		- stack[base + 26LLU] = 1758LLU;
	27022	+ stack[base + 26LLU] = 1763LLU;
26961	27023	// arguments for call to sub
26962	27024	stack[base + 28LLU] = stack[base + 20]/counter/;
26963	27025	stack[base + 29LLU] = 1LLU;

		@@ -26966,29 +27028,29 @@
26966	27028	label = 18446744073709551604LLU; // sub
26967	27029	break;
26968	27030	}
26969		- case 1758LLU: // return from sub to procfn
	27031	+ case 1763LLU: // return from sub to procfn
26970	27032	{
26971	27033	// copy mutable arguments back from call to sub
26972	27034	// copy back results provided by call to sub
26973	27035	stack[base + 20] = stack[base + 27LLU];
26974	27036	((struct listnode )(stack[base + 23/previous/]))->data = stack[base + 22]/result*/;
26975		- label = 1747LLU; // repeat
	27037	+ label = 1752LLU; // repeat
26976	27038	break;
26977	27039	}
26978		- case 1748LLU: // loop finished
	27040	+ case 1753LLU: // loop finished
26979	27041	{
26980	27042	//#define counter 20
26981	27043	stack[base + 20/counter/] = 0; // init
26982	27044	stack[base + 20]/counter/ = stack[base + 11]/fnargcount/;
26983	27045	assign(stack[base + 16]/fnargtypes/, &stack[base + 21]/fnargtypes/);
26984		- label = 1759LLU; // start to repeat
	27046	+ label = 1764LLU; // start to repeat
26985	27047	break;
26986	27048	}
26987		- case 1759LLU: // repeat from here
	27049	+ case 1764LLU: // repeat from here
26988	27050	{
26989	27051	if(!stack[base + 21]/fnargtypes/)
26990	27052	{
26991		- label = 1760LLU; // break loop
	27053	+ label = 1765LLU; // break loop
26992	27054	break;
26993	27055	}
26994	27056

		@@ -27004,7 +27066,7 @@
27004	27066	stack[base + 24/iarg/] = 0; // init
27005	27067	// call sub from procfn
27006	27068	stack[base + 25LLU] = base;
27007		- stack[base + 26LLU] = 1761LLU;
	27069	+ stack[base + 26LLU] = 1766LLU;
27008	27070	// arguments for call to sub
27009	27071	stack[base + 28LLU] = stack[base + 11]/fnargcount/;
27010	27072	stack[base + 29LLU] = stack[base + 20]/counter/;

		@@ -27013,7 +27075,7 @@
27013	27075	label = 18446744073709551604LLU; // sub
27014	27076	break;
27015	27077	}
27016		- case 1761LLU: // return from sub to procfn
	27078	+ case 1766LLU: // return from sub to procfn
27017	27079	{
27018	27080	// copy mutable arguments back from call to sub
27019	27081	// copy back results provided by call to sub

		@@ -27020,7 +27082,7 @@
27020	27082	stack[base + 24] = stack[base + 27LLU];
27021	27083	if(/param/0 != ((uint64_t )(stack[base + 22]/param*/))[0])
27022	27084	{
27023		- label = 1762LLU; // jump to alternative
	27085	+ label = 1767LLU; // jump to alternative
27024	27086	break;
27025	27087	}
27026	27088

		@@ -27033,7 +27095,7 @@
27033	27095	stack[base + 26]/mutable/ = ((uint64_t *)(stack[base + 22]/param*/))[1][1];
27034	27096	if(/typeid/0 != ((uint64_t )(stack[base + 25]/argtypeid*/))[0])
27035	27097	{
27036		- label = 1764LLU; // jump to alternative
	27098	+ label = 1769LLU; // jump to alternative
27037	27099	break;
27038	27100	}
27039	27101

		@@ -27047,7 +27109,7 @@
27047	27109	printf("%s", "\n//#define arg");
27048	27110	// call printnr from procfn
27049	27111	stack[base + 29LLU] = base;
27050		- stack[base + 30LLU] = 1766LLU;
	27112	+ stack[base + 30LLU] = 1771LLU;
27051	27113	// arguments for call to printnr
27052	27114	stack[base + 31LLU] = stack[base + 24]/iarg/;
27053	27115	// set stack-base & callee-address

		@@ -27055,7 +27117,7 @@
27055	27117	label = 18446744073709551591LLU; // printnr
27056	27118	break;
27057	27119	}
27058		- case 1766LLU: // return from printnr to procfn
	27120	+ case 1771LLU: // return from printnr to procfn
27059	27121	{
27060	27122	// copy mutable arguments back from call to printnr
27061	27123	printf("%s", " ");

		@@ -27066,7 +27128,7 @@
27066	27128	// call copytype from procfn
27067	27129	newstack[0] = (uint64_t)stack; // backup stack location
27068	27130	newstack[1] = base;
27069		- newstack[2] = 1767LLU;
	27131	+ newstack[2] = 1772LLU;
27070	27132	// arguments for call to copytype
27071	27133	newstack[4LLU] = stack[base + 27]/argtype/;
27072	27134	stack = newstack;

		@@ -27075,7 +27137,7 @@
27075	27137	label = 82LLU; // copytype
27076	27138	break;
27077	27139	}
27078		- case 1767LLU: // return from copytype to procfn
	27140	+ case 1772LLU: // return from copytype to procfn
27079	27141	{
27080	27142	uint64_t oldstack = (uint64_t )stack[0];
27081	27143	// copy mutable arguments back from call to copytype

		@@ -27090,7 +27152,7 @@
27090	27152	stack = oldstack;
27091	27153	// call add from procfn
27092	27154	stack[base + 30LLU] = base;
27093		- stack[base + 31LLU] = 1768LLU;
	27155	+ stack[base + 31LLU] = 1773LLU;
27094	27156	// arguments for call to add
27095	27157	stack[base + 33LLU] = stack[base + 10]/fnrescount/;
27096	27158	stack[base + 34LLU] = stack[base + 24]/iarg/;

		@@ -27099,7 +27161,7 @@
27099	27161	label = 18446744073709551605LLU; // add
27100	27162	break;
27101	27163	}
27102		- case 1768LLU: // return from add to procfn
	27164	+ case 1773LLU: // return from add to procfn
27103	27165	{
27104	27166	// copy mutable arguments back from call to add
27105	27167	// copy back results provided by call to add

		@@ -27106,7 +27168,7 @@
27106	27168	stack[base + 24] = stack[base + 32LLU];
27107	27169	// call printnr from procfn
27108	27170	stack[base + 30LLU] = base;
27109		- stack[base + 31LLU] = 1769LLU;
	27171	+ stack[base + 31LLU] = 1774LLU;
27110	27172	// arguments for call to printnr
27111	27173	stack[base + 32LLU] = stack[base + 24]/iarg/;
27112	27174	// set stack-base & callee-address

		@@ -27114,7 +27176,7 @@
27114	27176	label = 18446744073709551591LLU; // printnr
27115	27177	break;
27116	27178	}
27117		- case 1769LLU: // return from printnr to procfn
	27179	+ case 1774LLU: // return from printnr to procfn
27118	27180	{
27119	27181	// copy mutable arguments back from call to printnr
27120	27182	//#define newletarg 30

		@@ -27121,7 +27183,7 @@
27121	27183	stack[base + 30/newletarg/] = 0; // init
27122	27184	// call mklet from procfn
27123	27185	stack[base + 31LLU] = base;
27124		- stack[base + 32LLU] = 1770LLU;
	27186	+ stack[base + 32LLU] = 1775LLU;
27125	27187	// arguments for call to mklet
27126	27188	stack[base + 34LLU] = stack[base + 29]/type/;
27127	27189	stack[base + 35LLU] = stack[base + 28]/argid/;

		@@ -27132,7 +27194,7 @@
27132	27194	label = 163LLU; // mklet
27133	27195	break;
27134	27196	}
27135		- case 1770LLU: // return from mklet to procfn
	27197	+ case 1775LLU: // return from mklet to procfn
27136	27198	{
27137	27199	// copy mutable arguments back from call to mklet
27138	27200	// copy back results provided by call to mklet

		@@ -27145,35 +27207,35 @@
27145	27207	}
27146	27208	((uint64_t *)(stack[base + 25]/argtypeid/))[1][1] = stack[base + 28]/argid*/;
27147	27209	((uint64_t *)(stack[base + 25]/argtypeid/))[1][0] = stack[base + 27]/argtype*/;
27148		- label = 1765LLU; // consequent complete
	27210	+ label = 1770LLU; // consequent complete
27149	27211	break;
27150	27212	}
27151		- case 1764LLU: // alternative
	27213	+ case 1769LLU: // alternative
27152	27214	{
27153	27215	fprintf(stderr, "%s", "INTERNAL ERROR accessing typeid\n");
27154	27216	exit(-1);
27155		- label = 1765LLU; // alternative complete
	27217	+ label = 1770LLU; // alternative complete
27156	27218	break;
27157	27219	}
27158		- case 1765LLU: // completed if-then-else
	27220	+ case 1770LLU: // completed if-then-else
27159	27221	{
27160	27222	((uint64_t *)(stack[base + 22]/param/))[1][1] = stack[base + 26]/mutable*/;
27161	27223	((uint64_t *)(stack[base + 22]/param/))[1][0] = stack[base + 25]/argtypeid*/;
27162		- label = 1763LLU; // consequent complete
	27224	+ label = 1768LLU; // consequent complete
27163	27225	break;
27164	27226	}
27165		- case 1762LLU: // alternative
	27227	+ case 1767LLU: // alternative
27166	27228	{
27167	27229	fprintf(stderr, "%s", "INTERNAL ERROR accessing param\n");
27168	27230	exit(-1);
27169		- label = 1763LLU; // alternative complete
	27231	+ label = 1768LLU; // alternative complete
27170	27232	break;
27171	27233	}
27172		- case 1763LLU: // completed if-then-else
	27234	+ case 1768LLU: // completed if-then-else
27173	27235	{
27174	27236	// call sub from procfn
27175	27237	stack[base + 25LLU] = base;
27176		- stack[base + 26LLU] = 1771LLU;
	27238	+ stack[base + 26LLU] = 1776LLU;
27177	27239	// arguments for call to sub
27178	27240	stack[base + 28LLU] = stack[base + 20]/counter/;
27179	27241	stack[base + 29LLU] = 1LLU;

		@@ -27182,20 +27244,20 @@
27182	27244	label = 18446744073709551604LLU; // sub
27183	27245	break;
27184	27246	}
27185		- case 1771LLU: // return from sub to procfn
	27247	+ case 1776LLU: // return from sub to procfn
27186	27248	{
27187	27249	// copy mutable arguments back from call to sub
27188	27250	// copy back results provided by call to sub
27189	27251	stack[base + 20] = stack[base + 27LLU];
27190	27252	((struct listnode )(stack[base + 23/previous/]))->data = stack[base + 22]/param*/;
27191		- label = 1759LLU; // repeat
	27253	+ label = 1764LLU; // repeat
27192	27254	break;
27193	27255	}
27194		- case 1760LLU: // loop finished
	27256	+ case 1765LLU: // loop finished
27195	27257	{
27196	27258	if(!stack[base + 7]/fnrec/)
27197	27259	{
27198		- label = 1772LLU; // jump to alternative
	27260	+ label = 1777LLU; // jump to alternative
27199	27261	break;
27200	27262	}
27201	27263

		@@ -27202,7 +27264,7 @@
27202	27264	// consequent
27203	27265	// call fnconstr from procfn
27204	27266	stack[base + 20LLU] = base;
27205		- stack[base + 21LLU] = 1774LLU;
	27267	+ stack[base + 21LLU] = 1779LLU;
27206	27268	// arguments for call to fnconstr
27207	27269	stack[base + 22LLU] = stack[base + 9]/fnlabel/;
27208	27270	stack[base + 23LLU] = stack[base + 15]/fnrestypes/;

		@@ -27216,19 +27278,19 @@
27216	27278	label = 366LLU; // fnconstr
27217	27279	break;
27218	27280	}
27219		- case 1774LLU: // return from fnconstr to procfn
	27281	+ case 1779LLU: // return from fnconstr to procfn
27220	27282	{
27221	27283	// copy mutable arguments back from call to fnconstr
27222	27284	stack[base + 0]/fndefs/ = stack[base + 28LLU];
27223		- label = 1773LLU; // consequent complete
	27285	+ label = 1778LLU; // consequent complete
27224	27286	break;
27225	27287	}
27226		- case 1772LLU: // alternative
	27288	+ case 1777LLU: // alternative
27227	27289	{
27228		- label = 1773LLU; // alternative complete
	27290	+ label = 1778LLU; // alternative complete
27229	27291	break;
27230	27292	}
27231		- case 1773LLU: // completed if-then-else
	27293	+ case 1778LLU: // completed if-then-else
27232	27294	{
27233	27295	//#define varcount 20
27234	27296	stack[base + 20/varcount/] = 0; // init

		@@ -27235,7 +27297,7 @@
27235	27297	stack[base + 20]/varcount/ = 0;
27236	27298	// call matchsym from procfn
27237	27299	stack[base + 21LLU] = base;
27238		- stack[base + 22LLU] = 1775LLU;
	27300	+ stack[base + 22LLU] = 1780LLU;
27239	27301	// arguments for call to matchsym
27240	27302	stack[base + 23LLU] = 123LLU;
27241	27303	stack[base + 24LLU] = stack[base + 2]/lookahead/;

		@@ -27244,7 +27306,7 @@
27244	27306	label = 27LLU; // matchsym
27245	27307	break;
27246	27308	}
27247		- case 1775LLU: // return from matchsym to procfn
	27309	+ case 1780LLU: // return from matchsym to procfn
27248	27310	{
27249	27311	// copy mutable arguments back from call to matchsym
27250	27312	stack[base + 2]/lookahead/ = stack[base + 24LLU];

		@@ -27256,7 +27318,7 @@
27256	27318	// call procblock from procfn
27257	27319	newstack[0] = (uint64_t)stack; // backup stack location
27258	27320	newstack[1] = base;
27259		- newstack[2] = 1776LLU;
	27321	+ newstack[2] = 1781LLU;
27260	27322	// arguments for call to procblock
27261	27323	newstack[3LLU] = stack[base + 0]/fndefs/;
27262	27324	newstack[4LLU] = stack[base + 1]/typedefs/;

		@@ -27279,7 +27341,7 @@
27279	27341	label = 961LLU; // procblock
27280	27342	break;
27281	27343	}
27282		- case 1776LLU: // return from procblock to procfn
	27344	+ case 1781LLU: // return from procblock to procfn
27283	27345	{
27284	27346	uint64_t oldstack = (uint64_t )stack[0];
27285	27347	// copy mutable arguments back from call to procblock

		@@ -27296,14 +27358,14 @@
27296	27358	}
27297	27359	Free(119LLU + 1, sizeof(uint64_t), stack);
27298	27360	stack = oldstack;
27299		- label = 1777LLU; // start to repeat
	27361	+ label = 1782LLU; // start to repeat
27300	27362	break;
27301	27363	}
27302		- case 1777LLU: // repeat from here
	27364	+ case 1782LLU: // repeat from here
27303	27365	{
27304	27366	if(!stack[base + 19]/scope/)
27305	27367	{
27306		- label = 1778LLU; // break loop
	27368	+ label = 1783LLU; // break loop
27307	27369	break;
27308	27370	}
27309	27371

		@@ -27314,7 +27376,7 @@
27314	27376	struct listnode list = (struct listnode )stack[base + 19]/scope/;
27315	27377	if(!list)
27316	27378	{
27317		- label = 1779LLU; // jump to alternative
	27379	+ label = 1784LLU; // jump to alternative
27318	27380	break;
27319	27381	}
27320	27382

		@@ -27326,7 +27388,7 @@
27326	27388	}
27327	27389	// call dellet from procfn
27328	27390	stack[base + 23LLU] = base;
27329		- stack[base + 24LLU] = 1781LLU;
	27391	+ stack[base + 24LLU] = 1786LLU;
27330	27392	// arguments for call to dellet
27331	27393	stack[base + 25LLU] = stack[base + 22]/current/;
27332	27394	// set stack-base & callee-address

		@@ -27334,30 +27396,30 @@
27334	27396	label = 166LLU; // dellet
27335	27397	break;
27336	27398	}
27337		- case 1781LLU: // return from dellet to procfn
	27399	+ case 1786LLU: // return from dellet to procfn
27338	27400	{
27339	27401	// copy mutable arguments back from call to dellet
27340		- label = 1780LLU; // consequent complete
	27402	+ label = 1785LLU; // consequent complete
27341	27403	break;
27342	27404	}
27343		- case 1779LLU: // alternative
	27405	+ case 1784LLU: // alternative
27344	27406	{
27345	27407	fprintf(stderr, "%s", "internal error cleaning up lets in block\n");
27346	27408	exit(-1);
27347		- label = 1780LLU; // alternative complete
	27409	+ label = 1785LLU; // alternative complete
27348	27410	break;
27349	27411	}
27350		- case 1780LLU: // completed if-then-else
	27412	+ case 1785LLU: // completed if-then-else
27351	27413	{
27352		- label = 1777LLU; // repeat
	27414	+ label = 1782LLU; // repeat
27353	27415	break;
27354	27416	}
27355		- case 1778LLU: // loop finished
	27417	+ case 1783LLU: // loop finished
27356	27418	{
27357	27419	printf("%s", "\n // return from ");
27358	27420	// call printid from procfn
27359	27421	stack[base + 22LLU] = base;
27360		- stack[base + 23LLU] = 1782LLU;
	27422	+ stack[base + 23LLU] = 1787LLU;
27361	27423	// arguments for call to printid
27362	27424	stack[base + 24LLU] = stack[base + 8]/fnid/;
27363	27425	// set stack-base & callee-address

		@@ -27365,7 +27427,7 @@
27365	27427	label = 18446744073709551588LLU; // printid
27366	27428	break;
27367	27429	}
27368		- case 1782LLU: // return from printid to procfn
	27430	+ case 1787LLU: // return from printid to procfn
27369	27431	{
27370	27432	// copy mutable arguments back from call to printid
27371	27433	printf("%s", "\n label = stack[base - 1];");

		@@ -27376,7 +27438,7 @@
27376	27438	stack[base + 22/isgtr/] = 0; // init
27377	27439	// call gtr from procfn
27378	27440	stack[base + 23LLU] = base;
27379		- stack[base + 24LLU] = 1783LLU;
	27441	+ stack[base + 24LLU] = 1788LLU;
27380	27442	// arguments for call to gtr
27381	27443	stack[base + 26LLU] = stack[base + 12]/fnmaxcount/;
27382	27444	stack[base + 27LLU] = stack[base + 17]/sizelimit/;

		@@ -27385,7 +27447,7 @@
27385	27447	label = 18446744073709551595LLU; // gtr
27386	27448	break;
27387	27449	}
27388		- case 1783LLU: // return from gtr to procfn
	27450	+ case 1788LLU: // return from gtr to procfn
27389	27451	{
27390	27452	// copy mutable arguments back from call to gtr
27391	27453	// copy back results provided by call to gtr

		@@ -27392,7 +27454,7 @@
27392	27454	stack[base + 22] = stack[base + 25LLU];
27393	27455	if(!stack[base + 22]/isgtr/)
27394	27456	{
27395		- label = 1784LLU; // jump to alternative
	27457	+ label = 1789LLU; // jump to alternative
27396	27458	break;
27397	27459	}
27398	27460

		@@ -27400,7 +27462,7 @@
27400	27462	fprintf(stderr, "%s", "function ");
27401	27463	// call reportid from procfn
27402	27464	stack[base + 23LLU] = base;
27403		- stack[base + 24LLU] = 1786LLU;
	27465	+ stack[base + 24LLU] = 1791LLU;
27404	27466	// arguments for call to reportid
27405	27467	stack[base + 25LLU] = stack[base + 8]/fnid/;
27406	27468	// set stack-base & callee-address

		@@ -27408,13 +27470,13 @@
27408	27470	label = 18446744073709551587LLU; // reportid
27409	27471	break;
27410	27472	}
27411		- case 1786LLU: // return from reportid to procfn
	27473	+ case 1791LLU: // return from reportid to procfn
27412	27474	{
27413	27475	// copy mutable arguments back from call to reportid
27414	27476	fprintf(stderr, "%s", " size ");
27415	27477	// call reportnr from procfn
27416	27478	stack[base + 23LLU] = base;
27417		- stack[base + 24LLU] = 1787LLU;
	27479	+ stack[base + 24LLU] = 1792LLU;
27418	27480	// arguments for call to reportnr
27419	27481	stack[base + 25LLU] = stack[base + 12]/fnmaxcount/;
27420	27482	// set stack-base & callee-address

		@@ -27422,13 +27484,13 @@
27422	27484	label = 18446744073709551590LLU; // reportnr
27423	27485	break;
27424	27486	}
27425		- case 1787LLU: // return from reportnr to procfn
	27487	+ case 1792LLU: // return from reportnr to procfn
27426	27488	{
27427	27489	// copy mutable arguments back from call to reportnr
27428	27490	fprintf(stderr, "%s", " exceeds function memory ");
27429	27491	// call reportnr from procfn
27430	27492	stack[base + 23LLU] = base;
27431		- stack[base + 24LLU] = 1788LLU;
	27493	+ stack[base + 24LLU] = 1793LLU;
27432	27494	// arguments for call to reportnr
27433	27495	stack[base + 25LLU] = stack[base + 17]/sizelimit/;
27434	27496	// set stack-base & callee-address

		@@ -27436,36 +27498,36 @@
27436	27498	label = 18446744073709551590LLU; // reportnr
27437	27499	break;
27438	27500	}
27439		- case 1788LLU: // return from reportnr to procfn
	27501	+ case 1793LLU: // return from reportnr to procfn
27440	27502	{
27441	27503	// copy mutable arguments back from call to reportnr
27442	27504	fprintf(stderr, "%s", "\n");
27443	27505	exit(-1);
27444		- label = 1785LLU; // consequent complete
	27506	+ label = 1790LLU; // consequent complete
27445	27507	break;
27446	27508	}
27447		- case 1784LLU: // alternative
	27509	+ case 1789LLU: // alternative
27448	27510	{
27449		- label = 1785LLU; // alternative complete
	27511	+ label = 1790LLU; // alternative complete
27450	27512	break;
27451	27513	}
27452		- case 1785LLU: // completed if-then-else
	27514	+ case 1790LLU: // completed if-then-else
27453	27515	{
27454	27516	if(!stack[base + 7]/fnrec/)
27455	27517	{
27456		- label = 1789LLU; // jump to alternative
	27518	+ label = 1794LLU; // jump to alternative
27457	27519	break;
27458	27520	}
27459	27521
27460	27522	// consequent
27461		- label = 1790LLU; // consequent complete
	27523	+ label = 1795LLU; // consequent complete
27462	27524	break;
27463	27525	}
27464		- case 1789LLU: // alternative
	27526	+ case 1794LLU: // alternative
27465	27527	{
27466	27528	// call fnconstr from procfn
27467	27529	stack[base + 23LLU] = base;
27468		- stack[base + 24LLU] = 1791LLU;
	27530	+ stack[base + 24LLU] = 1796LLU;
27469	27531	// arguments for call to fnconstr
27470	27532	stack[base + 25LLU] = stack[base + 9]/fnlabel/;
27471	27533	stack[base + 26LLU] = stack[base + 15]/fnrestypes/;

		@@ -27479,14 +27541,14 @@
27479	27541	label = 366LLU; // fnconstr
27480	27542	break;
27481	27543	}
27482		- case 1791LLU: // return from fnconstr to procfn
	27544	+ case 1796LLU: // return from fnconstr to procfn
27483	27545	{
27484	27546	// copy mutable arguments back from call to fnconstr
27485	27547	stack[base + 0]/fndefs/ = stack[base + 31LLU];
27486		- label = 1790LLU; // alternative complete
	27548	+ label = 1795LLU; // alternative complete
27487	27549	break;
27488	27550	}
27489		- case 1790LLU: // completed if-then-else
	27551	+ case 1795LLU: // completed if-then-else
27490	27552	{
27491	27553	// return from procfn
27492	27554	label = stack[base - 1];

		@@ -27493,7 +27555,7 @@
27493	27555	base = stack[base - 2];
27494	27556	break;
27495	27557	}
27496		- case 1792LLU: // emitexit
	27558	+ case 1797LLU: // emitexit
27497	27559	{
27498	27560	//#define arg0 0
27499	27561	printf("%s", "\n default:");

		@@ -27509,7 +27571,7 @@
27509	27571	stack[base + 1/calleedef/] = 0; // init
27510	27572	// call findfn from emitexit
27511	27573	stack[base + 2LLU] = base;
27512		- stack[base + 3LLU] = 1793LLU;
	27574	+ stack[base + 3LLU] = 1798LLU;
27513	27575	// arguments for call to findfn
27514	27576	stack[base + 5LLU] = stack[base + 0]/fndefs/;
27515	27577	stack[base + 6LLU] = 728618386900123648LLU;

		@@ -27518,7 +27580,7 @@
27518	27580	label = 386LLU; // findfn
27519	27581	break;
27520	27582	}
27521		- case 1793LLU: // return from findfn to emitexit
	27583	+ case 1798LLU: // return from findfn to emitexit
27522	27584	{
27523	27585	// copy mutable arguments back from call to findfn
27524	27586	// copy back results provided by call to findfn

		@@ -27525,7 +27587,7 @@
27525	27587	stack[base + 1] = stack[base + 4LLU];
27526	27588	if(/fndef/0 != ((uint64_t )(stack[base + 1]/calleedef*/))[0])
27527	27589	{
27528		- label = 1794LLU; // jump to alternative
	27590	+ label = 1799LLU; // jump to alternative
27529	27591	break;
27530	27592	}
27531	27593

		@@ -27559,7 +27621,7 @@
27559	27621	stack[base + 10]/memorysize/ = 2;
27560	27622	// call add from emitexit
27561	27623	stack[base + 11LLU] = base;
27562		- stack[base + 12LLU] = 1796LLU;
	27624	+ stack[base + 12LLU] = 1801LLU;
27563	27625	// arguments for call to add
27564	27626	stack[base + 14LLU] = stack[base + 10]/memorysize/;
27565	27627	stack[base + 15LLU] = stack[base + 8]/cerescount/;

		@@ -27568,7 +27630,7 @@
27568	27630	label = 18446744073709551605LLU; // add
27569	27631	break;
27570	27632	}
27571		- case 1796LLU: // return from add to emitexit
	27633	+ case 1801LLU: // return from add to emitexit
27572	27634	{
27573	27635	// copy mutable arguments back from call to add
27574	27636	// copy back results provided by call to add

		@@ -27575,7 +27637,7 @@
27575	27637	stack[base + 10] = stack[base + 13LLU];
27576	27638	// call add from emitexit
27577	27639	stack[base + 11LLU] = base;
27578		- stack[base + 12LLU] = 1797LLU;
	27640	+ stack[base + 12LLU] = 1802LLU;
27579	27641	// arguments for call to add
27580	27642	stack[base + 14LLU] = stack[base + 10]/memorysize/;
27581	27643	stack[base + 15LLU] = stack[base + 9]/ceargcount/;

		@@ -27584,7 +27646,7 @@
27584	27646	label = 18446744073709551605LLU; // add
27585	27647	break;
27586	27648	}
27587		- case 1797LLU: // return from add to emitexit
	27649	+ case 1802LLU: // return from add to emitexit
27588	27650	{
27589	27651	// copy mutable arguments back from call to add
27590	27652	// copy back results provided by call to add

		@@ -27591,7 +27653,7 @@
27591	27653	stack[base + 10] = stack[base + 13LLU];
27592	27654	// call add from emitexit
27593	27655	stack[base + 11LLU] = base;
27594		- stack[base + 12LLU] = 1798LLU;
	27656	+ stack[base + 12LLU] = 1803LLU;
27595	27657	// arguments for call to add
27596	27658	stack[base + 14LLU] = stack[base + 10]/memorysize/;
27597	27659	stack[base + 15LLU] = stack[base + 5]/cemaxcount/;

		@@ -27600,7 +27662,7 @@
27600	27662	label = 18446744073709551605LLU; // add
27601	27663	break;
27602	27664	}
27603		- case 1798LLU: // return from add to emitexit
	27665	+ case 1803LLU: // return from add to emitexit
27604	27666	{
27605	27667	// copy mutable arguments back from call to add
27606	27668	// copy back results provided by call to add

		@@ -27610,7 +27672,7 @@
27610	27672	printf("%s", "\n uint64_t memory = (uint64_t )Calloc(");
27611	27673	// call printnr from emitexit
27612	27674	stack[base + 11LLU] = base;
27613		- stack[base + 12LLU] = 1799LLU;
	27675	+ stack[base + 12LLU] = 1804LLU;
27614	27676	// arguments for call to printnr
27615	27677	stack[base + 13LLU] = stack[base + 10]/memorysize/;
27616	27678	// set stack-base & callee-address

		@@ -27618,7 +27680,7 @@
27618	27680	label = 18446744073709551591LLU; // printnr
27619	27681	break;
27620	27682	}
27621		- case 1799LLU: // return from printnr to emitexit
	27683	+ case 1804LLU: // return from printnr to emitexit
27622	27684	{
27623	27685	// copy mutable arguments back from call to printnr
27624	27686	printf("%s", "LLU + 1, sizeof(uint64_t));");

		@@ -27625,7 +27687,7 @@
27625	27687	printf("%s", "\n memory[");
27626	27688	// call printnr from emitexit
27627	27689	stack[base + 11LLU] = base;
27628		- stack[base + 12LLU] = 1800LLU;
	27690	+ stack[base + 12LLU] = 1805LLU;
27629	27691	// arguments for call to printnr
27630	27692	stack[base + 13LLU] = stack[base + 10]/memorysize/;
27631	27693	// set stack-base & callee-address

		@@ -27633,7 +27695,7 @@
27633	27695	label = 18446744073709551591LLU; // printnr
27634	27696	break;
27635	27697	}
27636		- case 1800LLU: // return from printnr to emitexit
	27698	+ case 1805LLU: // return from printnr to emitexit
27637	27699	{
27638	27700	// copy mutable arguments back from call to printnr
27639	27701	printf("%s", "LLU] = 9876543210LLU; // overflow-marker");

		@@ -27641,7 +27703,7 @@
27641	27703	printf("%s", "\n if(memory[");
27642	27704	// call printnr from emitexit
27643	27705	stack[base + 11LLU] = base;
27644		- stack[base + 12LLU] = 1801LLU;
	27706	+ stack[base + 12LLU] = 1806LLU;
27645	27707	// arguments for call to printnr
27646	27708	stack[base + 13LLU] = stack[base + 10]/memorysize/;
27647	27709	// set stack-base & callee-address

		@@ -27649,7 +27711,7 @@
27649	27711	label = 18446744073709551591LLU; // printnr
27650	27712	break;
27651	27713	}
27652		- case 1801LLU: // return from printnr to emitexit
	27714	+ case 1806LLU: // return from printnr to emitexit
27653	27715	{
27654	27716	// copy mutable arguments back from call to printnr
27655	27717	printf("%s", "LLU] != 9876543210LLU)");

		@@ -27660,7 +27722,7 @@
27660	27722	printf("%s", "\n Free(");
27661	27723	// call printnr from emitexit
27662	27724	stack[base + 11LLU] = base;
27663		- stack[base + 12LLU] = 1802LLU;
	27725	+ stack[base + 12LLU] = 1807LLU;
27664	27726	// arguments for call to printnr
27665	27727	stack[base + 13LLU] = stack[base + 10]/memorysize/;
27666	27728	// set stack-base & callee-address

		@@ -27668,7 +27730,7 @@
27668	27730	label = 18446744073709551591LLU; // printnr
27669	27731	break;
27670	27732	}
27671		- case 1802LLU: // return from printnr to emitexit
	27733	+ case 1807LLU: // return from printnr to emitexit
27672	27734	{
27673	27735	// copy mutable arguments back from call to printnr
27674	27736	printf("%s", "LLU + 1, sizeof(uint64_t), memory);");

		@@ -27682,15 +27744,15 @@
27682	27744	((uint64_t *)(stack[base + 1]/calleedef/))[1][2] = stack[base + 4]/ceargtypes*/;
27683	27745	((uint64_t *)(stack[base + 1]/calleedef/))[1][1] = stack[base + 3]/cerestypes*/;
27684	27746	((uint64_t *)(stack[base + 1]/calleedef/))[1][0] = stack[base + 2]/celabel*/;
27685		- label = 1795LLU; // consequent complete
	27747	+ label = 1800LLU; // consequent complete
27686	27748	break;
27687	27749	}
27688		- case 1794LLU: // alternative
	27750	+ case 1799LLU: // alternative
27689	27751	{
27690		- label = 1795LLU; // alternative complete
	27752	+ label = 1800LLU; // alternative complete
27691	27753	break;
27692	27754	}
27693		- case 1795LLU: // completed if-then-else
	27755	+ case 1800LLU: // completed if-then-else
27694	27756	{
27695	27757	// return from emitexit
27696	27758	label = stack[base - 1];

		@@ -27702,7 +27764,7 @@
27702	27764	//#define res0 0
27703	27765	// call emitinit from main
27704	27766	stack[base + 1LLU] = base;
27705		- stack[base + 2LLU] = 1803LLU;
	27767	+ stack[base + 2LLU] = 1808LLU;
27706	27768	// arguments for call to emitinit
27707	27769	// set stack-base & callee-address
27708	27770	base += 3LLU;

		@@ -27709,7 +27771,7 @@
27709	27771	label = 11LLU; // emitinit
27710	27772	break;
27711	27773	}
27712		- case 1803LLU: // return from emitinit to main
	27774	+ case 1808LLU: // return from emitinit to main
27713	27775	{
27714	27776	// copy mutable arguments back from call to emitinit
27715	27777	//#define fndefs 1

		@@ -27720,7 +27782,7 @@
27720	27782	stack[base + 2]/defcount/ = 0;
27721	27783	// call emitcase from main
27722	27784	stack[base + 3LLU] = base;
27723		- stack[base + 4LLU] = 1804LLU;
	27785	+ stack[base + 4LLU] = 1809LLU;
27724	27786	// arguments for call to emitcase
27725	27787	stack[base + 5LLU] = 0LLU;
27726	27788	stack[base + 6LLU] = 589327973546580007LLU;

		@@ -27729,7 +27791,7 @@
27729	27791	label = 405LLU; // emitcase
27730	27792	break;
27731	27793	}
27732		- case 1804LLU: // return from emitcase to main
	27794	+ case 1809LLU: // return from emitcase to main
27733	27795	{
27734	27796	// copy mutable arguments back from call to emitcase
27735	27797	printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR, 0-LABEL\\n\");");

		@@ -27736,7 +27798,7 @@
27736	27798	printf("%s", "\n exit(-1);");
27737	27799	// call register from main
27738	27800	stack[base + 3LLU] = base;
27739		- stack[base + 4LLU] = 1805LLU;
	27801	+ stack[base + 4LLU] = 1810LLU;
27740	27802	// arguments for call to register
27741	27803	stack[base + 5LLU] = 1LLU;
27742	27804	stack[base + 6LLU] = 1LLU;

		@@ -27749,7 +27811,7 @@
27749	27811	label = 409LLU; // register
27750	27812	break;
27751	27813	}
27752		- case 1805LLU: // return from register to main
	27814	+ case 1810LLU: // return from register to main
27753	27815	{
27754	27816	// copy mutable arguments back from call to register
27755	27817	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27757,7 +27819,7 @@
27757	27819	printf("%s", "\n stack[base + 0] = !stack[base + 1];");
27758	27820	// call register from main
27759	27821	stack[base + 3LLU] = base;
27760		- stack[base + 4LLU] = 1806LLU;
	27822	+ stack[base + 4LLU] = 1811LLU;
27761	27823	// arguments for call to register
27762	27824	stack[base + 5LLU] = 1LLU;
27763	27825	stack[base + 6LLU] = 1LLU;

		@@ -27770,7 +27832,7 @@
27770	27832	label = 409LLU; // register
27771	27833	break;
27772	27834	}
27773		- case 1806LLU: // return from register to main
	27835	+ case 1811LLU: // return from register to main
27774	27836	{
27775	27837	// copy mutable arguments back from call to register
27776	27838	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27778,7 +27840,7 @@
27778	27840	printf("%s", "\n stack[base + 0] = ~stack[base + 1];");
27779	27841	// call register from main
27780	27842	stack[base + 3LLU] = base;
27781		- stack[base + 4LLU] = 1807LLU;
	27843	+ stack[base + 4LLU] = 1812LLU;
27782	27844	// arguments for call to register
27783	27845	stack[base + 5LLU] = 1LLU;
27784	27846	stack[base + 6LLU] = 2LLU;

		@@ -27791,7 +27853,7 @@
27791	27853	label = 409LLU; // register
27792	27854	break;
27793	27855	}
27794		- case 1807LLU: // return from register to main
	27856	+ case 1812LLU: // return from register to main
27795	27857	{
27796	27858	// copy mutable arguments back from call to register
27797	27859	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27799,7 +27861,7 @@
27799	27861	printf("%s", "\n stack[base + 0] = stack[base + 1] && stack[base + 2];");
27800	27862	// call register from main
27801	27863	stack[base + 3LLU] = base;
27802		- stack[base + 4LLU] = 1808LLU;
	27864	+ stack[base + 4LLU] = 1813LLU;
27803	27865	// arguments for call to register
27804	27866	stack[base + 5LLU] = 1LLU;
27805	27867	stack[base + 6LLU] = 2LLU;

		@@ -27812,7 +27874,7 @@
27812	27874	label = 409LLU; // register
27813	27875	break;
27814	27876	}
27815		- case 1808LLU: // return from register to main
	27877	+ case 1813LLU: // return from register to main
27816	27878	{
27817	27879	// copy mutable arguments back from call to register
27818	27880	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27820,7 +27882,7 @@
27820	27882	printf("%s", "\n stack[base + 0] = stack[base + 1] & stack[base + 2];");
27821	27883	// call register from main
27822	27884	stack[base + 3LLU] = base;
27823		- stack[base + 4LLU] = 1809LLU;
	27885	+ stack[base + 4LLU] = 1814LLU;
27824	27886	// arguments for call to register
27825	27887	stack[base + 5LLU] = 1LLU;
27826	27888	stack[base + 6LLU] = 2LLU;

		@@ -27833,7 +27895,7 @@
27833	27895	label = 409LLU; // register
27834	27896	break;
27835	27897	}
27836		- case 1809LLU: // return from register to main
	27898	+ case 1814LLU: // return from register to main
27837	27899	{
27838	27900	// copy mutable arguments back from call to register
27839	27901	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27841,7 +27903,7 @@
27841	27903	printf("%s", "\n stack[base + 0] = stack[base + 1] \|\| stack[base + 2];");
27842	27904	// call register from main
27843	27905	stack[base + 3LLU] = base;
27844		- stack[base + 4LLU] = 1810LLU;
	27906	+ stack[base + 4LLU] = 1815LLU;
27845	27907	// arguments for call to register
27846	27908	stack[base + 5LLU] = 1LLU;
27847	27909	stack[base + 6LLU] = 2LLU;

		@@ -27854,7 +27916,7 @@
27854	27916	label = 409LLU; // register
27855	27917	break;
27856	27918	}
27857		- case 1810LLU: // return from register to main
	27919	+ case 1815LLU: // return from register to main
27858	27920	{
27859	27921	// copy mutable arguments back from call to register
27860	27922	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27862,7 +27924,7 @@
27862	27924	printf("%s", "\n stack[base + 0] = stack[base + 1] \| stack[base + 2];");
27863	27925	// call register from main
27864	27926	stack[base + 3LLU] = base;
27865		- stack[base + 4LLU] = 1811LLU;
	27927	+ stack[base + 4LLU] = 1816LLU;
27866	27928	// arguments for call to register
27867	27929	stack[base + 5LLU] = 1LLU;
27868	27930	stack[base + 6LLU] = 2LLU;

		@@ -27875,7 +27937,7 @@
27875	27937	label = 409LLU; // register
27876	27938	break;
27877	27939	}
27878		- case 1811LLU: // return from register to main
	27940	+ case 1816LLU: // return from register to main
27879	27941	{
27880	27942	// copy mutable arguments back from call to register
27881	27943	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27883,7 +27945,7 @@
27883	27945	printf("%s", "\n stack[base + 0] = stack[base + 1] << stack[base + 2];");
27884	27946	// call register from main
27885	27947	stack[base + 3LLU] = base;
27886		- stack[base + 4LLU] = 1812LLU;
	27948	+ stack[base + 4LLU] = 1817LLU;
27887	27949	// arguments for call to register
27888	27950	stack[base + 5LLU] = 1LLU;
27889	27951	stack[base + 6LLU] = 2LLU;

		@@ -27896,7 +27958,7 @@
27896	27958	label = 409LLU; // register
27897	27959	break;
27898	27960	}
27899		- case 1812LLU: // return from register to main
	27961	+ case 1817LLU: // return from register to main
27900	27962	{
27901	27963	// copy mutable arguments back from call to register
27902	27964	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27904,7 +27966,7 @@
27904	27966	printf("%s", "\n stack[base + 0] = stack[base + 1] >> stack[base + 2];");
27905	27967	// call register from main
27906	27968	stack[base + 3LLU] = base;
27907		- stack[base + 4LLU] = 1813LLU;
	27969	+ stack[base + 4LLU] = 1818LLU;
27908	27970	// arguments for call to register
27909	27971	stack[base + 5LLU] = 1LLU;
27910	27972	stack[base + 6LLU] = 2LLU;

		@@ -27917,7 +27979,7 @@
27917	27979	label = 409LLU; // register
27918	27980	break;
27919	27981	}
27920		- case 1813LLU: // return from register to main
	27982	+ case 1818LLU: // return from register to main
27921	27983	{
27922	27984	// copy mutable arguments back from call to register
27923	27985	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27925,7 +27987,7 @@
27925	27987	printf("%s", "\n stack[base + 0] = stack[base + 1] < stack[base + 2] ? stack[base + 1] : stack[base + 2];");
27926	27988	// call register from main
27927	27989	stack[base + 3LLU] = base;
27928		- stack[base + 4LLU] = 1814LLU;
	27990	+ stack[base + 4LLU] = 1819LLU;
27929	27991	// arguments for call to register
27930	27992	stack[base + 5LLU] = 1LLU;
27931	27993	stack[base + 6LLU] = 2LLU;

		@@ -27938,7 +28000,7 @@
27938	28000	label = 409LLU; // register
27939	28001	break;
27940	28002	}
27941		- case 1814LLU: // return from register to main
	28003	+ case 1819LLU: // return from register to main
27942	28004	{
27943	28005	// copy mutable arguments back from call to register
27944	28006	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27946,7 +28008,7 @@
27946	28008	printf("%s", "\n stack[base + 0] = stack[base + 1] > stack[base + 2] ? stack[base + 1] : stack[base + 2];");
27947	28009	// call register from main
27948	28010	stack[base + 3LLU] = base;
27949		- stack[base + 4LLU] = 1815LLU;
	28011	+ stack[base + 4LLU] = 1820LLU;
27950	28012	// arguments for call to register
27951	28013	stack[base + 5LLU] = 1LLU;
27952	28014	stack[base + 6LLU] = 2LLU;

		@@ -27959,7 +28021,7 @@
27959	28021	label = 409LLU; // register
27960	28022	break;
27961	28023	}
27962		- case 1815LLU: // return from register to main
	28024	+ case 1820LLU: // return from register to main
27963	28025	{
27964	28026	// copy mutable arguments back from call to register
27965	28027	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27967,7 +28029,7 @@
27967	28029	printf("%s", "\n stack[base + 0] = stack[base + 1] + stack[base + 2];");
27968	28030	// call register from main
27969	28031	stack[base + 3LLU] = base;
27970		- stack[base + 4LLU] = 1816LLU;
	28032	+ stack[base + 4LLU] = 1821LLU;
27971	28033	// arguments for call to register
27972	28034	stack[base + 5LLU] = 1LLU;
27973	28035	stack[base + 6LLU] = 2LLU;

		@@ -27980,7 +28042,7 @@
27980	28042	label = 409LLU; // register
27981	28043	break;
27982	28044	}
27983		- case 1816LLU: // return from register to main
	28045	+ case 1821LLU: // return from register to main
27984	28046	{
27985	28047	// copy mutable arguments back from call to register
27986	28048	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -27988,7 +28050,7 @@
27988	28050	printf("%s", "\n stack[base + 0] = stack[base + 1] - stack[base + 2];");
27989	28051	// call register from main
27990	28052	stack[base + 3LLU] = base;
27991		- stack[base + 4LLU] = 1817LLU;
	28053	+ stack[base + 4LLU] = 1822LLU;
27992	28054	// arguments for call to register
27993	28055	stack[base + 5LLU] = 1LLU;
27994	28056	stack[base + 6LLU] = 2LLU;

		@@ -28001,7 +28063,7 @@
28001	28063	label = 409LLU; // register
28002	28064	break;
28003	28065	}
28004		- case 1817LLU: // return from register to main
	28066	+ case 1822LLU: // return from register to main
28005	28067	{
28006	28068	// copy mutable arguments back from call to register
28007	28069	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28009,7 +28071,7 @@
28009	28071	printf("%s", "\n stack[base + 0] = stack[base + 1] * stack[base + 2];");
28010	28072	// call register from main
28011	28073	stack[base + 3LLU] = base;
28012		- stack[base + 4LLU] = 1818LLU;
	28074	+ stack[base + 4LLU] = 1823LLU;
28013	28075	// arguments for call to register
28014	28076	stack[base + 5LLU] = 1LLU;
28015	28077	stack[base + 6LLU] = 2LLU;

		@@ -28022,7 +28084,7 @@
28022	28084	label = 409LLU; // register
28023	28085	break;
28024	28086	}
28025		- case 1818LLU: // return from register to main
	28087	+ case 1823LLU: // return from register to main
28026	28088	{
28027	28089	// copy mutable arguments back from call to register
28028	28090	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28030,7 +28092,7 @@
28030	28092	printf("%s", "\n stack[base + 0] = stack[base + 1] / stack[base + 2];");
28031	28093	// call register from main
28032	28094	stack[base + 3LLU] = base;
28033		- stack[base + 4LLU] = 1819LLU;
	28095	+ stack[base + 4LLU] = 1824LLU;
28034	28096	// arguments for call to register
28035	28097	stack[base + 5LLU] = 1LLU;
28036	28098	stack[base + 6LLU] = 2LLU;

		@@ -28043,7 +28105,7 @@
28043	28105	label = 409LLU; // register
28044	28106	break;
28045	28107	}
28046		- case 1819LLU: // return from register to main
	28108	+ case 1824LLU: // return from register to main
28047	28109	{
28048	28110	// copy mutable arguments back from call to register
28049	28111	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28051,7 +28113,7 @@
28051	28113	printf("%s", "\n stack[base + 0] = stack[base + 1] % stack[base + 2];");
28052	28114	// call register from main
28053	28115	stack[base + 3LLU] = base;
28054		- stack[base + 4LLU] = 1820LLU;
	28116	+ stack[base + 4LLU] = 1825LLU;
28055	28117	// arguments for call to register
28056	28118	stack[base + 5LLU] = 1LLU;
28057	28119	stack[base + 6LLU] = 2LLU;

		@@ -28064,7 +28126,7 @@
28064	28126	label = 409LLU; // register
28065	28127	break;
28066	28128	}
28067		- case 1820LLU: // return from register to main
	28129	+ case 1825LLU: // return from register to main
28068	28130	{
28069	28131	// copy mutable arguments back from call to register
28070	28132	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28072,7 +28134,7 @@
28072	28134	printf("%s", "\n stack[base + 0] = stack[base + 1] == stack[base + 2];");
28073	28135	// call register from main
28074	28136	stack[base + 3LLU] = base;
28075		- stack[base + 4LLU] = 1821LLU;
	28137	+ stack[base + 4LLU] = 1826LLU;
28076	28138	// arguments for call to register
28077	28139	stack[base + 5LLU] = 1LLU;
28078	28140	stack[base + 6LLU] = 2LLU;

		@@ -28085,7 +28147,7 @@
28085	28147	label = 409LLU; // register
28086	28148	break;
28087	28149	}
28088		- case 1821LLU: // return from register to main
	28150	+ case 1826LLU: // return from register to main
28089	28151	{
28090	28152	// copy mutable arguments back from call to register
28091	28153	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28093,7 +28155,7 @@
28093	28155	printf("%s", "\n stack[base + 0] = stack[base + 1] != stack[base + 2];");
28094	28156	// call register from main
28095	28157	stack[base + 3LLU] = base;
28096		- stack[base + 4LLU] = 1822LLU;
	28158	+ stack[base + 4LLU] = 1827LLU;
28097	28159	// arguments for call to register
28098	28160	stack[base + 5LLU] = 1LLU;
28099	28161	stack[base + 6LLU] = 2LLU;

		@@ -28106,7 +28168,7 @@
28106	28168	label = 409LLU; // register
28107	28169	break;
28108	28170	}
28109		- case 1822LLU: // return from register to main
	28171	+ case 1827LLU: // return from register to main
28110	28172	{
28111	28173	// copy mutable arguments back from call to register
28112	28174	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28114,7 +28176,7 @@
28114	28176	printf("%s", "\n stack[base + 0] = stack[base + 1] <= stack[base + 2];");
28115	28177	// call register from main
28116	28178	stack[base + 3LLU] = base;
28117		- stack[base + 4LLU] = 1823LLU;
	28179	+ stack[base + 4LLU] = 1828LLU;
28118	28180	// arguments for call to register
28119	28181	stack[base + 5LLU] = 1LLU;
28120	28182	stack[base + 6LLU] = 2LLU;

		@@ -28127,7 +28189,7 @@
28127	28189	label = 409LLU; // register
28128	28190	break;
28129	28191	}
28130		- case 1823LLU: // return from register to main
	28192	+ case 1828LLU: // return from register to main
28131	28193	{
28132	28194	// copy mutable arguments back from call to register
28133	28195	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28135,7 +28197,7 @@
28135	28197	printf("%s", "\n stack[base + 0] = stack[base + 1] < stack[base + 2];");
28136	28198	// call register from main
28137	28199	stack[base + 3LLU] = base;
28138		- stack[base + 4LLU] = 1824LLU;
	28200	+ stack[base + 4LLU] = 1829LLU;
28139	28201	// arguments for call to register
28140	28202	stack[base + 5LLU] = 1LLU;
28141	28203	stack[base + 6LLU] = 2LLU;

		@@ -28148,7 +28210,7 @@
28148	28210	label = 409LLU; // register
28149	28211	break;
28150	28212	}
28151		- case 1824LLU: // return from register to main
	28213	+ case 1829LLU: // return from register to main
28152	28214	{
28153	28215	// copy mutable arguments back from call to register
28154	28216	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28156,7 +28218,7 @@
28156	28218	printf("%s", "\n stack[base + 0] = stack[base + 1] >= stack[base + 2];");
28157	28219	// call register from main
28158	28220	stack[base + 3LLU] = base;
28159		- stack[base + 4LLU] = 1825LLU;
	28221	+ stack[base + 4LLU] = 1830LLU;
28160	28222	// arguments for call to register
28161	28223	stack[base + 5LLU] = 1LLU;
28162	28224	stack[base + 6LLU] = 2LLU;

		@@ -28169,7 +28231,7 @@
28169	28231	label = 409LLU; // register
28170	28232	break;
28171	28233	}
28172		- case 1825LLU: // return from register to main
	28234	+ case 1830LLU: // return from register to main
28173	28235	{
28174	28236	// copy mutable arguments back from call to register
28175	28237	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28177,7 +28239,7 @@
28177	28239	printf("%s", "\n stack[base + 0] = stack[base + 1] > stack[base + 2];");
28178	28240	// call register from main
28179	28241	stack[base + 3LLU] = base;
28180		- stack[base + 4LLU] = 1826LLU;
	28242	+ stack[base + 4LLU] = 1831LLU;
28181	28243	// arguments for call to register
28182	28244	stack[base + 5LLU] = 1LLU;
28183	28245	stack[base + 6LLU] = 0LLU;

		@@ -28190,7 +28252,7 @@
28190	28252	label = 409LLU; // register
28191	28253	break;
28192	28254	}
28193		- case 1826LLU: // return from register to main
	28255	+ case 1831LLU: // return from register to main
28194	28256	{
28195	28257	// copy mutable arguments back from call to register
28196	28258	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28198,7 +28260,7 @@
28198	28260	printf("%s", "\n stack[base + 0] = (uint64_t)getchar();");
28199	28261	// call register from main
28200	28262	stack[base + 3LLU] = base;
28201		- stack[base + 4LLU] = 1827LLU;
	28263	+ stack[base + 4LLU] = 1832LLU;
28202	28264	// arguments for call to register
28203	28265	stack[base + 5LLU] = 0LLU;
28204	28266	stack[base + 6LLU] = 1LLU;

		@@ -28211,7 +28273,7 @@
28211	28273	label = 409LLU; // register
28212	28274	break;
28213	28275	}
28214		- case 1827LLU: // return from register to main
	28276	+ case 1832LLU: // return from register to main
28215	28277	{
28216	28278	// copy mutable arguments back from call to register
28217	28279	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28219,7 +28281,7 @@
28219	28281	printf("%s", "\n printf(\"%c\", (char)stack[base + 0]);");
28220	28282	// call register from main
28221	28283	stack[base + 3LLU] = base;
28222		- stack[base + 4LLU] = 1828LLU;
	28284	+ stack[base + 4LLU] = 1833LLU;
28223	28285	// arguments for call to register
28224	28286	stack[base + 5LLU] = 0LLU;
28225	28287	stack[base + 6LLU] = 1LLU;

		@@ -28232,7 +28294,7 @@
28232	28294	label = 409LLU; // register
28233	28295	break;
28234	28296	}
28235		- case 1828LLU: // return from register to main
	28297	+ case 1833LLU: // return from register to main
28236	28298	{
28237	28299	// copy mutable arguments back from call to register
28238	28300	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28240,7 +28302,7 @@
28240	28302	printf("%s", "\n fprintf(stderr, \"%c\", (char)stack[base + 0]);");
28241	28303	// call register from main
28242	28304	stack[base + 3LLU] = base;
28243		- stack[base + 4LLU] = 1829LLU;
	28305	+ stack[base + 4LLU] = 1834LLU;
28244	28306	// arguments for call to register
28245	28307	stack[base + 5LLU] = 0LLU;
28246	28308	stack[base + 6LLU] = 1LLU;

		@@ -28253,7 +28315,7 @@
28253	28315	label = 409LLU; // register
28254	28316	break;
28255	28317	}
28256		- case 1829LLU: // return from register to main
	28318	+ case 1834LLU: // return from register to main
28257	28319	{
28258	28320	// copy mutable arguments back from call to register
28259	28321	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28261,7 +28323,7 @@
28261	28323	printf("%s", "\n printf(\"%llu\", (long long unsigned int)stack[base + 0]);");
28262	28324	// call register from main
28263	28325	stack[base + 3LLU] = base;
28264		- stack[base + 4LLU] = 1830LLU;
	28326	+ stack[base + 4LLU] = 1835LLU;
28265	28327	// arguments for call to register
28266	28328	stack[base + 5LLU] = 0LLU;
28267	28329	stack[base + 6LLU] = 1LLU;

		@@ -28274,7 +28336,7 @@
28274	28336	label = 409LLU; // register
28275	28337	break;
28276	28338	}
28277		- case 1830LLU: // return from register to main
	28339	+ case 1835LLU: // return from register to main
28278	28340	{
28279	28341	// copy mutable arguments back from call to register
28280	28342	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28282,7 +28344,7 @@
28282	28344	printf("%s", "\n fprintf(stderr, \"%llu\", (long long unsigned int)stack[base + 0]);");
28283	28345	// call register from main
28284	28346	stack[base + 3LLU] = base;
28285		- stack[base + 4LLU] = 1831LLU;
	28347	+ stack[base + 4LLU] = 1836LLU;
28286	28348	// arguments for call to register
28287	28349	stack[base + 5LLU] = 2LLU;
28288	28350	stack[base + 6LLU] = 1LLU;

		@@ -28295,7 +28357,7 @@
28295	28357	label = 409LLU; // register
28296	28358	break;
28297	28359	}
28298		- case 1831LLU: // return from register to main
	28360	+ case 1836LLU: // return from register to main
28299	28361	{
28300	28362	// copy mutable arguments back from call to register
28301	28363	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28312,7 +28374,7 @@
28312	28374	printf("%s", "\n stack[base + 1] = (uint64_t)lookahead;");
28313	28375	// call register from main
28314	28376	stack[base + 3LLU] = base;
28315		- stack[base + 4LLU] = 1832LLU;
	28377	+ stack[base + 4LLU] = 1837LLU;
28316	28378	// arguments for call to register
28317	28379	stack[base + 5LLU] = 0LLU;
28318	28380	stack[base + 6LLU] = 1LLU;

		@@ -28325,7 +28387,7 @@
28325	28387	label = 409LLU; // register
28326	28388	break;
28327	28389	}
28328		- case 1832LLU: // return from register to main
	28390	+ case 1837LLU: // return from register to main
28329	28391	{
28330	28392	// copy mutable arguments back from call to register
28331	28393	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28348,7 +28410,7 @@
28348	28410	printf("%s", "\n }");
28349	28411	// call register from main
28350	28412	stack[base + 3LLU] = base;
28351		- stack[base + 4LLU] = 1833LLU;
	28413	+ stack[base + 4LLU] = 1838LLU;
28352	28414	// arguments for call to register
28353	28415	stack[base + 5LLU] = 0LLU;
28354	28416	stack[base + 6LLU] = 1LLU;

		@@ -28361,7 +28423,7 @@
28361	28423	label = 409LLU; // register
28362	28424	break;
28363	28425	}
28364		- case 1833LLU: // return from register to main
	28426	+ case 1838LLU: // return from register to main
28365	28427	{
28366	28428	// copy mutable arguments back from call to register
28367	28429	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28384,7 +28446,7 @@
28384	28446	printf("%s", "\n }");
28385	28447	// call register from main
28386	28448	stack[base + 3LLU] = base;
28387		- stack[base + 4LLU] = 1834LLU;
	28449	+ stack[base + 4LLU] = 1839LLU;
28388	28450	// arguments for call to register
28389	28451	stack[base + 5LLU] = 2LLU;
28390	28452	stack[base + 6LLU] = 1LLU;

		@@ -28397,7 +28459,7 @@
28397	28459	label = 409LLU; // register
28398	28460	break;
28399	28461	}
28400		- case 1834LLU: // return from register to main
	28462	+ case 1839LLU: // return from register to main
28401	28463	{
28402	28464	// copy mutable arguments back from call to register
28403	28465	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28426,7 +28488,7 @@
28426	28488	printf("%s", "\n stack[base + 1] = (uint64_t)lookahead;");
28427	28489	// call register from main
28428	28490	stack[base + 3LLU] = base;
28429		- stack[base + 4LLU] = 1835LLU;
	28491	+ stack[base + 4LLU] = 1840LLU;
28430	28492	// arguments for call to register
28431	28493	stack[base + 5LLU] = 3LLU;
28432	28494	stack[base + 6LLU] = 1LLU;

		@@ -28439,7 +28501,7 @@
28439	28501	label = 409LLU; // register
28440	28502	break;
28441	28503	}
28442		- case 1835LLU: // return from register to main
	28504	+ case 1840LLU: // return from register to main
28443	28505	{
28444	28506	// copy mutable arguments back from call to register
28445	28507	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28568,7 +28630,7 @@
28568	28630	printf("%s", "\n }");
28569	28631	// call register from main
28570	28632	stack[base + 3LLU] = base;
28571		- stack[base + 4LLU] = 1836LLU;
	28633	+ stack[base + 4LLU] = 1841LLU;
28572	28634	// arguments for call to register
28573	28635	stack[base + 5LLU] = 0LLU;
28574	28636	stack[base + 6LLU] = 2LLU;

		@@ -28581,7 +28643,7 @@
28581	28643	label = 409LLU; // register
28582	28644	break;
28583	28645	}
28584		- case 1836LLU: // return from register to main
	28646	+ case 1841LLU: // return from register to main
28585	28647	{
28586	28648	// copy mutable arguments back from call to register
28587	28649	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28626,7 +28688,7 @@
28626	28688	printf("%s", "\n }");
28627	28689	// call register from main
28628	28690	stack[base + 3LLU] = base;
28629		- stack[base + 4LLU] = 1837LLU;
	28691	+ stack[base + 4LLU] = 1842LLU;
28630	28692	// arguments for call to register
28631	28693	stack[base + 5LLU] = 0LLU;
28632	28694	stack[base + 6LLU] = 2LLU;

		@@ -28639,7 +28701,7 @@
28639	28701	label = 409LLU; // register
28640	28702	break;
28641	28703	}
28642		- case 1837LLU: // return from register to main
	28704	+ case 1842LLU: // return from register to main
28643	28705	{
28644	28706	// copy mutable arguments back from call to register
28645	28707	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28684,7 +28746,7 @@
28684	28746	printf("%s", "\n }");
28685	28747	// call register from main
28686	28748	stack[base + 3LLU] = base;
28687		- stack[base + 4LLU] = 1838LLU;
	28749	+ stack[base + 4LLU] = 1843LLU;
28688	28750	// arguments for call to register
28689	28751	stack[base + 5LLU] = 1LLU;
28690	28752	stack[base + 6LLU] = 1LLU;

		@@ -28697,7 +28759,7 @@
28697	28759	label = 409LLU; // register
28698	28760	break;
28699	28761	}
28700		- case 1838LLU: // return from register to main
	28762	+ case 1843LLU: // return from register to main
28701	28763	{
28702	28764	// copy mutable arguments back from call to register
28703	28765	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28726,7 +28788,7 @@
28726	28788	printf("%s", "\n stack[base + 0] = lookahead;");
28727	28789	// call register from main
28728	28790	stack[base + 3LLU] = base;
28729		- stack[base + 4LLU] = 1839LLU;
	28791	+ stack[base + 4LLU] = 1844LLU;
28730	28792	// arguments for call to register
28731	28793	stack[base + 5LLU] = 1LLU;
28732	28794	stack[base + 6LLU] = 1LLU;

		@@ -28739,7 +28801,7 @@
28739	28801	label = 409LLU; // register
28740	28802	break;
28741	28803	}
28742		- case 1839LLU: // return from register to main
	28804	+ case 1844LLU: // return from register to main
28743	28805	{
28744	28806	// copy mutable arguments back from call to register
28745	28807	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28748,7 +28810,7 @@
28748	28810	printf("%s", "\n stack[base + 0] = stack[base + 1];");
28749	28811	// call register from main
28750	28812	stack[base + 3LLU] = base;
28751		- stack[base + 4LLU] = 1840LLU;
	28813	+ stack[base + 4LLU] = 1845LLU;
28752	28814	// arguments for call to register
28753	28815	stack[base + 5LLU] = 1LLU;
28754	28816	stack[base + 6LLU] = 2LLU;

		@@ -28761,7 +28823,7 @@
28761	28823	label = 409LLU; // register
28762	28824	break;
28763	28825	}
28764		- case 1840LLU: // return from register to main
	28826	+ case 1845LLU: // return from register to main
28765	28827	{
28766	28828	// copy mutable arguments back from call to register
28767	28829	stack[base + 2]/defcount/ = stack[base + 10LLU];

		@@ -28771,7 +28833,7 @@
28771	28833	printf("%s", "\n stack[base + 0/code/] = stringnrtoid(tmp, stack[base + 2/nr/]);");
28772	28834	// call emitreturn from main
28773	28835	stack[base + 3LLU] = base;
28774		- stack[base + 4LLU] = 1841LLU;
	28836	+ stack[base + 4LLU] = 1846LLU;
28775	28837	// arguments for call to emitreturn
28776	28838	// set stack-base & callee-address
28777	28839	base += 5LLU;

		@@ -28778,7 +28840,7 @@
28778	28840	label = 408LLU; // emitreturn
28779	28841	break;
28780	28842	}
28781		- case 1841LLU: // return from emitreturn to main
	28843	+ case 1846LLU: // return from emitreturn to main
28782	28844	{
28783	28845	// copy mutable arguments back from call to emitreturn
28784	28846	//#define typedefs 3

		@@ -28798,7 +28860,7 @@
28798	28860	stack[base + 8]/running/ = 1;
28799	28861	// call getbyte from main
28800	28862	stack[base + 9LLU] = base;
28801		- stack[base + 10LLU] = 1842LLU;
	28863	+ stack[base + 10LLU] = 1847LLU;
28802	28864	// arguments for call to getbyte
28803	28865	// set stack-base & callee-address
28804	28866	base += 11LLU;

		@@ -28805,19 +28867,19 @@
28805	28867	label = 18446744073709551594LLU; // getbyte
28806	28868	break;
28807	28869	}
28808		- case 1842LLU: // return from getbyte to main
	28870	+ case 1847LLU: // return from getbyte to main
28809	28871	{
28810	28872	// copy mutable arguments back from call to getbyte
28811	28873	// copy back results provided by call to getbyte
28812	28874	stack[base + 4] = stack[base + 11LLU];
28813		- label = 1843LLU; // start to repeat
	28875	+ label = 1848LLU; // start to repeat
28814	28876	break;
28815	28877	}
28816		- case 1843LLU: // repeat from here
	28878	+ case 1848LLU: // repeat from here
28817	28879	{
28818	28880	if(!stack[base + 8]/running/)
28819	28881	{
28820		- label = 1844LLU; // break loop
	28882	+ label = 1849LLU; // break loop
28821	28883	break;
28822	28884	}
28823	28885

		@@ -28824,7 +28886,7 @@
28824	28886	// loop body
28825	28887	// call parsetoken from main
28826	28888	stack[base + 9LLU] = base;
28827		- stack[base + 10LLU] = 1845LLU;
	28889	+ stack[base + 10LLU] = 1850LLU;
28828	28890	// arguments for call to parsetoken
28829	28891	stack[base + 14LLU] = stack[base + 4]/lookahead/;
28830	28892	// set stack-base & callee-address

		@@ -28832,7 +28894,7 @@
28832	28894	label = 18446744073709551585LLU; // parsetoken
28833	28895	break;
28834	28896	}
28835		- case 1845LLU: // return from parsetoken to main
	28897	+ case 1850LLU: // return from parsetoken to main
28836	28898	{
28837	28899	// copy mutable arguments back from call to parsetoken
28838	28900	// copy back results provided by call to parsetoken

		@@ -28841,7 +28903,7 @@
28841	28903	stack[base + 4] = stack[base + 13LLU];
28842	28904	// call neq from main
28843	28905	stack[base + 9LLU] = base;
28844		- stack[base + 10LLU] = 1846LLU;
	28906	+ stack[base + 10LLU] = 1851LLU;
28845	28907	// arguments for call to neq
28846	28908	stack[base + 12LLU] = 5LLU;
28847	28909	stack[base + 13LLU] = stack[base + 5]/variant/;

		@@ -28850,7 +28912,7 @@
28850	28912	label = 18446744073709551599LLU; // neq
28851	28913	break;
28852	28914	}
28853		- case 1846LLU: // return from neq to main
	28915	+ case 1851LLU: // return from neq to main
28854	28916	{
28855	28917	// copy mutable arguments back from call to neq
28856	28918	// copy back results provided by call to neq

		@@ -28857,7 +28919,7 @@
28857	28919	stack[base + 8] = stack[base + 11LLU];
28858	28920	if(!stack[base + 8]/running/)
28859	28921	{
28860		- label = 1847LLU; // jump to alternative
	28922	+ label = 1852LLU; // jump to alternative
28861	28923	break;
28862	28924	}
28863	28925

		@@ -28866,7 +28928,7 @@
28866	28928	stack[base + 9/issimple/] = 0; // init
28867	28929	// call equ from main
28868	28930	stack[base + 10LLU] = base;
28869		- stack[base + 11LLU] = 1849LLU;
	28931	+ stack[base + 11LLU] = 1854LLU;
28870	28932	// arguments for call to equ
28871	28933	stack[base + 13LLU] = stack[base + 5]/variant/;
28872	28934	stack[base + 14LLU] = 0LLU;

		@@ -28875,7 +28937,7 @@
28875	28937	label = 18446744073709551600LLU; // equ
28876	28938	break;
28877	28939	}
28878		- case 1849LLU: // return from equ to main
	28940	+ case 1854LLU: // return from equ to main
28879	28941	{
28880	28942	// copy mutable arguments back from call to equ
28881	28943	// copy back results provided by call to equ

		@@ -28884,7 +28946,7 @@
28884	28946	stack[base + 10/isequal/] = 0; // init
28885	28947	// call equ from main
28886	28948	stack[base + 11LLU] = base;
28887		- stack[base + 12LLU] = 1850LLU;
	28949	+ stack[base + 12LLU] = 1855LLU;
28888	28950	// arguments for call to equ
28889	28951	stack[base + 14LLU] = stack[base + 6]/content/;
28890	28952	stack[base + 15LLU] = 96LLU;

		@@ -28893,7 +28955,7 @@
28893	28955	label = 18446744073709551600LLU; // equ
28894	28956	break;
28895	28957	}
28896		- case 1850LLU: // return from equ to main
	28958	+ case 1855LLU: // return from equ to main
28897	28959	{
28898	28960	// copy mutable arguments back from call to equ
28899	28961	// copy back results provided by call to equ

		@@ -28900,7 +28962,7 @@
28900	28962	stack[base + 10] = stack[base + 13LLU];
28901	28963	// call and from main
28902	28964	stack[base + 11LLU] = base;
28903		- stack[base + 12LLU] = 1851LLU;
	28965	+ stack[base + 12LLU] = 1856LLU;
28904	28966	// arguments for call to and
28905	28967	stack[base + 14LLU] = stack[base + 9]/issimple/;
28906	28968	stack[base + 15LLU] = stack[base + 10]/isequal/;

		@@ -28909,7 +28971,7 @@
28909	28971	label = 18446744073709551613LLU; // and
28910	28972	break;
28911	28973	}
28912		- case 1851LLU: // return from and to main
	28974	+ case 1856LLU: // return from and to main
28913	28975	{
28914	28976	// copy mutable arguments back from call to and
28915	28977	// copy back results provided by call to and

		@@ -28916,19 +28978,19 @@
28916	28978	stack[base + 10] = stack[base + 13LLU];
28917	28979	if(!stack[base + 10]/isequal/)
28918	28980	{
28919		- label = 1852LLU; // jump to alternative
	28981	+ label = 1857LLU; // jump to alternative
28920	28982	break;
28921	28983	}
28922	28984
28923	28985	// consequent
28924		- label = 1854LLU; // start to repeat
	28986	+ label = 1859LLU; // start to repeat
28925	28987	break;
28926	28988	}
28927		- case 1854LLU: // repeat from here
	28989	+ case 1859LLU: // repeat from here
28928	28990	{
28929	28991	if(!stack[base + 8]/running/)
28930	28992	{
28931		- label = 1855LLU; // break loop
	28993	+ label = 1860LLU; // break loop
28932	28994	break;
28933	28995	}
28934	28996

		@@ -28935,7 +28997,7 @@
28935	28997	// loop body
28936	28998	// call leq from main
28937	28999	stack[base + 11LLU] = base;
28938		- stack[base + 12LLU] = 1856LLU;
	29000	+ stack[base + 12LLU] = 1861LLU;
28939	29001	// arguments for call to leq
28940	29002	stack[base + 14LLU] = stack[base + 4]/lookahead/;
28941	29003	stack[base + 15LLU] = 255LLU;

		@@ -28944,7 +29006,7 @@
28944	29006	label = 18446744073709551598LLU; // leq
28945	29007	break;
28946	29008	}
28947		- case 1856LLU: // return from leq to main
	29009	+ case 1861LLU: // return from leq to main
28948	29010	{
28949	29011	// copy mutable arguments back from call to leq
28950	29012	// copy back results provided by call to leq

		@@ -28951,7 +29013,7 @@
28951	29013	stack[base + 8] = stack[base + 13LLU];
28952	29014	if(!stack[base + 8]/running/)
28953	29015	{
28954		- label = 1857LLU; // jump to alternative
	29016	+ label = 1862LLU; // jump to alternative
28955	29017	break;
28956	29018	}
28957	29019

		@@ -28958,7 +29020,7 @@
28958	29020	// consequent
28959	29021	// call neq from main
28960	29022	stack[base + 11LLU] = base;
28961		- stack[base + 12LLU] = 1859LLU;
	29023	+ stack[base + 12LLU] = 1864LLU;
28962	29024	// arguments for call to neq
28963	29025	stack[base + 14LLU] = stack[base + 4]/lookahead/;
28964	29026	stack[base + 15LLU] = 96LLU;

		@@ -28967,7 +29029,7 @@
28967	29029	label = 18446744073709551599LLU; // neq
28968	29030	break;
28969	29031	}
28970		- case 1859LLU: // return from neq to main
	29032	+ case 1864LLU: // return from neq to main
28971	29033	{
28972	29034	// copy mutable arguments back from call to neq
28973	29035	// copy back results provided by call to neq

		@@ -28974,7 +29036,7 @@
28974	29036	stack[base + 8] = stack[base + 13LLU];
28975	29037	if(!stack[base + 8]/running/)
28976	29038	{
28977		- label = 1860LLU; // jump to alternative
	29039	+ label = 1865LLU; // jump to alternative
28978	29040	break;
28979	29041	}
28980	29042

		@@ -28981,7 +29043,7 @@
28981	29043	// consequent
28982	29044	// call printbyte from main
28983	29045	stack[base + 11LLU] = base;
28984		- stack[base + 12LLU] = 1862LLU;
	29046	+ stack[base + 12LLU] = 1867LLU;
28985	29047	// arguments for call to printbyte
28986	29048	stack[base + 13LLU] = stack[base + 4]/lookahead/;
28987	29049	// set stack-base & callee-address

		@@ -28989,12 +29051,12 @@
28989	29051	label = 18446744073709551593LLU; // printbyte
28990	29052	break;
28991	29053	}
28992		- case 1862LLU: // return from printbyte to main
	29054	+ case 1867LLU: // return from printbyte to main
28993	29055	{
28994	29056	// copy mutable arguments back from call to printbyte
28995	29057	// call getbyte from main
28996	29058	stack[base + 11LLU] = base;
28997		- stack[base + 12LLU] = 1863LLU;
	29059	+ stack[base + 12LLU] = 1868LLU;
28998	29060	// arguments for call to getbyte
28999	29061	// set stack-base & callee-address
29000	29062	base += 13LLU;

		@@ -29001,40 +29063,40 @@
29001	29063	label = 18446744073709551594LLU; // getbyte
29002	29064	break;
29003	29065	}
29004		- case 1863LLU: // return from getbyte to main
	29066	+ case 1868LLU: // return from getbyte to main
29005	29067	{
29006	29068	// copy mutable arguments back from call to getbyte
29007	29069	// copy back results provided by call to getbyte
29008	29070	stack[base + 4] = stack[base + 13LLU];
29009		- label = 1861LLU; // consequent complete
	29071	+ label = 1866LLU; // consequent complete
29010	29072	break;
29011	29073	}
29012		- case 1860LLU: // alternative
	29074	+ case 1865LLU: // alternative
29013	29075	{
29014		- label = 1861LLU; // alternative complete
	29076	+ label = 1866LLU; // alternative complete
29015	29077	break;
29016	29078	}
29017		- case 1861LLU: // completed if-then-else
	29079	+ case 1866LLU: // completed if-then-else
29018	29080	{
29019		- label = 1858LLU; // consequent complete
	29081	+ label = 1863LLU; // consequent complete
29020	29082	break;
29021	29083	}
29022		- case 1857LLU: // alternative
	29084	+ case 1862LLU: // alternative
29023	29085	{
29024		- label = 1858LLU; // alternative complete
	29086	+ label = 1863LLU; // alternative complete
29025	29087	break;
29026	29088	}
29027		- case 1858LLU: // completed if-then-else
	29089	+ case 1863LLU: // completed if-then-else
29028	29090	{
29029		- label = 1854LLU; // repeat
	29091	+ label = 1859LLU; // repeat
29030	29092	break;
29031	29093	}
29032		- case 1855LLU: // loop finished
	29094	+ case 1860LLU: // loop finished
29033	29095	{
29034	29096	stack[base + 8]/running/ = 1;
29035	29097	// call getbyte from main
29036	29098	stack[base + 11LLU] = base;
29037		- stack[base + 12LLU] = 1864LLU;
	29099	+ stack[base + 12LLU] = 1869LLU;
29038	29100	// arguments for call to getbyte
29039	29101	// set stack-base & callee-address
29040	29102	base += 13LLU;

		@@ -29041,19 +29103,19 @@
29041	29103	label = 18446744073709551594LLU; // getbyte
29042	29104	break;
29043	29105	}
29044		- case 1864LLU: // return from getbyte to main
	29106	+ case 1869LLU: // return from getbyte to main
29045	29107	{
29046	29108	// copy mutable arguments back from call to getbyte
29047	29109	// copy back results provided by call to getbyte
29048	29110	stack[base + 4] = stack[base + 13LLU];
29049		- label = 1853LLU; // consequent complete
	29111	+ label = 1858LLU; // consequent complete
29050	29112	break;
29051	29113	}
29052		- case 1852LLU: // alternative
	29114	+ case 1857LLU: // alternative
29053	29115	{
29054	29116	// call equ from main
29055	29117	stack[base + 11LLU] = base;
29056		- stack[base + 12LLU] = 1865LLU;
	29118	+ stack[base + 12LLU] = 1870LLU;
29057	29119	// arguments for call to equ
29058	29120	stack[base + 14LLU] = 4LLU;
29059	29121	stack[base + 15LLU] = stack[base + 5]/variant/;

		@@ -29062,7 +29124,7 @@
29062	29124	label = 18446744073709551600LLU; // equ
29063	29125	break;
29064	29126	}
29065		- case 1865LLU: // return from equ to main
	29127	+ case 1870LLU: // return from equ to main
29066	29128	{
29067	29129	// copy mutable arguments back from call to equ
29068	29130	// copy back results provided by call to equ

		@@ -29069,7 +29131,7 @@
29069	29131	stack[base + 10] = stack[base + 13LLU];
29070	29132	if(!stack[base + 10]/isequal/)
29071	29133	{
29072		- label = 1866LLU; // jump to alternative
	29134	+ label = 1871LLU; // jump to alternative
29073	29135	break;
29074	29136	}
29075	29137

		@@ -29076,7 +29138,7 @@
29076	29138	// consequent
29077	29139	// call equ from main
29078	29140	stack[base + 11LLU] = base;
29079		- stack[base + 12LLU] = 1868LLU;
	29141	+ stack[base + 12LLU] = 1873LLU;
29080	29142	// arguments for call to equ
29081	29143	stack[base + 14LLU] = 819787073576763392LLU;
29082	29144	stack[base + 15LLU] = stack[base + 6]/content/;

		@@ -29085,7 +29147,7 @@
29085	29147	label = 18446744073709551600LLU; // equ
29086	29148	break;
29087	29149	}
29088		- case 1868LLU: // return from equ to main
	29150	+ case 1873LLU: // return from equ to main
29089	29151	{
29090	29152	// copy mutable arguments back from call to equ
29091	29153	// copy back results provided by call to equ

		@@ -29092,7 +29154,7 @@
29092	29154	stack[base + 10] = stack[base + 13LLU];
29093	29155	if(!stack[base + 10]/isequal/)
29094	29156	{
29095		- label = 1869LLU; // jump to alternative
	29157	+ label = 1874LLU; // jump to alternative
29096	29158	break;
29097	29159	}
29098	29160

		@@ -29099,7 +29161,7 @@
29099	29161	// consequent
29100	29162	// call parsetoken from main
29101	29163	stack[base + 11LLU] = base;
29102		- stack[base + 12LLU] = 1871LLU;
	29164	+ stack[base + 12LLU] = 1876LLU;
29103	29165	// arguments for call to parsetoken
29104	29166	stack[base + 16LLU] = stack[base + 4]/lookahead/;
29105	29167	// set stack-base & callee-address

		@@ -29107,7 +29169,7 @@
29107	29169	label = 18446744073709551585LLU; // parsetoken
29108	29170	break;
29109	29171	}
29110		- case 1871LLU: // return from parsetoken to main
	29172	+ case 1876LLU: // return from parsetoken to main
29111	29173	{
29112	29174	// copy mutable arguments back from call to parsetoken
29113	29175	// copy back results provided by call to parsetoken

		@@ -29116,7 +29178,7 @@
29116	29178	stack[base + 4] = stack[base + 15LLU];
29117	29179	// call equ from main
29118	29180	stack[base + 11LLU] = base;
29119		- stack[base + 12LLU] = 1872LLU;
	29181	+ stack[base + 12LLU] = 1877LLU;
29120	29182	// arguments for call to equ
29121	29183	stack[base + 14LLU] = stack[base + 6]/content/;
29122	29184	stack[base + 15LLU] = 566536285473210368LLU;

		@@ -29125,7 +29187,7 @@
29125	29187	label = 18446744073709551600LLU; // equ
29126	29188	break;
29127	29189	}
29128		- case 1872LLU: // return from equ to main
	29190	+ case 1877LLU: // return from equ to main
29129	29191	{
29130	29192	// copy mutable arguments back from call to equ
29131	29193	// copy back results provided by call to equ

		@@ -29132,7 +29194,7 @@
29132	29194	stack[base + 10] = stack[base + 13LLU];
29133	29195	if(!stack[base + 10]/isequal/)
29134	29196	{
29135		- label = 1873LLU; // jump to alternative
	29197	+ label = 1878LLU; // jump to alternative
29136	29198	break;
29137	29199	}
29138	29200

		@@ -29139,7 +29201,7 @@
29139	29201	// consequent
29140	29202	// call procdata from main
29141	29203	stack[base + 11LLU] = base;
29142		- stack[base + 12LLU] = 1875LLU;
	29204	+ stack[base + 12LLU] = 1880LLU;
29143	29205	// arguments for call to procdata
29144	29206	stack[base + 13LLU] = stack[base + 3]/typedefs/;
29145	29207	stack[base + 14LLU] = stack[base + 4]/lookahead/;

		@@ -29153,7 +29215,7 @@
29153	29215	label = 330LLU; // procdata
29154	29216	break;
29155	29217	}
29156		- case 1875LLU: // return from procdata to main
	29218	+ case 1880LLU: // return from procdata to main
29157	29219	{
29158	29220	// copy mutable arguments back from call to procdata
29159	29221	stack[base + 2]/defcount/ = stack[base + 18LLU];

		@@ -29162,14 +29224,14 @@
29162	29224	stack[base + 5]/variant/ = stack[base + 15LLU];
29163	29225	stack[base + 4]/lookahead/ = stack[base + 14LLU];
29164	29226	stack[base + 3]/typedefs/ = stack[base + 13LLU];
29165		- label = 1874LLU; // consequent complete
	29227	+ label = 1879LLU; // consequent complete
29166	29228	break;
29167	29229	}
29168		- case 1873LLU: // alternative
	29230	+ case 1878LLU: // alternative
29169	29231	{
29170	29232	// call procfn from main
29171	29233	stack[base + 11LLU] = base;
29172		- stack[base + 12LLU] = 1876LLU;
	29234	+ stack[base + 12LLU] = 1881LLU;
29173	29235	// arguments for call to procfn
29174	29236	stack[base + 13LLU] = stack[base + 1]/fndefs/;
29175	29237	stack[base + 14LLU] = stack[base + 3]/typedefs/;

		@@ -29181,10 +29243,10 @@
29181	29243	stack[base + 20LLU] = 1LLU;
29182	29244	// set stack-base & callee-address
29183	29245	base += 13LLU;
29184		- label = 1638LLU; // procfn
	29246	+ label = 1643LLU; // procfn
29185	29247	break;
29186	29248	}
29187		- case 1876LLU: // return from procfn to main
	29249	+ case 1881LLU: // return from procfn to main
29188	29250	{
29189	29251	// copy mutable arguments back from call to procfn
29190	29252	stack[base + 2]/defcount/ = stack[base + 19LLU];

		@@ -29194,19 +29256,19 @@
29194	29256	stack[base + 4]/lookahead/ = stack[base + 15LLU];
29195	29257	stack[base + 3]/typedefs/ = stack[base + 14LLU];
29196	29258	stack[base + 1]/fndefs/ = stack[base + 13LLU];
29197		- label = 1874LLU; // alternative complete
	29259	+ label = 1879LLU; // alternative complete
29198	29260	break;
29199	29261	}
29200		- case 1874LLU: // completed if-then-else
	29262	+ case 1879LLU: // completed if-then-else
29201	29263	{
29202		- label = 1870LLU; // consequent complete
	29264	+ label = 1875LLU; // consequent complete
29203	29265	break;
29204	29266	}
29205		- case 1869LLU: // alternative
	29267	+ case 1874LLU: // alternative
29206	29268	{
29207	29269	// call equ from main
29208	29270	stack[base + 11LLU] = base;
29209		- stack[base + 12LLU] = 1877LLU;
	29271	+ stack[base + 12LLU] = 1882LLU;
29210	29272	// arguments for call to equ
29211	29273	stack[base + 14LLU] = stack[base + 6]/content/;
29212	29274	stack[base + 15LLU] = 566536285473210368LLU;

		@@ -29215,7 +29277,7 @@
29215	29277	label = 18446744073709551600LLU; // equ
29216	29278	break;
29217	29279	}
29218		- case 1877LLU: // return from equ to main
	29280	+ case 1882LLU: // return from equ to main
29219	29281	{
29220	29282	// copy mutable arguments back from call to equ
29221	29283	// copy back results provided by call to equ

		@@ -29222,7 +29284,7 @@
29222	29284	stack[base + 10] = stack[base + 13LLU];
29223	29285	if(!stack[base + 10]/isequal/)
29224	29286	{
29225		- label = 1878LLU; // jump to alternative
	29287	+ label = 1883LLU; // jump to alternative
29226	29288	break;
29227	29289	}
29228	29290

		@@ -29229,7 +29291,7 @@
29229	29291	// consequent
29230	29292	// call procdata from main
29231	29293	stack[base + 11LLU] = base;
29232		- stack[base + 12LLU] = 1880LLU;
	29294	+ stack[base + 12LLU] = 1885LLU;
29233	29295	// arguments for call to procdata
29234	29296	stack[base + 13LLU] = stack[base + 3]/typedefs/;
29235	29297	stack[base + 14LLU] = stack[base + 4]/lookahead/;

		@@ -29243,7 +29305,7 @@
29243	29305	label = 330LLU; // procdata
29244	29306	break;
29245	29307	}
29246		- case 1880LLU: // return from procdata to main
	29308	+ case 1885LLU: // return from procdata to main
29247	29309	{
29248	29310	// copy mutable arguments back from call to procdata
29249	29311	stack[base + 2]/defcount/ = stack[base + 18LLU];

		@@ -29252,14 +29314,14 @@
29252	29314	stack[base + 5]/variant/ = stack[base + 15LLU];
29253	29315	stack[base + 4]/lookahead/ = stack[base + 14LLU];
29254	29316	stack[base + 3]/typedefs/ = stack[base + 13LLU];
29255		- label = 1879LLU; // consequent complete
	29317	+ label = 1884LLU; // consequent complete
29256	29318	break;
29257	29319	}
29258		- case 1878LLU: // alternative
	29320	+ case 1883LLU: // alternative
29259	29321	{
29260	29322	// call procfn from main
29261	29323	stack[base + 11LLU] = base;
29262		- stack[base + 12LLU] = 1881LLU;
	29324	+ stack[base + 12LLU] = 1886LLU;
29263	29325	// arguments for call to procfn
29264	29326	stack[base + 13LLU] = stack[base + 1]/fndefs/;
29265	29327	stack[base + 14LLU] = stack[base + 3]/typedefs/;

		@@ -29271,10 +29333,10 @@
29271	29333	stack[base + 20LLU] = 0LLU;
29272	29334	// set stack-base & callee-address
29273	29335	base += 13LLU;
29274		- label = 1638LLU; // procfn
	29336	+ label = 1643LLU; // procfn
29275	29337	break;
29276	29338	}
29277		- case 1881LLU: // return from procfn to main
	29339	+ case 1886LLU: // return from procfn to main
29278	29340	{
29279	29341	// copy mutable arguments back from call to procfn
29280	29342	stack[base + 2]/defcount/ = stack[base + 19LLU];

		@@ -29284,24 +29346,24 @@
29284	29346	stack[base + 4]/lookahead/ = stack[base + 15LLU];
29285	29347	stack[base + 3]/typedefs/ = stack[base + 14LLU];
29286	29348	stack[base + 1]/fndefs/ = stack[base + 13LLU];
29287		- label = 1879LLU; // alternative complete
	29349	+ label = 1884LLU; // alternative complete
29288	29350	break;
29289	29351	}
29290		- case 1879LLU: // completed if-then-else
	29352	+ case 1884LLU: // completed if-then-else
29291	29353	{
29292		- label = 1870LLU; // alternative complete
	29354	+ label = 1875LLU; // alternative complete
29293	29355	break;
29294	29356	}
29295		- case 1870LLU: // completed if-then-else
	29357	+ case 1875LLU: // completed if-then-else
29296	29358	{
29297		- label = 1867LLU; // consequent complete
	29359	+ label = 1872LLU; // consequent complete
29298	29360	break;
29299	29361	}
29300		- case 1866LLU: // alternative
	29362	+ case 1871LLU: // alternative
29301	29363	{
29302	29364	// call issimple from main
29303	29365	stack[base + 11LLU] = base;
29304		- stack[base + 12LLU] = 1882LLU;
	29366	+ stack[base + 12LLU] = 1887LLU;
29305	29367	// arguments for call to issimple
29306	29368	stack[base + 14LLU] = stack[base + 5]/variant/;
29307	29369	stack[base + 15LLU] = stack[base + 6]/content/;

		@@ -29311,7 +29373,7 @@
29311	29373	label = 18LLU; // issimple
29312	29374	break;
29313	29375	}
29314		- case 1882LLU: // return from issimple to main
	29376	+ case 1887LLU: // return from issimple to main
29315	29377	{
29316	29378	// copy mutable arguments back from call to issimple
29317	29379	// copy back results provided by call to issimple

		@@ -29318,7 +29380,7 @@
29318	29380	stack[base + 10] = stack[base + 13LLU];
29319	29381	if(!stack[base + 10]/isequal/)
29320	29382	{
29321		- label = 1883LLU; // jump to alternative
	29383	+ label = 1888LLU; // jump to alternative
29322	29384	break;
29323	29385	}
29324	29386

		@@ -29325,7 +29387,7 @@
29325	29387	// consequent
29326	29388	// call procfn from main
29327	29389	stack[base + 11LLU] = base;
29328		- stack[base + 12LLU] = 1885LLU;
	29390	+ stack[base + 12LLU] = 1890LLU;
29329	29391	// arguments for call to procfn
29330	29392	stack[base + 13LLU] = stack[base + 1]/fndefs/;
29331	29393	stack[base + 14LLU] = stack[base + 3]/typedefs/;

		@@ -29337,10 +29399,10 @@
29337	29399	stack[base + 20LLU] = 0LLU;
29338	29400	// set stack-base & callee-address
29339	29401	base += 13LLU;
29340		- label = 1638LLU; // procfn
	29402	+ label = 1643LLU; // procfn
29341	29403	break;
29342	29404	}
29343		- case 1885LLU: // return from procfn to main
	29405	+ case 1890LLU: // return from procfn to main
29344	29406	{
29345	29407	// copy mutable arguments back from call to procfn
29346	29408	stack[base + 2]/defcount/ = stack[base + 19LLU];

		@@ -29350,15 +29412,15 @@
29350	29412	stack[base + 4]/lookahead/ = stack[base + 15LLU];
29351	29413	stack[base + 3]/typedefs/ = stack[base + 14LLU];
29352	29414	stack[base + 1]/fndefs/ = stack[base + 13LLU];
29353		- label = 1884LLU; // consequent complete
	29415	+ label = 1889LLU; // consequent complete
29354	29416	break;
29355	29417	}
29356		- case 1883LLU: // alternative
	29418	+ case 1888LLU: // alternative
29357	29419	{
29358	29420	fprintf(stderr, "%s", "unexpected token ");
29359	29421	// call reporttok from main
29360	29422	stack[base + 11LLU] = base;
29361		- stack[base + 12LLU] = 1886LLU;
	29423	+ stack[base + 12LLU] = 1891LLU;
29362	29424	// arguments for call to reporttok
29363	29425	stack[base + 13LLU] = stack[base + 5]/variant/;
29364	29426	stack[base + 14LLU] = stack[base + 6]/content/;

		@@ -29367,13 +29429,13 @@
29367	29429	label = 18446744073709551583LLU; // reporttok
29368	29430	break;
29369	29431	}
29370		- case 1886LLU: // return from reporttok to main
	29432	+ case 1891LLU: // return from reporttok to main
29371	29433	{
29372	29434	// copy mutable arguments back from call to reporttok
29373	29435	fprintf(stderr, "%s", ", variant ");
29374	29436	// call reportnr from main
29375	29437	stack[base + 11LLU] = base;
29376		- stack[base + 12LLU] = 1887LLU;
	29438	+ stack[base + 12LLU] = 1892LLU;
29377	29439	// arguments for call to reportnr
29378	29440	stack[base + 13LLU] = stack[base + 5]/variant/;
29379	29441	// set stack-base & callee-address

		@@ -29381,62 +29443,62 @@
29381	29443	label = 18446744073709551590LLU; // reportnr
29382	29444	break;
29383	29445	}
29384		- case 1887LLU: // return from reportnr to main
	29446	+ case 1892LLU: // return from reportnr to main
29385	29447	{
29386	29448	// copy mutable arguments back from call to reportnr
29387	29449	fprintf(stderr, "%s", "\n");
29388	29450	exit(-1);
29389		- label = 1884LLU; // alternative complete
	29451	+ label = 1889LLU; // alternative complete
29390	29452	break;
29391	29453	}
29392		- case 1884LLU: // completed if-then-else
	29454	+ case 1889LLU: // completed if-then-else
29393	29455	{
29394		- label = 1867LLU; // alternative complete
	29456	+ label = 1872LLU; // alternative complete
29395	29457	break;
29396	29458	}
29397		- case 1867LLU: // completed if-then-else
	29459	+ case 1872LLU: // completed if-then-else
29398	29460	{
29399		- label = 1853LLU; // alternative complete
	29461	+ label = 1858LLU; // alternative complete
29400	29462	break;
29401	29463	}
29402		- case 1853LLU: // completed if-then-else
	29464	+ case 1858LLU: // completed if-then-else
29403	29465	{
29404		- label = 1848LLU; // consequent complete
	29466	+ label = 1853LLU; // consequent complete
29405	29467	break;
29406	29468	}
29407		- case 1847LLU: // alternative
	29469	+ case 1852LLU: // alternative
29408	29470	{
29409		- label = 1848LLU; // alternative complete
	29471	+ label = 1853LLU; // alternative complete
29410	29472	break;
29411	29473	}
29412		- case 1848LLU: // completed if-then-else
	29474	+ case 1853LLU: // completed if-then-else
29413	29475	{
29414		- label = 1843LLU; // repeat
	29476	+ label = 1848LLU; // repeat
29415	29477	break;
29416	29478	}
29417		- case 1844LLU: // loop finished
	29479	+ case 1849LLU: // loop finished
29418	29480	{
29419	29481	// call emitexit from main
29420	29482	stack[base + 9LLU] = base;
29421		- stack[base + 10LLU] = 1888LLU;
	29483	+ stack[base + 10LLU] = 1893LLU;
29422	29484	// arguments for call to emitexit
29423	29485	stack[base + 11LLU] = stack[base + 1]/fndefs/;
29424	29486	// set stack-base & callee-address
29425	29487	base += 11LLU;
29426		- label = 1792LLU; // emitexit
	29488	+ label = 1797LLU; // emitexit
29427	29489	break;
29428	29490	}
29429		- case 1888LLU: // return from emitexit to main
	29491	+ case 1893LLU: // return from emitexit to main
29430	29492	{
29431	29493	// copy mutable arguments back from call to emitexit
29432		- label = 1889LLU; // start to repeat
	29494	+ label = 1894LLU; // start to repeat
29433	29495	break;
29434	29496	}
29435		- case 1889LLU: // repeat from here
	29497	+ case 1894LLU: // repeat from here
29436	29498	{
29437	29499	if(!stack[base + 1]/fndefs/)
29438	29500	{
29439		- label = 1890LLU; // break loop
	29501	+ label = 1895LLU; // break loop
29440	29502	break;
29441	29503	}
29442	29504

		@@ -29447,7 +29509,7 @@
29447	29509	struct listnode list = (struct listnode )stack[base + 1]/fndefs/;
29448	29510	if(!list)
29449	29511	{
29450		- label = 1891LLU; // jump to alternative
	29512	+ label = 1896LLU; // jump to alternative
29451	29513	break;
29452	29514	}
29453	29515

		@@ -29459,7 +29521,7 @@
29459	29521	}
29460	29522	if(/fndef/0 != ((uint64_t )(stack[base + 9]/fndef*/))[0])
29461	29523	{
29462		- label = 1893LLU; // jump to alternative
	29524	+ label = 1898LLU; // jump to alternative
29463	29525	break;
29464	29526	}
29465	29527

		@@ -29485,25 +29547,25 @@
29485	29547	fprintf(stderr, "%s", "\nreleasing definition of function ");
29486	29548	if(!stack[base + 15]/recursive/)
29487	29549	{
29488		- label = 1895LLU; // jump to alternative
	29550	+ label = 1900LLU; // jump to alternative
29489	29551	break;
29490	29552	}
29491	29553
29492	29554	// consequent
29493	29555	fprintf(stderr, "%s", "rec ");
29494		- label = 1896LLU; // consequent complete
	29556	+ label = 1901LLU; // consequent complete
29495	29557	break;
29496	29558	}
29497		- case 1895LLU: // alternative
	29559	+ case 1900LLU: // alternative
29498	29560	{
29499		- label = 1896LLU; // alternative complete
	29561	+ label = 1901LLU; // alternative complete
29500	29562	break;
29501	29563	}
29502		- case 1896LLU: // completed if-then-else
	29564	+ case 1901LLU: // completed if-then-else
29503	29565	{
29504	29566	// call reportid from main
29505	29567	stack[base + 16LLU] = base;
29506		- stack[base + 17LLU] = 1897LLU;
	29568	+ stack[base + 17LLU] = 1902LLU;
29507	29569	// arguments for call to reportid
29508	29570	stack[base + 18LLU] = stack[base + 14]/id/;
29509	29571	// set stack-base & callee-address

		@@ -29511,18 +29573,18 @@
29511	29573	label = 18446744073709551587LLU; // reportid
29512	29574	break;
29513	29575	}
29514		- case 1897LLU: // return from reportid to main
	29576	+ case 1902LLU: // return from reportid to main
29515	29577	{
29516	29578	// copy mutable arguments back from call to reportid
29517	29579	fprintf(stderr, "%s", "( ");
29518		- label = 1898LLU; // start to repeat
	29580	+ label = 1903LLU; // start to repeat
29519	29581	break;
29520	29582	}
29521		- case 1898LLU: // repeat from here
	29583	+ case 1903LLU: // repeat from here
29522	29584	{
29523	29585	if(!stack[base + 12]/argtypes/)
29524	29586	{
29525		- label = 1899LLU; // break loop
	29587	+ label = 1904LLU; // break loop
29526	29588	break;
29527	29589	}
29528	29590

		@@ -29533,7 +29595,7 @@
29533	29595	struct listnode list = (struct listnode )stack[base + 12]/argtypes/;
29534	29596	if(!list)
29535	29597	{
29536		- label = 1900LLU; // jump to alternative
	29598	+ label = 1905LLU; // jump to alternative
29537	29599	break;
29538	29600	}
29539	29601

		@@ -29545,7 +29607,7 @@
29545	29607	}
29546	29608	// call repparam from main
29547	29609	stack[base + 17LLU] = base;
29548		- stack[base + 18LLU] = 1902LLU;
	29610	+ stack[base + 18LLU] = 1907LLU;
29549	29611	// arguments for call to repparam
29550	29612	stack[base + 19LLU] = stack[base + 16]/param/;
29551	29613	// set stack-base & callee-address

		@@ -29553,13 +29615,13 @@
29553	29615	label = 147LLU; // repparam
29554	29616	break;
29555	29617	}
29556		- case 1902LLU: // return from repparam to main
	29618	+ case 1907LLU: // return from repparam to main
29557	29619	{
29558	29620	// copy mutable arguments back from call to repparam
29559	29621	fprintf(stderr, "%s", "; ");
29560	29622	// call delparam from main
29561	29623	stack[base + 17LLU] = base;
29562		- stack[base + 18LLU] = 1903LLU;
	29624	+ stack[base + 18LLU] = 1908LLU;
29563	29625	// arguments for call to delparam
29564	29626	stack[base + 19LLU] = stack[base + 16]/param/;
29565	29627	// set stack-base & callee-address

		@@ -29567,33 +29629,33 @@
29567	29629	label = 143LLU; // delparam
29568	29630	break;
29569	29631	}
29570		- case 1903LLU: // return from delparam to main
	29632	+ case 1908LLU: // return from delparam to main
29571	29633	{
29572	29634	// copy mutable arguments back from call to delparam
29573		- label = 1901LLU; // consequent complete
	29635	+ label = 1906LLU; // consequent complete
29574	29636	break;
29575	29637	}
29576		- case 1900LLU: // alternative
	29638	+ case 1905LLU: // alternative
29577	29639	{
29578		- label = 1901LLU; // alternative complete
	29640	+ label = 1906LLU; // alternative complete
29579	29641	break;
29580	29642	}
29581		- case 1901LLU: // completed if-then-else
	29643	+ case 1906LLU: // completed if-then-else
29582	29644	{
29583		- label = 1898LLU; // repeat
	29645	+ label = 1903LLU; // repeat
29584	29646	break;
29585	29647	}
29586		- case 1899LLU: // loop finished
	29648	+ case 1904LLU: // loop finished
29587	29649	{
29588	29650	fprintf(stderr, "%s", ")->( ");
29589		- label = 1904LLU; // start to repeat
	29651	+ label = 1909LLU; // start to repeat
29590	29652	break;
29591	29653	}
29592		- case 1904LLU: // repeat from here
	29654	+ case 1909LLU: // repeat from here
29593	29655	{
29594	29656	if(!stack[base + 11]/restypes/)
29595	29657	{
29596		- label = 1905LLU; // break loop
	29658	+ label = 1910LLU; // break loop
29597	29659	break;
29598	29660	}
29599	29661

		@@ -29604,7 +29666,7 @@
29604	29666	struct listnode list = (struct listnode )stack[base + 11]/restypes/;
29605	29667	if(!list)
29606	29668	{
29607		- label = 1906LLU; // jump to alternative
	29669	+ label = 1911LLU; // jump to alternative
29608	29670	break;
29609	29671	}
29610	29672

		@@ -29616,7 +29678,7 @@
29616	29678	}
29617	29679	// call represult from main
29618	29680	stack[base + 17LLU] = base;
29619		- stack[base + 18LLU] = 1908LLU;
	29681	+ stack[base + 18LLU] = 1913LLU;
29620	29682	// arguments for call to represult
29621	29683	stack[base + 19LLU] = stack[base + 16]/result/;
29622	29684	// set stack-base & callee-address

		@@ -29624,13 +29686,13 @@
29624	29686	label = 124LLU; // represult
29625	29687	break;
29626	29688	}
29627		- case 1908LLU: // return from represult to main
	29689	+ case 1913LLU: // return from represult to main
29628	29690	{
29629	29691	// copy mutable arguments back from call to represult
29630	29692	fprintf(stderr, "%s", "; ");
29631	29693	// call delresult from main
29632	29694	stack[base + 17LLU] = base;
29633		- stack[base + 18LLU] = 1909LLU;
	29695	+ stack[base + 18LLU] = 1914LLU;
29634	29696	// arguments for call to delresult
29635	29697	stack[base + 19LLU] = stack[base + 16]/result/;
29636	29698	// set stack-base & callee-address

		@@ -29638,28 +29700,28 @@
29638	29700	label = 120LLU; // delresult
29639	29701	break;
29640	29702	}
29641		- case 1909LLU: // return from delresult to main
	29703	+ case 1914LLU: // return from delresult to main
29642	29704	{
29643	29705	// copy mutable arguments back from call to delresult
29644		- label = 1907LLU; // consequent complete
	29706	+ label = 1912LLU; // consequent complete
29645	29707	break;
29646	29708	}
29647		- case 1906LLU: // alternative
	29709	+ case 1911LLU: // alternative
29648	29710	{
29649		- label = 1907LLU; // alternative complete
	29711	+ label = 1912LLU; // alternative complete
29650	29712	break;
29651	29713	}
29652		- case 1907LLU: // completed if-then-else
	29714	+ case 1912LLU: // completed if-then-else
29653	29715	{
29654		- label = 1904LLU; // repeat
	29716	+ label = 1909LLU; // repeat
29655	29717	break;
29656	29718	}
29657		- case 1905LLU: // loop finished
	29719	+ case 1910LLU: // loop finished
29658	29720	{
29659	29721	fprintf(stderr, "%s", ") memory ");
29660	29722	// call reportnr from main
29661	29723	stack[base + 16LLU] = base;
29662		- stack[base + 17LLU] = 1910LLU;
	29724	+ stack[base + 17LLU] = 1915LLU;
29663	29725	// arguments for call to reportnr
29664	29726	stack[base + 18LLU] = stack[base + 13]/maxcount/;
29665	29727	// set stack-base & callee-address

		@@ -29667,66 +29729,66 @@
29667	29729	label = 18446744073709551590LLU; // reportnr
29668	29730	break;
29669	29731	}
29670		- case 1910LLU: // return from reportnr to main
	29732	+ case 1915LLU: // return from reportnr to main
29671	29733	{
29672	29734	// copy mutable arguments back from call to reportnr
29673	29735	if(!stack[base + 10]/label/)
29674	29736	{
29675		- label = 1911LLU; // jump to alternative
	29737	+ label = 1916LLU; // jump to alternative
29676	29738	break;
29677	29739	}
29678	29740
29679	29741	// consequent
29680		- label = 1912LLU; // consequent complete
	29742	+ label = 1917LLU; // consequent complete
29681	29743	break;
29682	29744	}
29683		- case 1911LLU: // alternative
	29745	+ case 1916LLU: // alternative
29684	29746	{
29685	29747	fprintf(stderr, "%s", " NULL-label!\n");
29686	29748	exit(-1);
29687		- label = 1912LLU; // alternative complete
	29749	+ label = 1917LLU; // alternative complete
29688	29750	break;
29689	29751	}
29690		- case 1912LLU: // completed if-then-else
	29752	+ case 1917LLU: // completed if-then-else
29691	29753	{
29692	29754	// releasing fndef
29693	29755	Free(6, sizeof(uint64_t), ((uint64_t *)stack[base + 9]/fndef*/)[1]);
29694	29756	Free(2, sizeof(uint64_t), (uint64_t )stack[base + 9]/fndef*/);
29695		- label = 1894LLU; // consequent complete
	29757	+ label = 1899LLU; // consequent complete
29696	29758	break;
29697	29759	}
29698		- case 1893LLU: // alternative
	29760	+ case 1898LLU: // alternative
29699	29761	{
29700	29762	fprintf(stderr, "%s", "failed to access fndef\n");
29701	29763	exit(-1);
29702		- label = 1894LLU; // alternative complete
	29764	+ label = 1899LLU; // alternative complete
29703	29765	break;
29704	29766	}
29705		- case 1894LLU: // completed if-then-else
	29767	+ case 1899LLU: // completed if-then-else
29706	29768	{
29707		- label = 1892LLU; // consequent complete
	29769	+ label = 1897LLU; // consequent complete
29708	29770	break;
29709	29771	}
29710		- case 1891LLU: // alternative
	29772	+ case 1896LLU: // alternative
29711	29773	{
29712		- label = 1892LLU; // alternative complete
	29774	+ label = 1897LLU; // alternative complete
29713	29775	break;
29714	29776	}
29715		- case 1892LLU: // completed if-then-else
	29777	+ case 1897LLU: // completed if-then-else
29716	29778	{
29717		- label = 1889LLU; // repeat
	29779	+ label = 1894LLU; // repeat
29718	29780	break;
29719	29781	}
29720		- case 1890LLU: // loop finished
	29782	+ case 1895LLU: // loop finished
29721	29783	{
29722		- label = 1913LLU; // start to repeat
	29784	+ label = 1918LLU; // start to repeat
29723	29785	break;
29724	29786	}
29725		- case 1913LLU: // repeat from here
	29787	+ case 1918LLU: // repeat from here
29726	29788	{
29727	29789	if(!stack[base + 3]/typedefs/)
29728	29790	{
29729		- label = 1914LLU; // break loop
	29791	+ label = 1919LLU; // break loop
29730	29792	break;
29731	29793	}
29732	29794

		@@ -29737,7 +29799,7 @@
29737	29799	struct listnode list = (struct listnode )stack[base + 3]/typedefs/;
29738	29800	if(!list)
29739	29801	{
29740		- label = 1915LLU; // jump to alternative
	29802	+ label = 1920LLU; // jump to alternative
29741	29803	break;
29742	29804	}
29743	29805

		@@ -29749,7 +29811,7 @@
29749	29811	}
29750	29812	if(/datadef/0 != ((uint64_t )(stack[base + 9]/typedef*/))[0])
29751	29813	{
29752		- label = 1917LLU; // jump to alternative
	29814	+ label = 1922LLU; // jump to alternative
29753	29815	break;
29754	29816	}
29755	29817

		@@ -29763,7 +29825,7 @@
29763	29825	fprintf(stderr, "%s", "\nreleasing definition of ");
29764	29826	// call reportid from main
29765	29827	stack[base + 12LLU] = base;
29766		- stack[base + 13LLU] = 1919LLU;
	29828	+ stack[base + 13LLU] = 1924LLU;
29767	29829	// arguments for call to reportid
29768	29830	stack[base + 14LLU] = stack[base + 10]/defid/;
29769	29831	// set stack-base & callee-address

		@@ -29771,20 +29833,20 @@
29771	29833	label = 18446744073709551587LLU; // reportid
29772	29834	break;
29773	29835	}
29774		- case 1919LLU: // return from reportid to main
	29836	+ case 1924LLU: // return from reportid to main
29775	29837	{
29776	29838	// copy mutable arguments back from call to reportid
29777	29839	//#define symbol 12
29778	29840	stack[base + 12/symbol/] = 0; // init
29779	29841	stack[base + 12]/symbol/ = 61; // =
29780		- label = 1920LLU; // start to repeat
	29842	+ label = 1925LLU; // start to repeat
29781	29843	break;
29782	29844	}
29783		- case 1920LLU: // repeat from here
	29845	+ case 1925LLU: // repeat from here
29784	29846	{
29785	29847	if(!stack[base + 11]/variants/)
29786	29848	{
29787		- label = 1921LLU; // break loop
	29849	+ label = 1926LLU; // break loop
29788	29850	break;
29789	29851	}
29790	29852

		@@ -29792,7 +29854,7 @@
29792	29854	fprintf(stderr, "%s", " ");
29793	29855	// call reportbyte from main
29794	29856	stack[base + 13LLU] = base;
29795		- stack[base + 14LLU] = 1922LLU;
	29857	+ stack[base + 14LLU] = 1927LLU;
29796	29858	// arguments for call to reportbyte
29797	29859	stack[base + 15LLU] = stack[base + 12]/symbol/;
29798	29860	// set stack-base & callee-address

		@@ -29800,7 +29862,7 @@
29800	29862	label = 18446744073709551592LLU; // reportbyte
29801	29863	break;
29802	29864	}
29803		- case 1922LLU: // return from reportbyte to main
	29865	+ case 1927LLU: // return from reportbyte to main
29804	29866	{
29805	29867	// copy mutable arguments back from call to reportbyte
29806	29868	stack[base + 12]/symbol/ = 124; // \|

		@@ -29810,7 +29872,7 @@
29810	29872	struct listnode list = (struct listnode )stack[base + 11]/variants/;
29811	29873	if(!list)
29812	29874	{
29813		- label = 1923LLU; // jump to alternative
	29875	+ label = 1928LLU; // jump to alternative
29814	29876	break;
29815	29877	}
29816	29878

		@@ -29822,7 +29884,7 @@
29822	29884	}
29823	29885	if(/variant/0 != ((uint64_t )(stack[base + 13]/constr*/))[0])
29824	29886	{
29825		- label = 1925LLU; // jump to alternative
	29887	+ label = 1930LLU; // jump to alternative
29826	29888	break;
29827	29889	}
29828	29890

		@@ -29836,7 +29898,7 @@
29836	29898	fprintf(stderr, "%s", " ");
29837	29899	// call reportid from main
29838	29900	stack[base + 16LLU] = base;
29839		- stack[base + 17LLU] = 1927LLU;
	29901	+ stack[base + 17LLU] = 1932LLU;
29840	29902	// arguments for call to reportid
29841	29903	stack[base + 18LLU] = stack[base + 14]/constrid/;
29842	29904	// set stack-base & callee-address

		@@ -29844,18 +29906,18 @@
29844	29906	label = 18446744073709551587LLU; // reportid
29845	29907	break;
29846	29908	}
29847		- case 1927LLU: // return from reportid to main
	29909	+ case 1932LLU: // return from reportid to main
29848	29910	{
29849	29911	// copy mutable arguments back from call to reportid
29850	29912	fprintf(stderr, "%s", " {");
29851		- label = 1928LLU; // start to repeat
	29913	+ label = 1933LLU; // start to repeat
29852	29914	break;
29853	29915	}
29854		- case 1928LLU: // repeat from here
	29916	+ case 1933LLU: // repeat from here
29855	29917	{
29856	29918	if(!stack[base + 15]/typeids/)
29857	29919	{
29858		- label = 1929LLU; // break loop
	29920	+ label = 1934LLU; // break loop
29859	29921	break;
29860	29922	}
29861	29923

		@@ -29866,7 +29928,7 @@
29866	29928	struct listnode list = (struct listnode )stack[base + 15]/typeids/;
29867	29929	if(!list)
29868	29930	{
29869		- label = 1930LLU; // jump to alternative
	29931	+ label = 1935LLU; // jump to alternative
29870	29932	break;
29871	29933	}
29872	29934

		@@ -29879,7 +29941,7 @@
29879	29941	fprintf(stderr, "%s", " ");
29880	29942	// call reportti from main
29881	29943	stack[base + 17LLU] = base;
29882		- stack[base + 18LLU] = 1932LLU;
	29944	+ stack[base + 18LLU] = 1937LLU;
29883	29945	// arguments for call to reportti
29884	29946	stack[base + 19LLU] = stack[base + 16]/typeid/;
29885	29947	// set stack-base & callee-address

		@@ -29887,12 +29949,12 @@
29887	29949	label = 112LLU; // reportti
29888	29950	break;
29889	29951	}
29890		- case 1932LLU: // return from reportti to main
	29952	+ case 1937LLU: // return from reportti to main
29891	29953	{
29892	29954	// copy mutable arguments back from call to reportti
29893	29955	// call deltypeid from main
29894	29956	stack[base + 17LLU] = base;
29895		- stack[base + 18LLU] = 1933LLU;
	29957	+ stack[base + 18LLU] = 1938LLU;
29896	29958	// arguments for call to deltypeid
29897	29959	stack[base + 19LLU] = stack[base + 16]/typeid/;
29898	29960	// set stack-base & callee-address

		@@ -29900,85 +29962,85 @@
29900	29962	label = 108LLU; // deltypeid
29901	29963	break;
29902	29964	}
29903		- case 1933LLU: // return from deltypeid to main
	29965	+ case 1938LLU: // return from deltypeid to main
29904	29966	{
29905	29967	// copy mutable arguments back from call to deltypeid
29906		- label = 1931LLU; // consequent complete
	29968	+ label = 1936LLU; // consequent complete
29907	29969	break;
29908	29970	}
29909		- case 1930LLU: // alternative
	29971	+ case 1935LLU: // alternative
29910	29972	{
29911		- label = 1931LLU; // alternative complete
	29973	+ label = 1936LLU; // alternative complete
29912	29974	break;
29913	29975	}
29914		- case 1931LLU: // completed if-then-else
	29976	+ case 1936LLU: // completed if-then-else
29915	29977	{
29916	29978	fprintf(stderr, "%s", ";");
29917		- label = 1928LLU; // repeat
	29979	+ label = 1933LLU; // repeat
29918	29980	break;
29919	29981	}
29920		- case 1929LLU: // loop finished
	29982	+ case 1934LLU: // loop finished
29921	29983	{
29922	29984	fprintf(stderr, "%s", " }");
29923	29985	// releasing constr
29924	29986	Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 13]/constr*/)[1]);
29925	29987	Free(2, sizeof(uint64_t), (uint64_t )stack[base + 13]/constr*/);
29926		- label = 1926LLU; // consequent complete
	29988	+ label = 1931LLU; // consequent complete
29927	29989	break;
29928	29990	}
29929		- case 1925LLU: // alternative
	29991	+ case 1930LLU: // alternative
29930	29992	{
29931	29993	fprintf(stderr, "%s", "INTERNAL ERROR\n");
29932	29994	exit(-1);
29933		- label = 1926LLU; // alternative complete
	29995	+ label = 1931LLU; // alternative complete
29934	29996	break;
29935	29997	}
29936		- case 1926LLU: // completed if-then-else
	29998	+ case 1931LLU: // completed if-then-else
29937	29999	{
29938		- label = 1924LLU; // consequent complete
	30000	+ label = 1929LLU; // consequent complete
29939	30001	break;
29940	30002	}
29941		- case 1923LLU: // alternative
	30003	+ case 1928LLU: // alternative
29942	30004	{
29943		- label = 1924LLU; // alternative complete
	30005	+ label = 1929LLU; // alternative complete
29944	30006	break;
29945	30007	}
29946		- case 1924LLU: // completed if-then-else
	30008	+ case 1929LLU: // completed if-then-else
29947	30009	{
29948		- label = 1920LLU; // repeat
	30010	+ label = 1925LLU; // repeat
29949	30011	break;
29950	30012	}
29951		- case 1921LLU: // loop finished
	30013	+ case 1926LLU: // loop finished
29952	30014	{
29953	30015	// releasing typedef
29954	30016	Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 9]/typedef*/)[1]);
29955	30017	Free(2, sizeof(uint64_t), (uint64_t )stack[base + 9]/typedef*/);
29956		- label = 1918LLU; // consequent complete
	30018	+ label = 1923LLU; // consequent complete
29957	30019	break;
29958	30020	}
29959		- case 1917LLU: // alternative
	30021	+ case 1922LLU: // alternative
29960	30022	{
29961	30023	fprintf(stderr, "%s", "INTERNAL ERROR releasing datadefs\n");
29962	30024	exit(-1);
29963		- label = 1918LLU; // alternative complete
	30025	+ label = 1923LLU; // alternative complete
29964	30026	break;
29965	30027	}
29966		- case 1918LLU: // completed if-then-else
	30028	+ case 1923LLU: // completed if-then-else
29967	30029	{
29968		- label = 1916LLU; // consequent complete
	30030	+ label = 1921LLU; // consequent complete
29969	30031	break;
29970	30032	}
29971		- case 1915LLU: // alternative
	30033	+ case 1920LLU: // alternative
29972	30034	{
29973		- label = 1916LLU; // alternative complete
	30035	+ label = 1921LLU; // alternative complete
29974	30036	break;
29975	30037	}
29976		- case 1916LLU: // completed if-then-else
	30038	+ case 1921LLU: // completed if-then-else
29977	30039	{
29978		- label = 1913LLU; // repeat
	30040	+ label = 1918LLU; // repeat
29979	30041	break;
29980	30042	}
29981		- case 1914LLU: // loop finished
	30043	+ case 1919LLU: // loop finished
29982	30044	{
29983	30045	fprintf(stderr, "%s", "\n");
29984	30046	// return from main

--- trunk/jpl_compiler_pragmatic/compiler.source.c (revision 1080)

+++ trunk/jpl_compiler_pragmatic/compiler.source.c (revision 1081)

		@@ -3660,7 +3660,7 @@
3660	3660
3661	3661	if ACCESS constr variant
3662	3662	{
3663		- constr.id -> dummy
	3663	+ constr.id -> variantid
3664	3664	constr.elements -> TYPEIDS
3665	3665
3666	3666	(label) = add(1, label)

		@@ -3880,8 +3880,18 @@
3880	3880
3881	3881	procblock(fndefs, typedefs, scopes, scope, fnrec, fnid, fnlabel, fnrescount, fnargcount, fnmaxcount, varcount, lookahead, variant, content, label) // alternative
3882	3882
3883		- print("\n label = ") printnr(labelskip) print("LLU; // alternative complete")
3884		- print("\n break;")
	3883	+ if(constrflag)
	3884	+ {
	3885	+ print("\n fprintf(stderr, \"%s\", \"ERROR: failed to construct ") printid(name) print(".") printid(variantid) print(" into ") printid(variableid) print("\\n\");")
	3886	+ print("\n label = 0; // alternative complete")
	3887	+ print("\n exit(-1); // couldn't construct object so program must shut down here rather than crashing unexpectedly later down the line")
	3888	+ }
	3889	+ else
	3890	+ {
	3891	+ print("\n label = ") printnr(labelskip) print("LLU; // alternative complete")
	3892	+ print("\n break;")
	3893	+ }
	3894	+
3885	3895	print("\n }")
3886	3896	print("\n case ") printnr(labelskip) print("LLU: // completed if-then-else")
3887	3897	print("\n {")

Afficher sur ancien navigateur de dépôt.