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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revision	1169 (tree)
Time	2021-02-24 06:01:40
Author	jakobthomsen

Log Message

fix memory-leak on exception in if-pop construct

Change Summary

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

Incremental Difference

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

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

		@@ -22929,7 +22929,7 @@
22929	22929	}
22930	22930	if(/typeidx/0 != ((uint64_t )(stack[base + 38]/typeidx*/))[0])
22931	22931	{
22932		- label = 1897LLU; // jump to alternative
	22932	+ label = 1898LLU; // jump to alternative
22933	22933	break;
22934	22934	}
22935	22935

		@@ -22939,7 +22939,7 @@
22939	22939	// case
22940	22940	if(/result/0 != ((uint64_t )(stack[base + 36]/result*/))[0])
22941	22941	{
22942		- label = 1900LLU; // jump to alternative
	22942	+ label = 1901LLU; // jump to alternative
22943	22943	break;
22944	22944	}
22945	22945

		@@ -22950,7 +22950,7 @@
22950	22950	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
22951	22951	if(!newstack)
22952	22952	{
22953		- label = 1901LLU; // throw: begin to unroll stack
	22953	+ label = 1902LLU; // throw: begin to unroll stack
22954	22954	break;
22955	22955	}
22956	22956

		@@ -22957,9 +22957,9 @@
22957	22957	newstack[15LLU] = 9876543210LLU; // overflow-marker
22958	22958	// call equtype from ProcCall
22959	22959	newstack[0] = (uint64_t)stack; // backup stack location
22960		- newstack[1] = 1902LLU;
	22960	+ newstack[1] = 1903LLU;
22961	22961	newstack[2] = base;
22962		- newstack[3] = 1903LLU;
	22962	+ newstack[3] = 1904LLU;
22963	22963	// arguments for call to equtype
22964	22964	newstack[5LLU] = stack[base + 39]/dsttype/;
22965	22965	newstack[6LLU] = stack[base + 41]/srctype/;

		@@ -22969,7 +22969,7 @@
22969	22969	label = 342LLU; // equtype
22970	22970	break;
22971	22971	}
22972		- case 1902LLU: // copy-back deleter (equtype to ProcCall)
	22972	+ case 1903LLU: // copy-back deleter (equtype to ProcCall)
22973	22973	{
22974	22974	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
22975	22975	uint64_t oldstack = (uint64_t )stack[0];

		@@ -22981,10 +22981,10 @@
22981	22981	}
22982	22982	Free(15LLU + 1, sizeof(uint64_t), stack);
22983	22983	stack = oldstack;
22984		- label = 1901LLU; // continue to unroll stack
	22984	+ label = 1902LLU; // continue to unroll stack
22985	22985	break;
22986	22986	}
22987		- case 1903LLU: // return from equtype to ProcCall
	22987	+ case 1904LLU: // return from equtype to ProcCall
22988	22988	{
22989	22989	uint64_t oldstack = (uint64_t )stack[0];
22990	22990	// copy mutable arguments back from call to equtype

		@@ -22999,21 +22999,21 @@
22999	22999	stack = oldstack;
23000	23000	if(!stack[base + 18]/isequal/)
23001	23001	{
23002		- label = 1904LLU; // jump to alternative
	23002	+ label = 1905LLU; // jump to alternative
23003	23003	break;
23004	23004	}
23005	23005
23006	23006	// consequent
23007		- label = 1905LLU; // consequent complete
	23007	+ label = 1906LLU; // consequent complete
23008	23008	break;
23009	23009	}
23010		- case 1904LLU: // alternative
	23010	+ case 1905LLU: // alternative
23011	23011	{
23012	23012	fprintf(stderr, "%s", "in function ");
23013	23013	// call reportid from ProcCall
23014		- stack[base + 43LLU] = 1906LLU/throw to this address/;
	23014	+ stack[base + 43LLU] = 1907LLU/throw to this address/;
23015	23015	stack[base + 44LLU] = base;
23016		- stack[base + 45LLU] = 1907LLU;
	23016	+ stack[base + 45LLU] = 1908LLU;
23017	23017	// arguments for call to reportid
23018	23018	stack[base + 46LLU] = stack[base + 8]/fnid/;
23019	23019	// set stack-base & callee-address

		@@ -23021,21 +23021,21 @@
23021	23021	label = 18446744073709551586LLU; // reportid
23022	23022	break;
23023	23023	}
23024		- case 1906LLU: // copy-back deleter (reportid to ProcCall)
	23024	+ case 1907LLU: // copy-back deleter (reportid to ProcCall)
23025	23025	{
23026	23026	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
23027	23027	// copy mutable arguments back from call to reportid
23028		- label = 1901LLU; // continue to roll stack
	23028	+ label = 1902LLU; // continue to roll stack
23029	23029	break;
23030	23030	}
23031		- case 1907LLU: // return from reportid to ProcCall
	23031	+ case 1908LLU: // return from reportid to ProcCall
23032	23032	{
23033	23033	// copy mutable arguments back from call to reportid
23034	23034	fprintf(stderr, "%s", " call to ");
23035	23035	// call reportid from ProcCall
23036		- stack[base + 43LLU] = 1908LLU/throw to this address/;
	23036	+ stack[base + 43LLU] = 1909LLU/throw to this address/;
23037	23037	stack[base + 44LLU] = base;
23038		- stack[base + 45LLU] = 1909LLU;
	23038	+ stack[base + 45LLU] = 1910LLU;
23039	23039	// arguments for call to reportid
23040	23040	stack[base + 46LLU] = stack[base + 24]/ceid/;
23041	23041	// set stack-base & callee-address

		@@ -23043,21 +23043,21 @@
23043	23043	label = 18446744073709551586LLU; // reportid
23044	23044	break;
23045	23045	}
23046		- case 1908LLU: // copy-back deleter (reportid to ProcCall)
	23046	+ case 1909LLU: // copy-back deleter (reportid to ProcCall)
23047	23047	{
23048	23048	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
23049	23049	// copy mutable arguments back from call to reportid
23050		- label = 1901LLU; // continue to roll stack
	23050	+ label = 1902LLU; // continue to roll stack
23051	23051	break;
23052	23052	}
23053		- case 1909LLU: // return from reportid to ProcCall
	23053	+ case 1910LLU: // return from reportid to ProcCall
23054	23054	{
23055	23055	// copy mutable arguments back from call to reportid
23056	23056	fprintf(stderr, "%s", " at position ");
23057	23057	// call reportnr from ProcCall
23058		- stack[base + 43LLU] = 1910LLU/throw to this address/;
	23058	+ stack[base + 43LLU] = 1911LLU/throw to this address/;
23059	23059	stack[base + 44LLU] = base;
23060		- stack[base + 45LLU] = 1911LLU;
	23060	+ stack[base + 45LLU] = 1912LLU;
23061	23061	// arguments for call to reportnr
23062	23062	stack[base + 46LLU] = stack[base + 32]/index/;
23063	23063	// set stack-base & callee-address

		@@ -23065,14 +23065,14 @@
23065	23065	label = 18446744073709551589LLU; // reportnr
23066	23066	break;
23067	23067	}
23068		- case 1910LLU: // copy-back deleter (reportnr to ProcCall)
	23068	+ case 1911LLU: // copy-back deleter (reportnr to ProcCall)
23069	23069	{
23070	23070	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
23071	23071	// copy mutable arguments back from call to reportnr
23072		- label = 1901LLU; // continue to roll stack
	23072	+ label = 1902LLU; // continue to roll stack
23073	23073	break;
23074	23074	}
23075		- case 1911LLU: // return from reportnr to ProcCall
	23075	+ case 1912LLU: // return from reportnr to ProcCall
23076	23076	{
23077	23077	// copy mutable arguments back from call to reportnr
23078	23078	fprintf(stderr, "%s", " cannot return source of type ");

		@@ -23079,7 +23079,7 @@
23079	23079	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
23080	23080	if(!newstack)
23081	23081	{
23082		- label = 1901LLU; // throw: begin to unroll stack
	23082	+ label = 1902LLU; // throw: begin to unroll stack
23083	23083	break;
23084	23084	}
23085	23085

		@@ -23086,9 +23086,9 @@
23086	23086	newstack[10LLU] = 9876543210LLU; // overflow-marker
23087	23087	// call reporttype from ProcCall
23088	23088	newstack[0] = (uint64_t)stack; // backup stack location
23089		- newstack[1] = 1912LLU;
	23089	+ newstack[1] = 1913LLU;
23090	23090	newstack[2] = base;
23091		- newstack[3] = 1913LLU;
	23091	+ newstack[3] = 1914LLU;
23092	23092	// arguments for call to reporttype
23093	23093	newstack[4LLU] = stack[base + 41]/srctype/;
23094	23094	stack = newstack;

		@@ -23097,7 +23097,7 @@
23097	23097	label = 316LLU; // reporttype
23098	23098	break;
23099	23099	}
23100		- case 1912LLU: // copy-back deleter (reporttype to ProcCall)
	23100	+ case 1913LLU: // copy-back deleter (reporttype to ProcCall)
23101	23101	{
23102	23102	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
23103	23103	uint64_t oldstack = (uint64_t )stack[0];

		@@ -23109,10 +23109,10 @@
23109	23109	}
23110	23110	Free(10LLU + 1, sizeof(uint64_t), stack);
23111	23111	stack = oldstack;
23112		- label = 1901LLU; // continue to unroll stack
	23112	+ label = 1902LLU; // continue to unroll stack
23113	23113	break;
23114	23114	}
23115		- case 1913LLU: // return from reporttype to ProcCall
	23115	+ case 1914LLU: // return from reporttype to ProcCall
23116	23116	{
23117	23117	uint64_t oldstack = (uint64_t )stack[0];
23118	23118	// copy mutable arguments back from call to reporttype

		@@ -23127,7 +23127,7 @@
23127	23127	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
23128	23128	if(!newstack)
23129	23129	{
23130		- label = 1901LLU; // throw: begin to unroll stack
	23130	+ label = 1902LLU; // throw: begin to unroll stack
23131	23131	break;
23132	23132	}
23133	23133

		@@ -23134,9 +23134,9 @@
23134	23134	newstack[10LLU] = 9876543210LLU; // overflow-marker
23135	23135	// call reporttype from ProcCall
23136	23136	newstack[0] = (uint64_t)stack; // backup stack location
23137		- newstack[1] = 1914LLU;
	23137	+ newstack[1] = 1915LLU;
23138	23138	newstack[2] = base;
23139		- newstack[3] = 1915LLU;
	23139	+ newstack[3] = 1916LLU;
23140	23140	// arguments for call to reporttype
23141	23141	newstack[4LLU] = stack[base + 39]/dsttype/;
23142	23142	stack = newstack;

		@@ -23145,7 +23145,7 @@
23145	23145	label = 316LLU; // reporttype
23146	23146	break;
23147	23147	}
23148		- case 1914LLU: // copy-back deleter (reporttype to ProcCall)
	23148	+ case 1915LLU: // copy-back deleter (reporttype to ProcCall)
23149	23149	{
23150	23150	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
23151	23151	uint64_t oldstack = (uint64_t )stack[0];

		@@ -23157,10 +23157,10 @@
23157	23157	}
23158	23158	Free(10LLU + 1, sizeof(uint64_t), stack);
23159	23159	stack = oldstack;
23160		- label = 1901LLU; // continue to unroll stack
	23160	+ label = 1902LLU; // continue to unroll stack
23161	23161	break;
23162	23162	}
23163		- case 1915LLU: // return from reporttype to ProcCall
	23163	+ case 1916LLU: // return from reporttype to ProcCall
23164	23164	{
23165	23165	uint64_t oldstack = (uint64_t )stack[0];
23166	23166	// copy mutable arguments back from call to reporttype

		@@ -23173,16 +23173,16 @@
23173	23173	stack = oldstack;
23174	23174	fprintf(stderr, "%s", "\n");
23175	23175	exit(-1);
23176		- label = 1905LLU; // alternative complete
	23176	+ label = 1906LLU; // alternative complete
23177	23177	break;
23178	23178	}
23179		- case 1905LLU: // completed if-then-else
	23179	+ case 1906LLU: // completed if-then-else
23180	23180	{
23181	23181	stack[base + 30]/sum/ = 0;
23182	23182	// call add from ProcCall
23183		- stack[base + 43LLU] = 1916LLU/throw to this address/;
	23183	+ stack[base + 43LLU] = 1917LLU/throw to this address/;
23184	23184	stack[base + 44LLU] = base;
23185		- stack[base + 45LLU] = 1917LLU;
	23185	+ stack[base + 45LLU] = 1918LLU;
23186	23186	// arguments for call to add
23187	23187	stack[base + 47LLU] = 4LLU;
23188	23188	stack[base + 48LLU] = stack[base + 30]/sum/;

		@@ -23191,22 +23191,22 @@
23191	23191	label = 18446744073709551605LLU; // add
23192	23192	break;
23193	23193	}
23194		- case 1916LLU: // copy-back deleter (add to ProcCall)
	23194	+ case 1917LLU: // copy-back deleter (add to ProcCall)
23195	23195	{
23196	23196	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23197	23197	// copy mutable arguments back from call to add
23198		- label = 1901LLU; // continue to roll stack
	23198	+ label = 1902LLU; // continue to roll stack
23199	23199	break;
23200	23200	}
23201		- case 1917LLU: // return from add to ProcCall
	23201	+ case 1918LLU: // return from add to ProcCall
23202	23202	{
23203	23203	// copy mutable arguments back from call to add
23204	23204	// copy back results provided by call to add
23205	23205	stack[base + 30] = stack[base + 46LLU];
23206	23206	// call add from ProcCall
23207		- stack[base + 43LLU] = 1918LLU/throw to this address/;
	23207	+ stack[base + 43LLU] = 1919LLU/throw to this address/;
23208	23208	stack[base + 44LLU] = base;
23209		- stack[base + 45LLU] = 1919LLU;
	23209	+ stack[base + 45LLU] = 1920LLU;
23210	23210	// arguments for call to add
23211	23211	stack[base + 47LLU] = stack[base + 32]/index/;
23212	23212	stack[base + 48LLU] = stack[base + 30]/sum/;

		@@ -23215,14 +23215,14 @@
23215	23215	label = 18446744073709551605LLU; // add
23216	23216	break;
23217	23217	}
23218		- case 1918LLU: // copy-back deleter (add to ProcCall)
	23218	+ case 1919LLU: // copy-back deleter (add to ProcCall)
23219	23219	{
23220	23220	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23221	23221	// copy mutable arguments back from call to add
23222		- label = 1901LLU; // continue to roll stack
	23222	+ label = 1902LLU; // continue to roll stack
23223	23223	break;
23224	23224	}
23225		- case 1919LLU: // return from add to ProcCall
	23225	+ case 1920LLU: // return from add to ProcCall
23226	23226	{
23227	23227	// copy mutable arguments back from call to add
23228	23228	// copy back results provided by call to add

		@@ -23229,9 +23229,9 @@
23229	23229	stack[base + 30] = stack[base + 46LLU];
23230	23230	printf("%s", "\n old");
23231	23231	// call emitvaridx from ProcCall
23232		- stack[base + 43LLU] = 1920LLU/throw to this address/;
	23232	+ stack[base + 43LLU] = 1921LLU/throw to this address/;
23233	23233	stack[base + 44LLU] = base;
23234		- stack[base + 45LLU] = 1921LLU;
	23234	+ stack[base + 45LLU] = 1922LLU;
23235	23235	// arguments for call to emitvaridx
23236	23236	stack[base + 46LLU] = stack[base + 40]/INDEX/;
23237	23237	// set stack-base & callee-address

		@@ -23239,21 +23239,21 @@
23239	23239	label = 691LLU; // emitvaridx
23240	23240	break;
23241	23241	}
23242		- case 1920LLU: // copy-back deleter (emitvaridx to ProcCall)
	23242	+ case 1921LLU: // copy-back deleter (emitvaridx to ProcCall)
23243	23243	{
23244	23244	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n");
23245	23245	// copy mutable arguments back from call to emitvaridx
23246		- label = 1901LLU; // continue to roll stack
	23246	+ label = 1902LLU; // continue to roll stack
23247	23247	break;
23248	23248	}
23249		- case 1921LLU: // return from emitvaridx to ProcCall
	23249	+ case 1922LLU: // return from emitvaridx to ProcCall
23250	23250	{
23251	23251	// copy mutable arguments back from call to emitvaridx
23252	23252	printf("%s", " = stack[");
23253	23253	// call printnr from ProcCall
23254		- stack[base + 43LLU] = 1922LLU/throw to this address/;
	23254	+ stack[base + 43LLU] = 1923LLU/throw to this address/;
23255	23255	stack[base + 44LLU] = base;
23256		- stack[base + 45LLU] = 1923LLU;
	23256	+ stack[base + 45LLU] = 1924LLU;
23257	23257	// arguments for call to printnr
23258	23258	stack[base + 46LLU] = stack[base + 30]/sum/;
23259	23259	// set stack-base & callee-address

		@@ -23261,54 +23261,54 @@
23261	23261	label = 18446744073709551590LLU; // printnr
23262	23262	break;
23263	23263	}
23264		- case 1922LLU: // copy-back deleter (printnr to ProcCall)
	23264	+ case 1923LLU: // copy-back deleter (printnr to ProcCall)
23265	23265	{
23266	23266	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23267	23267	// copy mutable arguments back from call to printnr
23268		- label = 1901LLU; // continue to roll stack
	23268	+ label = 1902LLU; // continue to roll stack
23269	23269	break;
23270	23270	}
23271		- case 1923LLU: // return from printnr to ProcCall
	23271	+ case 1924LLU: // return from printnr to ProcCall
23272	23272	{
23273	23273	// copy mutable arguments back from call to printnr
23274	23274	printf("%s", "LLU];");
23275	23275	((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
23276	23276	((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
23277		- label = 1899LLU; // case complete
	23277	+ label = 1900LLU; // case complete
23278	23278	break;
23279	23279	}
23280		- case 1901LLU: // copy-back deleter (switch)
	23280	+ case 1902LLU: // copy-back deleter (switch)
23281	23281	{
23282	23282	((uint64_t **)(stack[base + 36]))[1][1] = stack[base + 42];
23283	23283	((uint64_t **)(stack[base + 36]))[1][0] = stack[base + 41];
23284		- label = 1898LLU; // continue to unroll stack
	23284	+ label = 1899LLU; // continue to unroll stack
23285	23285	break;
23286	23286	}
23287		- case 1900LLU: // try next case
	23287	+ case 1901LLU: // try next case
23288	23288	{
23289	23289	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
23290	23290	exit(-1);
23291	23291	}
23292		- case 1899LLU: // completed switch
	23292	+ case 1900LLU: // completed switch
23293	23293	{
23294	23294	((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
23295	23295	((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
23296		- label = 1896LLU; // case complete
	23296	+ label = 1897LLU; // case complete
23297	23297	break;
23298	23298	}
23299		- case 1898LLU: // copy-back deleter (switch)
	23299	+ case 1899LLU: // copy-back deleter (switch)
23300	23300	{
23301	23301	((uint64_t **)(stack[base + 38]))[1][1] = stack[base + 40];
23302	23302	((uint64_t **)(stack[base + 38]))[1][0] = stack[base + 39];
23303		- label = 1889LLU; // continue to unroll stack
	23303	+ label = 1896LLU; // continue to unroll stack
23304	23304	break;
23305	23305	}
23306		- case 1897LLU: // try next case
	23306	+ case 1898LLU: // try next case
23307	23307	{
23308	23308	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
23309	23309	exit(-1);
23310	23310	}
23311		- case 1896LLU: // completed switch
	23311	+ case 1897LLU: // completed switch
23312	23312	{
23313	23313
23314	23314	uint64_t newstack = (uint64_t )(stack[base + 38] - sizeof(uint64_t) * 4);

		@@ -23316,7 +23316,7 @@
23316	23316	newstack[0] = (uint64_t)stack; // backup stack location
23317	23317	newstack[1] = 1234567890;
23318	23318	newstack[2] = base;
23319		- newstack[3] = 1924LLU;
	23319	+ newstack[3] = 1925LLU;
23320	23320	stack = newstack;
23321	23321	// set stack-base & callee-address
23322	23322	base = 4/deloffset/;

		@@ -23323,7 +23323,7 @@
23323	23323	label = 379LLU; // ~typeidx
23324	23324	break;
23325	23325	}
23326		- case 1924LLU: // return from ~typeidx to ProcCall
	23326	+ case 1925LLU: // return from ~typeidx to ProcCall
23327	23327	{
23328	23328	stack = (uint64_t *)stack[0];
23329	23329	// releasing toplevel container

		@@ -23332,13 +23332,37 @@
23332	23332	label = 1895LLU; // consequent complete
23333	23333	break;
23334	23334	}
	23335	+ case 1896LLU: // copy-back deleter (if pop)
	23336	+ {
	23337	+
	23338	+ uint64_t newstack = (uint64_t )(stack[base + 38] - sizeof(uint64_t) * 4);
	23339	+ // call ~typeidx from ProcCall
	23340	+ newstack[0] = (uint64_t)stack; // backup stack location
	23341	+ newstack[1] = 1234567890;
	23342	+ newstack[2] = base;
	23343	+ newstack[3] = 1926LLU;
	23344	+ stack = newstack;
	23345	+ // set stack-base & callee-address
	23346	+ base = 4/deloffset/;
	23347	+ label = 379LLU; // ~typeidx
	23348	+ break;
	23349	+ }
	23350	+ case 1926LLU: // return from ~typeidx to ProcCall
	23351	+ {
	23352	+ stack = (uint64_t *)stack[0];
	23353	+ // releasing toplevel container
	23354	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 38] - sizeof(uint64_t) 4));
	23355	+
	23356	+ label = 1889LLU; // consequent complete
	23357	+ break;
	23358	+ }
23335	23359	case 1894LLU: // alternative
23336	23360	{
23337	23361	fprintf(stderr, "%s", "in function ");
23338	23362	// call reportid from ProcCall
23339		- stack[base + 39LLU] = 1925LLU/throw to this address/;
	23363	+ stack[base + 39LLU] = 1927LLU/throw to this address/;
23340	23364	stack[base + 40LLU] = base;
23341		- stack[base + 41LLU] = 1926LLU;
	23365	+ stack[base + 41LLU] = 1928LLU;
23342	23366	// arguments for call to reportid
23343	23367	stack[base + 42LLU] = stack[base + 8]/fnid/;
23344	23368	// set stack-base & callee-address

		@@ -23346,7 +23370,7 @@
23346	23370	label = 18446744073709551586LLU; // reportid
23347	23371	break;
23348	23372	}
23349		- case 1925LLU: // copy-back deleter (reportid to ProcCall)
	23373	+ case 1927LLU: // copy-back deleter (reportid to ProcCall)
23350	23374	{
23351	23375	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
23352	23376	// copy mutable arguments back from call to reportid

		@@ -23353,14 +23377,14 @@
23353	23377	label = 1889LLU; // continue to roll stack
23354	23378	break;
23355	23379	}
23356		- case 1926LLU: // return from reportid to ProcCall
	23380	+ case 1928LLU: // return from reportid to ProcCall
23357	23381	{
23358	23382	// copy mutable arguments back from call to reportid
23359	23383	fprintf(stderr, "%s", " call to ");
23360	23384	// call reportid from ProcCall
23361		- stack[base + 39LLU] = 1927LLU/throw to this address/;
	23385	+ stack[base + 39LLU] = 1929LLU/throw to this address/;
23362	23386	stack[base + 40LLU] = base;
23363		- stack[base + 41LLU] = 1928LLU;
	23387	+ stack[base + 41LLU] = 1930LLU;
23364	23388	// arguments for call to reportid
23365	23389	stack[base + 42LLU] = stack[base + 24]/ceid/;
23366	23390	// set stack-base & callee-address

		@@ -23368,7 +23392,7 @@
23368	23392	label = 18446744073709551586LLU; // reportid
23369	23393	break;
23370	23394	}
23371		- case 1927LLU: // copy-back deleter (reportid to ProcCall)
	23395	+ case 1929LLU: // copy-back deleter (reportid to ProcCall)
23372	23396	{
23373	23397	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
23374	23398	// copy mutable arguments back from call to reportid

		@@ -23375,14 +23399,14 @@
23375	23399	label = 1889LLU; // continue to roll stack
23376	23400	break;
23377	23401	}
23378		- case 1928LLU: // return from reportid to ProcCall
	23402	+ case 1930LLU: // return from reportid to ProcCall
23379	23403	{
23380	23404	// copy mutable arguments back from call to reportid
23381	23405	fprintf(stderr, "%s", " at position ");
23382	23406	// call reportnr from ProcCall
23383		- stack[base + 39LLU] = 1929LLU/throw to this address/;
	23407	+ stack[base + 39LLU] = 1931LLU/throw to this address/;
23384	23408	stack[base + 40LLU] = base;
23385		- stack[base + 41LLU] = 1930LLU;
	23409	+ stack[base + 41LLU] = 1932LLU;
23386	23410	// arguments for call to reportnr
23387	23411	stack[base + 42LLU] = stack[base + 32]/index/;
23388	23412	// set stack-base & callee-address

		@@ -23390,7 +23414,7 @@
23390	23414	label = 18446744073709551589LLU; // reportnr
23391	23415	break;
23392	23416	}
23393		- case 1929LLU: // copy-back deleter (reportnr to ProcCall)
	23417	+ case 1931LLU: // copy-back deleter (reportnr to ProcCall)
23394	23418	{
23395	23419	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
23396	23420	// copy mutable arguments back from call to reportnr

		@@ -23397,7 +23421,7 @@
23397	23421	label = 1889LLU; // continue to roll stack
23398	23422	break;
23399	23423	}
23400		- case 1930LLU: // return from reportnr to ProcCall
	23424	+ case 1932LLU: // return from reportnr to ProcCall
23401	23425	{
23402	23426	// copy mutable arguments back from call to reportnr
23403	23427	fprintf(stderr, "%s", " not enough destination-variables for results");

		@@ -23432,9 +23456,9 @@
23432	23456	{
23433	23457	printf("%s", "\n if(stack[");
23434	23458	// call printnr from ProcCall
23435		- stack[base + 35LLU] = 1931LLU/throw to this address/;
	23459	+ stack[base + 35LLU] = 1933LLU/throw to this address/;
23436	23460	stack[base + 36LLU] = base;
23437		- stack[base + 37LLU] = 1932LLU;
	23461	+ stack[base + 37LLU] = 1934LLU;
23438	23462	// arguments for call to printnr
23439	23463	stack[base + 38LLU] = stack[base + 34]/recsztotal/;
23440	23464	// set stack-base & callee-address

		@@ -23442,7 +23466,7 @@
23442	23466	label = 18446744073709551590LLU; // printnr
23443	23467	break;
23444	23468	}
23445		- case 1931LLU: // copy-back deleter (printnr to ProcCall)
	23469	+ case 1933LLU: // copy-back deleter (printnr to ProcCall)
23446	23470	{
23447	23471	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23448	23472	// copy mutable arguments back from call to printnr

		@@ -23449,7 +23473,7 @@
23449	23473	label = 1612LLU; // continue to roll stack
23450	23474	break;
23451	23475	}
23452		- case 1932LLU: // return from printnr to ProcCall
	23476	+ case 1934LLU: // return from printnr to ProcCall
23453	23477	{
23454	23478	// copy mutable arguments back from call to printnr
23455	23479	printf("%s", "LLU] != 9876543210LLU)");

		@@ -23456,9 +23480,9 @@
23456	23480	printf("%s", "\n {");
23457	23481	printf("%s", "\n fprintf(stderr, \"INTERNAL ERROR - OVERFLOW (in recursive call to ");
23458	23482	// call printid from ProcCall
23459		- stack[base + 35LLU] = 1933LLU/throw to this address/;
	23483	+ stack[base + 35LLU] = 1935LLU/throw to this address/;
23460	23484	stack[base + 36LLU] = base;
23461		- stack[base + 37LLU] = 1934LLU;
	23485	+ stack[base + 37LLU] = 1936LLU;
23462	23486	// arguments for call to printid
23463	23487	stack[base + 38LLU] = stack[base + 24]/ceid/;
23464	23488	// set stack-base & callee-address

		@@ -23466,7 +23490,7 @@
23466	23490	label = 18446744073709551587LLU; // printid
23467	23491	break;
23468	23492	}
23469		- case 1933LLU: // copy-back deleter (printid to ProcCall)
	23493	+ case 1935LLU: // copy-back deleter (printid to ProcCall)
23470	23494	{
23471	23495	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
23472	23496	// copy mutable arguments back from call to printid

		@@ -23473,7 +23497,7 @@
23473	23497	label = 1612LLU; // continue to roll stack
23474	23498	break;
23475	23499	}
23476		- case 1934LLU: // return from printid to ProcCall
	23500	+ case 1936LLU: // return from printid to ProcCall
23477	23501	{
23478	23502	// copy mutable arguments back from call to printid
23479	23503	printf("%s", ")!\");");

		@@ -23481,9 +23505,9 @@
23481	23505	printf("%s", "\n }");
23482	23506	printf("%s", "\n Free(");
23483	23507	// call printnr from ProcCall
23484		- stack[base + 35LLU] = 1935LLU/throw to this address/;
	23508	+ stack[base + 35LLU] = 1937LLU/throw to this address/;
23485	23509	stack[base + 36LLU] = base;
23486		- stack[base + 37LLU] = 1936LLU;
	23510	+ stack[base + 37LLU] = 1938LLU;
23487	23511	// arguments for call to printnr
23488	23512	stack[base + 38LLU] = stack[base + 34]/recsztotal/;
23489	23513	// set stack-base & callee-address

		@@ -23491,7 +23515,7 @@
23491	23515	label = 18446744073709551590LLU; // printnr
23492	23516	break;
23493	23517	}
23494		- case 1935LLU: // copy-back deleter (printnr to ProcCall)
	23518	+ case 1937LLU: // copy-back deleter (printnr to ProcCall)
23495	23519	{
23496	23520	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23497	23521	// copy mutable arguments back from call to printnr

		@@ -23498,7 +23522,7 @@
23498	23522	label = 1612LLU; // continue to roll stack
23499	23523	break;
23500	23524	}
23501		- case 1936LLU: // return from printnr to ProcCall
	23525	+ case 1938LLU: // return from printnr to ProcCall
23502	23526	{
23503	23527	// copy mutable arguments back from call to printnr
23504	23528	printf("%s", "LLU + 1, sizeof(uint64_t), stack);");

		@@ -23509,9 +23533,9 @@
23509	23533	case 1606LLU: // alternative
23510	23534	{
23511	23535	// call add from ProcCall
23512		- stack[base + 33LLU] = 1937LLU/throw to this address/;
	23536	+ stack[base + 33LLU] = 1939LLU/throw to this address/;
23513	23537	stack[base + 34LLU] = base;
23514		- stack[base + 35LLU] = 1938LLU;
	23538	+ stack[base + 35LLU] = 1940LLU;
23515	23539	// arguments for call to add
23516	23540	stack[base + 37LLU] = 1LLU;
23517	23541	stack[base + 38LLU] = stack[base + 17]/label/;

		@@ -23520,7 +23544,7 @@
23520	23544	label = 18446744073709551605LLU; // add
23521	23545	break;
23522	23546	}
23523		- case 1937LLU: // copy-back deleter (add to ProcCall)
	23547	+ case 1939LLU: // copy-back deleter (add to ProcCall)
23524	23548	{
23525	23549	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23526	23550	// copy mutable arguments back from call to add

		@@ -23527,15 +23551,15 @@
23527	23551	label = 1604LLU; // continue to roll stack
23528	23552	break;
23529	23553	}
23530		- case 1938LLU: // return from add to ProcCall
	23554	+ case 1940LLU: // return from add to ProcCall
23531	23555	{
23532	23556	// copy mutable arguments back from call to add
23533	23557	// copy back results provided by call to add
23534	23558	stack[base + 17] = stack[base + 36LLU];
23535		- label = 1940LLU; // skip deleter
	23559	+ label = 1942LLU; // skip deleter
23536	23560	break;
23537	23561	}
23538		- case 1939LLU: // deleter
	23562	+ case 1941LLU: // deleter
23539	23563	{
23540	23564	// throw from ProcCall
23541	23565	if(!stack[base + 33])

		@@ -23548,14 +23572,14 @@
23548	23572	label = 1604LLU; // continue unrolling stack, delete next variable
23549	23573	break;
23550	23574	}
23551		- case 1940LLU: // skipped deleter
	23575	+ case 1942LLU: // skipped deleter
23552	23576	{
23553	23577	stack[base + 33] = stack[base + 17]/label/;
23554	23578	printf("%s", "\n // call ");
23555	23579	// call printid from ProcCall
23556		- stack[base + 34LLU] = 1941LLU/throw to this address/;
	23580	+ stack[base + 34LLU] = 1943LLU/throw to this address/;
23557	23581	stack[base + 35LLU] = base;
23558		- stack[base + 36LLU] = 1942LLU;
	23582	+ stack[base + 36LLU] = 1944LLU;
23559	23583	// arguments for call to printid
23560	23584	stack[base + 37LLU] = stack[base + 24]/ceid/;
23561	23585	// set stack-base & callee-address

		@@ -23563,21 +23587,21 @@
23563	23587	label = 18446744073709551587LLU; // printid
23564	23588	break;
23565	23589	}
23566		- case 1941LLU: // copy-back deleter (printid to ProcCall)
	23590	+ case 1943LLU: // copy-back deleter (printid to ProcCall)
23567	23591	{
23568	23592	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
23569	23593	// copy mutable arguments back from call to printid
23570		- label = 1939LLU; // continue to roll stack
	23594	+ label = 1941LLU; // continue to roll stack
23571	23595	break;
23572	23596	}
23573		- case 1942LLU: // return from printid to ProcCall
	23597	+ case 1944LLU: // return from printid to ProcCall
23574	23598	{
23575	23599	// copy mutable arguments back from call to printid
23576	23600	printf("%s", " from ");
23577	23601	// call printid from ProcCall
23578		- stack[base + 34LLU] = 1943LLU/throw to this address/;
	23602	+ stack[base + 34LLU] = 1945LLU/throw to this address/;
23579	23603	stack[base + 35LLU] = base;
23580		- stack[base + 36LLU] = 1944LLU;
	23604	+ stack[base + 36LLU] = 1946LLU;
23581	23605	// arguments for call to printid
23582	23606	stack[base + 37LLU] = stack[base + 8]/fnid/;
23583	23607	// set stack-base & callee-address

		@@ -23585,21 +23609,21 @@
23585	23609	label = 18446744073709551587LLU; // printid
23586	23610	break;
23587	23611	}
23588		- case 1943LLU: // copy-back deleter (printid to ProcCall)
	23612	+ case 1945LLU: // copy-back deleter (printid to ProcCall)
23589	23613	{
23590	23614	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
23591	23615	// copy mutable arguments back from call to printid
23592		- label = 1939LLU; // continue to roll stack
	23616	+ label = 1941LLU; // continue to roll stack
23593	23617	break;
23594	23618	}
23595		- case 1944LLU: // return from printid to ProcCall
	23619	+ case 1946LLU: // return from printid to ProcCall
23596	23620	{
23597	23621	// copy mutable arguments back from call to printid
23598	23622	stack[base + 30]/sum/ = 0;
23599	23623	// call add from ProcCall
23600		- stack[base + 34LLU] = 1945LLU/throw to this address/;
	23624	+ stack[base + 34LLU] = 1947LLU/throw to this address/;
23601	23625	stack[base + 35LLU] = base;
23602		- stack[base + 36LLU] = 1946LLU;
	23626	+ stack[base + 36LLU] = 1948LLU;
23603	23627	// arguments for call to add
23604	23628	stack[base + 38LLU] = stack[base + 4]/offset/;
23605	23629	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23608,22 +23632,22 @@
23608	23632	label = 18446744073709551605LLU; // add
23609	23633	break;
23610	23634	}
23611		- case 1945LLU: // copy-back deleter (add to ProcCall)
	23635	+ case 1947LLU: // copy-back deleter (add to ProcCall)
23612	23636	{
23613	23637	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23614	23638	// copy mutable arguments back from call to add
23615		- label = 1939LLU; // continue to roll stack
	23639	+ label = 1941LLU; // continue to roll stack
23616	23640	break;
23617	23641	}
23618		- case 1946LLU: // return from add to ProcCall
	23642	+ case 1948LLU: // return from add to ProcCall
23619	23643	{
23620	23644	// copy mutable arguments back from call to add
23621	23645	// copy back results provided by call to add
23622	23646	stack[base + 30] = stack[base + 37LLU];
23623	23647	// call add from ProcCall
23624		- stack[base + 34LLU] = 1947LLU/throw to this address/;
	23648	+ stack[base + 34LLU] = 1949LLU/throw to this address/;
23625	23649	stack[base + 35LLU] = base;
23626		- stack[base + 36LLU] = 1948LLU;
	23650	+ stack[base + 36LLU] = 1950LLU;
23627	23651	// arguments for call to add
23628	23652	stack[base + 38LLU] = stack[base + 10]/fnrescount/;
23629	23653	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23632,22 +23656,22 @@
23632	23656	label = 18446744073709551605LLU; // add
23633	23657	break;
23634	23658	}
23635		- case 1947LLU: // copy-back deleter (add to ProcCall)
	23659	+ case 1949LLU: // copy-back deleter (add to ProcCall)
23636	23660	{
23637	23661	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23638	23662	// copy mutable arguments back from call to add
23639		- label = 1939LLU; // continue to roll stack
	23663	+ label = 1941LLU; // continue to roll stack
23640	23664	break;
23641	23665	}
23642		- case 1948LLU: // return from add to ProcCall
	23666	+ case 1950LLU: // return from add to ProcCall
23643	23667	{
23644	23668	// copy mutable arguments back from call to add
23645	23669	// copy back results provided by call to add
23646	23670	stack[base + 30] = stack[base + 37LLU];
23647	23671	// call add from ProcCall
23648		- stack[base + 34LLU] = 1949LLU/throw to this address/;
	23672	+ stack[base + 34LLU] = 1951LLU/throw to this address/;
23649	23673	stack[base + 35LLU] = base;
23650		- stack[base + 36LLU] = 1950LLU;
	23674	+ stack[base + 36LLU] = 1952LLU;
23651	23675	// arguments for call to add
23652	23676	stack[base + 38LLU] = stack[base + 11]/fnargcount/;
23653	23677	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23656,22 +23680,22 @@
23656	23680	label = 18446744073709551605LLU; // add
23657	23681	break;
23658	23682	}
23659		- case 1949LLU: // copy-back deleter (add to ProcCall)
	23683	+ case 1951LLU: // copy-back deleter (add to ProcCall)
23660	23684	{
23661	23685	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23662	23686	// copy mutable arguments back from call to add
23663		- label = 1939LLU; // continue to roll stack
	23687	+ label = 1941LLU; // continue to roll stack
23664	23688	break;
23665	23689	}
23666		- case 1950LLU: // return from add to ProcCall
	23690	+ case 1952LLU: // return from add to ProcCall
23667	23691	{
23668	23692	// copy mutable arguments back from call to add
23669	23693	// copy back results provided by call to add
23670	23694	stack[base + 30] = stack[base + 37LLU];
23671	23695	// call add from ProcCall
23672		- stack[base + 34LLU] = 1951LLU/throw to this address/;
	23696	+ stack[base + 34LLU] = 1953LLU/throw to this address/;
23673	23697	stack[base + 35LLU] = base;
23674		- stack[base + 36LLU] = 1952LLU;
	23698	+ stack[base + 36LLU] = 1954LLU;
23675	23699	// arguments for call to add
23676	23700	stack[base + 38LLU] = 0LLU;
23677	23701	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23680,14 +23704,14 @@
23680	23704	label = 18446744073709551605LLU; // add
23681	23705	break;
23682	23706	}
23683		- case 1951LLU: // copy-back deleter (add to ProcCall)
	23707	+ case 1953LLU: // copy-back deleter (add to ProcCall)
23684	23708	{
23685	23709	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23686	23710	// copy mutable arguments back from call to add
23687		- label = 1939LLU; // continue to roll stack
	23711	+ label = 1941LLU; // continue to roll stack
23688	23712	break;
23689	23713	}
23690		- case 1952LLU: // return from add to ProcCall
	23714	+ case 1954LLU: // return from add to ProcCall
23691	23715	{
23692	23716	// copy mutable arguments back from call to add
23693	23717	// copy back results provided by call to add

		@@ -23694,9 +23718,9 @@
23694	23718	stack[base + 30] = stack[base + 37LLU];
23695	23719	printf("%s", "\n stack[base + ");
23696	23720	// call printnr from ProcCall
23697		- stack[base + 34LLU] = 1953LLU/throw to this address/;
	23721	+ stack[base + 34LLU] = 1955LLU/throw to this address/;
23698	23722	stack[base + 35LLU] = base;
23699		- stack[base + 36LLU] = 1954LLU;
	23723	+ stack[base + 36LLU] = 1956LLU;
23700	23724	// arguments for call to printnr
23701	23725	stack[base + 37LLU] = stack[base + 30]/sum/;
23702	23726	// set stack-base & callee-address

		@@ -23704,21 +23728,21 @@
23704	23728	label = 18446744073709551590LLU; // printnr
23705	23729	break;
23706	23730	}
23707		- case 1953LLU: // copy-back deleter (printnr to ProcCall)
	23731	+ case 1955LLU: // copy-back deleter (printnr to ProcCall)
23708	23732	{
23709	23733	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23710	23734	// copy mutable arguments back from call to printnr
23711		- label = 1939LLU; // continue to roll stack
	23735	+ label = 1941LLU; // continue to roll stack
23712	23736	break;
23713	23737	}
23714		- case 1954LLU: // return from printnr to ProcCall
	23738	+ case 1956LLU: // return from printnr to ProcCall
23715	23739	{
23716	23740	// copy mutable arguments back from call to printnr
23717	23741	printf("%s", "LLU] = ");
23718	23742	// call printnr from ProcCall
23719		- stack[base + 34LLU] = 1955LLU/throw to this address/;
	23743	+ stack[base + 34LLU] = 1957LLU/throw to this address/;
23720	23744	stack[base + 35LLU] = base;
23721		- stack[base + 36LLU] = 1956LLU;
	23745	+ stack[base + 36LLU] = 1958LLU;
23722	23746	// arguments for call to printnr
23723	23747	stack[base + 37LLU] = stack[base + 33]/labelfail/;
23724	23748	// set stack-base & callee-address

		@@ -23726,22 +23750,22 @@
23726	23750	label = 18446744073709551590LLU; // printnr
23727	23751	break;
23728	23752	}
23729		- case 1955LLU: // copy-back deleter (printnr to ProcCall)
	23753	+ case 1957LLU: // copy-back deleter (printnr to ProcCall)
23730	23754	{
23731	23755	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23732	23756	// copy mutable arguments back from call to printnr
23733		- label = 1939LLU; // continue to roll stack
	23757	+ label = 1941LLU; // continue to roll stack
23734	23758	break;
23735	23759	}
23736		- case 1956LLU: // return from printnr to ProcCall
	23760	+ case 1958LLU: // return from printnr to ProcCall
23737	23761	{
23738	23762	// copy mutable arguments back from call to printnr
23739	23763	printf("%s", "LLU/throw to this address/;");
23740	23764	stack[base + 30]/sum/ = 0;
23741	23765	// call add from ProcCall
23742		- stack[base + 34LLU] = 1957LLU/throw to this address/;
	23766	+ stack[base + 34LLU] = 1959LLU/throw to this address/;
23743	23767	stack[base + 35LLU] = base;
23744		- stack[base + 36LLU] = 1958LLU;
	23768	+ stack[base + 36LLU] = 1960LLU;
23745	23769	// arguments for call to add
23746	23770	stack[base + 38LLU] = stack[base + 4]/offset/;
23747	23771	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23750,22 +23774,22 @@
23750	23774	label = 18446744073709551605LLU; // add
23751	23775	break;
23752	23776	}
23753		- case 1957LLU: // copy-back deleter (add to ProcCall)
	23777	+ case 1959LLU: // copy-back deleter (add to ProcCall)
23754	23778	{
23755	23779	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23756	23780	// copy mutable arguments back from call to add
23757		- label = 1939LLU; // continue to roll stack
	23781	+ label = 1941LLU; // continue to roll stack
23758	23782	break;
23759	23783	}
23760		- case 1958LLU: // return from add to ProcCall
	23784	+ case 1960LLU: // return from add to ProcCall
23761	23785	{
23762	23786	// copy mutable arguments back from call to add
23763	23787	// copy back results provided by call to add
23764	23788	stack[base + 30] = stack[base + 37LLU];
23765	23789	// call add from ProcCall
23766		- stack[base + 34LLU] = 1959LLU/throw to this address/;
	23790	+ stack[base + 34LLU] = 1961LLU/throw to this address/;
23767	23791	stack[base + 35LLU] = base;
23768		- stack[base + 36LLU] = 1960LLU;
	23792	+ stack[base + 36LLU] = 1962LLU;
23769	23793	// arguments for call to add
23770	23794	stack[base + 38LLU] = stack[base + 10]/fnrescount/;
23771	23795	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23774,22 +23798,22 @@
23774	23798	label = 18446744073709551605LLU; // add
23775	23799	break;
23776	23800	}
23777		- case 1959LLU: // copy-back deleter (add to ProcCall)
	23801	+ case 1961LLU: // copy-back deleter (add to ProcCall)
23778	23802	{
23779	23803	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23780	23804	// copy mutable arguments back from call to add
23781		- label = 1939LLU; // continue to roll stack
	23805	+ label = 1941LLU; // continue to roll stack
23782	23806	break;
23783	23807	}
23784		- case 1960LLU: // return from add to ProcCall
	23808	+ case 1962LLU: // return from add to ProcCall
23785	23809	{
23786	23810	// copy mutable arguments back from call to add
23787	23811	// copy back results provided by call to add
23788	23812	stack[base + 30] = stack[base + 37LLU];
23789	23813	// call add from ProcCall
23790		- stack[base + 34LLU] = 1961LLU/throw to this address/;
	23814	+ stack[base + 34LLU] = 1963LLU/throw to this address/;
23791	23815	stack[base + 35LLU] = base;
23792		- stack[base + 36LLU] = 1962LLU;
	23816	+ stack[base + 36LLU] = 1964LLU;
23793	23817	// arguments for call to add
23794	23818	stack[base + 38LLU] = stack[base + 11]/fnargcount/;
23795	23819	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23798,22 +23822,22 @@
23798	23822	label = 18446744073709551605LLU; // add
23799	23823	break;
23800	23824	}
23801		- case 1961LLU: // copy-back deleter (add to ProcCall)
	23825	+ case 1963LLU: // copy-back deleter (add to ProcCall)
23802	23826	{
23803	23827	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23804	23828	// copy mutable arguments back from call to add
23805		- label = 1939LLU; // continue to roll stack
	23829	+ label = 1941LLU; // continue to roll stack
23806	23830	break;
23807	23831	}
23808		- case 1962LLU: // return from add to ProcCall
	23832	+ case 1964LLU: // return from add to ProcCall
23809	23833	{
23810	23834	// copy mutable arguments back from call to add
23811	23835	// copy back results provided by call to add
23812	23836	stack[base + 30] = stack[base + 37LLU];
23813	23837	// call add from ProcCall
23814		- stack[base + 34LLU] = 1963LLU/throw to this address/;
	23838	+ stack[base + 34LLU] = 1965LLU/throw to this address/;
23815	23839	stack[base + 35LLU] = base;
23816		- stack[base + 36LLU] = 1964LLU;
	23840	+ stack[base + 36LLU] = 1966LLU;
23817	23841	// arguments for call to add
23818	23842	stack[base + 38LLU] = 1LLU;
23819	23843	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23822,14 +23846,14 @@
23822	23846	label = 18446744073709551605LLU; // add
23823	23847	break;
23824	23848	}
23825		- case 1963LLU: // copy-back deleter (add to ProcCall)
	23849	+ case 1965LLU: // copy-back deleter (add to ProcCall)
23826	23850	{
23827	23851	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23828	23852	// copy mutable arguments back from call to add
23829		- label = 1939LLU; // continue to roll stack
	23853	+ label = 1941LLU; // continue to roll stack
23830	23854	break;
23831	23855	}
23832		- case 1964LLU: // return from add to ProcCall
	23856	+ case 1966LLU: // return from add to ProcCall
23833	23857	{
23834	23858	// copy mutable arguments back from call to add
23835	23859	// copy back results provided by call to add

		@@ -23836,9 +23860,9 @@
23836	23860	stack[base + 30] = stack[base + 37LLU];
23837	23861	printf("%s", "\n stack[base + ");
23838	23862	// call printnr from ProcCall
23839		- stack[base + 34LLU] = 1965LLU/throw to this address/;
	23863	+ stack[base + 34LLU] = 1967LLU/throw to this address/;
23840	23864	stack[base + 35LLU] = base;
23841		- stack[base + 36LLU] = 1966LLU;
	23865	+ stack[base + 36LLU] = 1968LLU;
23842	23866	// arguments for call to printnr
23843	23867	stack[base + 37LLU] = stack[base + 30]/sum/;
23844	23868	// set stack-base & callee-address

		@@ -23846,22 +23870,22 @@
23846	23870	label = 18446744073709551590LLU; // printnr
23847	23871	break;
23848	23872	}
23849		- case 1965LLU: // copy-back deleter (printnr to ProcCall)
	23873	+ case 1967LLU: // copy-back deleter (printnr to ProcCall)
23850	23874	{
23851	23875	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23852	23876	// copy mutable arguments back from call to printnr
23853		- label = 1939LLU; // continue to roll stack
	23877	+ label = 1941LLU; // continue to roll stack
23854	23878	break;
23855	23879	}
23856		- case 1966LLU: // return from printnr to ProcCall
	23880	+ case 1968LLU: // return from printnr to ProcCall
23857	23881	{
23858	23882	// copy mutable arguments back from call to printnr
23859	23883	printf("%s", "LLU] = base;");
23860	23884	stack[base + 30]/sum/ = 0;
23861	23885	// call add from ProcCall
23862		- stack[base + 34LLU] = 1967LLU/throw to this address/;
	23886	+ stack[base + 34LLU] = 1969LLU/throw to this address/;
23863	23887	stack[base + 35LLU] = base;
23864		- stack[base + 36LLU] = 1968LLU;
	23888	+ stack[base + 36LLU] = 1970LLU;
23865	23889	// arguments for call to add
23866	23890	stack[base + 38LLU] = stack[base + 4]/offset/;
23867	23891	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23870,22 +23894,22 @@
23870	23894	label = 18446744073709551605LLU; // add
23871	23895	break;
23872	23896	}
23873		- case 1967LLU: // copy-back deleter (add to ProcCall)
	23897	+ case 1969LLU: // copy-back deleter (add to ProcCall)
23874	23898	{
23875	23899	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23876	23900	// copy mutable arguments back from call to add
23877		- label = 1939LLU; // continue to roll stack
	23901	+ label = 1941LLU; // continue to roll stack
23878	23902	break;
23879	23903	}
23880		- case 1968LLU: // return from add to ProcCall
	23904	+ case 1970LLU: // return from add to ProcCall
23881	23905	{
23882	23906	// copy mutable arguments back from call to add
23883	23907	// copy back results provided by call to add
23884	23908	stack[base + 30] = stack[base + 37LLU];
23885	23909	// call add from ProcCall
23886		- stack[base + 34LLU] = 1969LLU/throw to this address/;
	23910	+ stack[base + 34LLU] = 1971LLU/throw to this address/;
23887	23911	stack[base + 35LLU] = base;
23888		- stack[base + 36LLU] = 1970LLU;
	23912	+ stack[base + 36LLU] = 1972LLU;
23889	23913	// arguments for call to add
23890	23914	stack[base + 38LLU] = stack[base + 10]/fnrescount/;
23891	23915	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23894,22 +23918,22 @@
23894	23918	label = 18446744073709551605LLU; // add
23895	23919	break;
23896	23920	}
23897		- case 1969LLU: // copy-back deleter (add to ProcCall)
	23921	+ case 1971LLU: // copy-back deleter (add to ProcCall)
23898	23922	{
23899	23923	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23900	23924	// copy mutable arguments back from call to add
23901		- label = 1939LLU; // continue to roll stack
	23925	+ label = 1941LLU; // continue to roll stack
23902	23926	break;
23903	23927	}
23904		- case 1970LLU: // return from add to ProcCall
	23928	+ case 1972LLU: // return from add to ProcCall
23905	23929	{
23906	23930	// copy mutable arguments back from call to add
23907	23931	// copy back results provided by call to add
23908	23932	stack[base + 30] = stack[base + 37LLU];
23909	23933	// call add from ProcCall
23910		- stack[base + 34LLU] = 1971LLU/throw to this address/;
	23934	+ stack[base + 34LLU] = 1973LLU/throw to this address/;
23911	23935	stack[base + 35LLU] = base;
23912		- stack[base + 36LLU] = 1972LLU;
	23936	+ stack[base + 36LLU] = 1974LLU;
23913	23937	// arguments for call to add
23914	23938	stack[base + 38LLU] = stack[base + 11]/fnargcount/;
23915	23939	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23918,22 +23942,22 @@
23918	23942	label = 18446744073709551605LLU; // add
23919	23943	break;
23920	23944	}
23921		- case 1971LLU: // copy-back deleter (add to ProcCall)
	23945	+ case 1973LLU: // copy-back deleter (add to ProcCall)
23922	23946	{
23923	23947	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23924	23948	// copy mutable arguments back from call to add
23925		- label = 1939LLU; // continue to roll stack
	23949	+ label = 1941LLU; // continue to roll stack
23926	23950	break;
23927	23951	}
23928		- case 1972LLU: // return from add to ProcCall
	23952	+ case 1974LLU: // return from add to ProcCall
23929	23953	{
23930	23954	// copy mutable arguments back from call to add
23931	23955	// copy back results provided by call to add
23932	23956	stack[base + 30] = stack[base + 37LLU];
23933	23957	// call add from ProcCall
23934		- stack[base + 34LLU] = 1973LLU/throw to this address/;
	23958	+ stack[base + 34LLU] = 1975LLU/throw to this address/;
23935	23959	stack[base + 35LLU] = base;
23936		- stack[base + 36LLU] = 1974LLU;
	23960	+ stack[base + 36LLU] = 1976LLU;
23937	23961	// arguments for call to add
23938	23962	stack[base + 38LLU] = 2LLU;
23939	23963	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -23942,22 +23966,22 @@
23942	23966	label = 18446744073709551605LLU; // add
23943	23967	break;
23944	23968	}
23945		- case 1973LLU: // copy-back deleter (add to ProcCall)
	23969	+ case 1975LLU: // copy-back deleter (add to ProcCall)
23946	23970	{
23947	23971	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23948	23972	// copy mutable arguments back from call to add
23949		- label = 1939LLU; // continue to roll stack
	23973	+ label = 1941LLU; // continue to roll stack
23950	23974	break;
23951	23975	}
23952		- case 1974LLU: // return from add to ProcCall
	23976	+ case 1976LLU: // return from add to ProcCall
23953	23977	{
23954	23978	// copy mutable arguments back from call to add
23955	23979	// copy back results provided by call to add
23956	23980	stack[base + 30] = stack[base + 37LLU];
23957	23981	// call add from ProcCall
23958		- stack[base + 34LLU] = 1975LLU/throw to this address/;
	23982	+ stack[base + 34LLU] = 1977LLU/throw to this address/;
23959	23983	stack[base + 35LLU] = base;
23960		- stack[base + 36LLU] = 1976LLU;
	23984	+ stack[base + 36LLU] = 1978LLU;
23961	23985	// arguments for call to add
23962	23986	stack[base + 38LLU] = 1LLU;
23963	23987	stack[base + 39LLU] = stack[base + 17]/label/;

		@@ -23966,14 +23990,14 @@
23966	23990	label = 18446744073709551605LLU; // add
23967	23991	break;
23968	23992	}
23969		- case 1975LLU: // copy-back deleter (add to ProcCall)
	23993	+ case 1977LLU: // copy-back deleter (add to ProcCall)
23970	23994	{
23971	23995	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
23972	23996	// copy mutable arguments back from call to add
23973		- label = 1939LLU; // continue to roll stack
	23997	+ label = 1941LLU; // continue to roll stack
23974	23998	break;
23975	23999	}
23976		- case 1976LLU: // return from add to ProcCall
	24000	+ case 1978LLU: // return from add to ProcCall
23977	24001	{
23978	24002	// copy mutable arguments back from call to add
23979	24003	// copy back results provided by call to add

		@@ -23980,9 +24004,9 @@
23980	24004	stack[base + 17] = stack[base + 37LLU];
23981	24005	printf("%s", "\n stack[base + ");
23982	24006	// call printnr from ProcCall
23983		- stack[base + 34LLU] = 1977LLU/throw to this address/;
	24007	+ stack[base + 34LLU] = 1979LLU/throw to this address/;
23984	24008	stack[base + 35LLU] = base;
23985		- stack[base + 36LLU] = 1978LLU;
	24009	+ stack[base + 36LLU] = 1980LLU;
23986	24010	// arguments for call to printnr
23987	24011	stack[base + 37LLU] = stack[base + 30]/sum/;
23988	24012	// set stack-base & callee-address

		@@ -23990,21 +24014,21 @@
23990	24014	label = 18446744073709551590LLU; // printnr
23991	24015	break;
23992	24016	}
23993		- case 1977LLU: // copy-back deleter (printnr to ProcCall)
	24017	+ case 1979LLU: // copy-back deleter (printnr to ProcCall)
23994	24018	{
23995	24019	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
23996	24020	// copy mutable arguments back from call to printnr
23997		- label = 1939LLU; // continue to roll stack
	24021	+ label = 1941LLU; // continue to roll stack
23998	24022	break;
23999	24023	}
24000		- case 1978LLU: // return from printnr to ProcCall
	24024	+ case 1980LLU: // return from printnr to ProcCall
24001	24025	{
24002	24026	// copy mutable arguments back from call to printnr
24003	24027	printf("%s", "LLU] = ");
24004	24028	// call printnr from ProcCall
24005		- stack[base + 34LLU] = 1979LLU/throw to this address/;
	24029	+ stack[base + 34LLU] = 1981LLU/throw to this address/;
24006	24030	stack[base + 35LLU] = base;
24007		- stack[base + 36LLU] = 1980LLU;
	24031	+ stack[base + 36LLU] = 1982LLU;
24008	24032	// arguments for call to printnr
24009	24033	stack[base + 37LLU] = stack[base + 17]/label/;
24010	24034	// set stack-base & callee-address

		@@ -24012,14 +24036,14 @@
24012	24036	label = 18446744073709551590LLU; // printnr
24013	24037	break;
24014	24038	}
24015		- case 1979LLU: // copy-back deleter (printnr to ProcCall)
	24039	+ case 1981LLU: // copy-back deleter (printnr to ProcCall)
24016	24040	{
24017	24041	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
24018	24042	// copy mutable arguments back from call to printnr
24019		- label = 1939LLU; // continue to roll stack
	24043	+ label = 1941LLU; // continue to roll stack
24020	24044	break;
24021	24045	}
24022		- case 1980LLU: // return from printnr to ProcCall
	24046	+ case 1982LLU: // return from printnr to ProcCall
24023	24047	{
24024	24048	// copy mutable arguments back from call to printnr
24025	24049	printf("%s", "LLU;");

		@@ -24026,9 +24050,9 @@
24026	24050	stack[base + 31]/n/ = stack[base + 29]/ceargcount/;
24027	24051	printf("%s", "\n // arguments for call to ");
24028	24052	// call printid from ProcCall
24029		- stack[base + 34LLU] = 1981LLU/throw to this address/;
	24053	+ stack[base + 34LLU] = 1983LLU/throw to this address/;
24030	24054	stack[base + 35LLU] = base;
24031		- stack[base + 36LLU] = 1982LLU;
	24055	+ stack[base + 36LLU] = 1984LLU;
24032	24056	// arguments for call to printid
24033	24057	stack[base + 37LLU] = stack[base + 24]/ceid/;
24034	24058	// set stack-base & callee-address

		@@ -24036,25 +24060,25 @@
24036	24060	label = 18446744073709551587LLU; // printid
24037	24061	break;
24038	24062	}
24039		- case 1981LLU: // copy-back deleter (printid to ProcCall)
	24063	+ case 1983LLU: // copy-back deleter (printid to ProcCall)
24040	24064	{
24041	24065	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
24042	24066	// copy mutable arguments back from call to printid
24043		- label = 1939LLU; // continue to roll stack
	24067	+ label = 1941LLU; // continue to roll stack
24044	24068	break;
24045	24069	}
24046		- case 1982LLU: // return from printid to ProcCall
	24070	+ case 1984LLU: // return from printid to ProcCall
24047	24071	{
24048	24072	// copy mutable arguments back from call to printid
24049	24073	flippedassign(stack[base + 22]/ceargtypes/, &stack[base + 34]);
24050		- label = 1983LLU; // start to repeat
	24074	+ label = 1985LLU; // start to repeat
24051	24075	break;
24052	24076	}
24053		- case 1983LLU: // repeat from here
	24077	+ case 1985LLU: // repeat from here
24054	24078	{
24055	24079	if(!stack[base + 34])
24056	24080	{
24057		- label = 1984LLU; // break loop
	24081	+ label = 1986LLU; // break loop
24058	24082	break;
24059	24083	}
24060	24084

		@@ -24063,9 +24087,9 @@
24063	24087	stack[base + 36]/previous/ = stack[base + 34];
24064	24088	stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
24065	24089	// call sub from ProcCall
24066		- stack[base + 37LLU] = 1986LLU/throw to this address/;
	24090	+ stack[base + 37LLU] = 1988LLU/throw to this address/;
24067	24091	stack[base + 38LLU] = base;
24068		- stack[base + 39LLU] = 1987LLU;
	24092	+ stack[base + 39LLU] = 1989LLU;
24069	24093	// arguments for call to sub
24070	24094	stack[base + 41LLU] = stack[base + 29]/ceargcount/;
24071	24095	stack[base + 42LLU] = stack[base + 31]/n/;

		@@ -24074,22 +24098,22 @@
24074	24098	label = 18446744073709551604LLU; // sub
24075	24099	break;
24076	24100	}
24077		- case 1986LLU: // copy-back deleter (sub to ProcCall)
	24101	+ case 1988LLU: // copy-back deleter (sub to ProcCall)
24078	24102	{
24079	24103	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
24080	24104	// copy mutable arguments back from call to sub
24081		- label = 1985LLU; // continue to roll stack
	24105	+ label = 1987LLU; // continue to roll stack
24082	24106	break;
24083	24107	}
24084		- case 1987LLU: // return from sub to ProcCall
	24108	+ case 1989LLU: // return from sub to ProcCall
24085	24109	{
24086	24110	// copy mutable arguments back from call to sub
24087	24111	// copy back results provided by call to sub
24088	24112	stack[base + 32] = stack[base + 40LLU];
24089	24113	// call sub from ProcCall
24090		- stack[base + 37LLU] = 1988LLU/throw to this address/;
	24114	+ stack[base + 37LLU] = 1990LLU/throw to this address/;
24091	24115	stack[base + 38LLU] = base;
24092		- stack[base + 39LLU] = 1989LLU;
	24116	+ stack[base + 39LLU] = 1991LLU;
24093	24117	// arguments for call to sub
24094	24118	stack[base + 41LLU] = stack[base + 31]/n/;
24095	24119	stack[base + 42LLU] = 1LLU;

		@@ -24098,14 +24122,14 @@
24098	24122	label = 18446744073709551604LLU; // sub
24099	24123	break;
24100	24124	}
24101		- case 1988LLU: // copy-back deleter (sub to ProcCall)
	24125	+ case 1990LLU: // copy-back deleter (sub to ProcCall)
24102	24126	{
24103	24127	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
24104	24128	// copy mutable arguments back from call to sub
24105		- label = 1985LLU; // continue to roll stack
	24129	+ label = 1987LLU; // continue to roll stack
24106	24130	break;
24107	24131	}
24108		- case 1989LLU: // return from sub to ProcCall
	24132	+ case 1991LLU: // return from sub to ProcCall
24109	24133	{
24110	24134	// copy mutable arguments back from call to sub
24111	24135	// copy back results provided by call to sub

		@@ -24112,15 +24136,15 @@
24112	24136	stack[base + 31] = stack[base + 40LLU];
24113	24137	if(!stack[base + 32]/index/)
24114	24138	{
24115		- label = 1990LLU; // jump to alternative
	24139	+ label = 1992LLU; // jump to alternative
24116	24140	break;
24117	24141	}
24118	24142
24119	24143	// consequent
24120	24144	// call matchsym from ProcCall
24121		- stack[base + 37LLU] = 1992LLU/throw to this address/;
	24145	+ stack[base + 37LLU] = 1994LLU/throw to this address/;
24122	24146	stack[base + 38LLU] = base;
24123		- stack[base + 39LLU] = 1993LLU;
	24147	+ stack[base + 39LLU] = 1995LLU;
24124	24148	// arguments for call to matchsym
24125	24149	stack[base + 40LLU] = stack[base + 8]/fnid/;
24126	24150	stack[base + 41LLU] = 44LLU;

		@@ -24130,33 +24154,33 @@
24130	24154	label = 212LLU; // matchsym
24131	24155	break;
24132	24156	}
24133		- case 1992LLU: // copy-back deleter (matchsym to ProcCall)
	24157	+ case 1994LLU: // copy-back deleter (matchsym to ProcCall)
24134	24158	{
24135	24159	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (matchsym to ProcCall)\n");
24136	24160	// copy mutable arguments back from call to matchsym
24137	24161	stack[base + 14]/lookahead/ = stack[base + 42LLU];
24138		- label = 1985LLU; // continue to roll stack
	24162	+ label = 1987LLU; // continue to roll stack
24139	24163	break;
24140	24164	}
24141		- case 1993LLU: // return from matchsym to ProcCall
	24165	+ case 1995LLU: // return from matchsym to ProcCall
24142	24166	{
24143	24167	// copy mutable arguments back from call to matchsym
24144	24168	stack[base + 14]/lookahead/ = stack[base + 42LLU];
24145		- label = 1991LLU; // consequent complete
	24169	+ label = 1993LLU; // consequent complete
24146	24170	break;
24147	24171	}
24148		- case 1990LLU: // alternative
	24172	+ case 1992LLU: // alternative
24149	24173	{
24150		- label = 1991LLU; // alternative complete
	24174	+ label = 1993LLU; // alternative complete
24151	24175	break;
24152	24176	}
24153		- case 1991LLU: // completed if-then-else
	24177	+ case 1993LLU: // completed if-then-else
24154	24178	{
24155	24179	stack[base + 30]/sum/ = 0;
24156	24180	// call add from ProcCall
24157		- stack[base + 37LLU] = 1994LLU/throw to this address/;
	24181	+ stack[base + 37LLU] = 1996LLU/throw to this address/;
24158	24182	stack[base + 38LLU] = base;
24159		- stack[base + 39LLU] = 1995LLU;
	24183	+ stack[base + 39LLU] = 1997LLU;
24160	24184	// arguments for call to add
24161	24185	stack[base + 41LLU] = stack[base + 4]/offset/;
24162	24186	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24165,22 +24189,22 @@
24165	24189	label = 18446744073709551605LLU; // add
24166	24190	break;
24167	24191	}
24168		- case 1994LLU: // copy-back deleter (add to ProcCall)
	24192	+ case 1996LLU: // copy-back deleter (add to ProcCall)
24169	24193	{
24170	24194	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24171	24195	// copy mutable arguments back from call to add
24172		- label = 1985LLU; // continue to roll stack
	24196	+ label = 1987LLU; // continue to roll stack
24173	24197	break;
24174	24198	}
24175		- case 1995LLU: // return from add to ProcCall
	24199	+ case 1997LLU: // return from add to ProcCall
24176	24200	{
24177	24201	// copy mutable arguments back from call to add
24178	24202	// copy back results provided by call to add
24179	24203	stack[base + 30] = stack[base + 40LLU];
24180	24204	// call add from ProcCall
24181		- stack[base + 37LLU] = 1996LLU/throw to this address/;
	24205	+ stack[base + 37LLU] = 1998LLU/throw to this address/;
24182	24206	stack[base + 38LLU] = base;
24183		- stack[base + 39LLU] = 1997LLU;
	24207	+ stack[base + 39LLU] = 1999LLU;
24184	24208	// arguments for call to add
24185	24209	stack[base + 41LLU] = 3LLU;
24186	24210	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24189,22 +24213,22 @@
24189	24213	label = 18446744073709551605LLU; // add
24190	24214	break;
24191	24215	}
24192		- case 1996LLU: // copy-back deleter (add to ProcCall)
	24216	+ case 1998LLU: // copy-back deleter (add to ProcCall)
24193	24217	{
24194	24218	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24195	24219	// copy mutable arguments back from call to add
24196		- label = 1985LLU; // continue to roll stack
	24220	+ label = 1987LLU; // continue to roll stack
24197	24221	break;
24198	24222	}
24199		- case 1997LLU: // return from add to ProcCall
	24223	+ case 1999LLU: // return from add to ProcCall
24200	24224	{
24201	24225	// copy mutable arguments back from call to add
24202	24226	// copy back results provided by call to add
24203	24227	stack[base + 30] = stack[base + 40LLU];
24204	24228	// call add from ProcCall
24205		- stack[base + 37LLU] = 1998LLU/throw to this address/;
	24229	+ stack[base + 37LLU] = 2000LLU/throw to this address/;
24206	24230	stack[base + 38LLU] = base;
24207		- stack[base + 39LLU] = 1999LLU;
	24231	+ stack[base + 39LLU] = 2001LLU;
24208	24232	// arguments for call to add
24209	24233	stack[base + 41LLU] = stack[base + 10]/fnrescount/;
24210	24234	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24213,22 +24237,22 @@
24213	24237	label = 18446744073709551605LLU; // add
24214	24238	break;
24215	24239	}
24216		- case 1998LLU: // copy-back deleter (add to ProcCall)
	24240	+ case 2000LLU: // copy-back deleter (add to ProcCall)
24217	24241	{
24218	24242	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24219	24243	// copy mutable arguments back from call to add
24220		- label = 1985LLU; // continue to roll stack
	24244	+ label = 1987LLU; // continue to roll stack
24221	24245	break;
24222	24246	}
24223		- case 1999LLU: // return from add to ProcCall
	24247	+ case 2001LLU: // return from add to ProcCall
24224	24248	{
24225	24249	// copy mutable arguments back from call to add
24226	24250	// copy back results provided by call to add
24227	24251	stack[base + 30] = stack[base + 40LLU];
24228	24252	// call add from ProcCall
24229		- stack[base + 37LLU] = 2000LLU/throw to this address/;
	24253	+ stack[base + 37LLU] = 2002LLU/throw to this address/;
24230	24254	stack[base + 38LLU] = base;
24231		- stack[base + 39LLU] = 2001LLU;
	24255	+ stack[base + 39LLU] = 2003LLU;
24232	24256	// arguments for call to add
24233	24257	stack[base + 41LLU] = stack[base + 11]/fnargcount/;
24234	24258	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24237,22 +24261,22 @@
24237	24261	label = 18446744073709551605LLU; // add
24238	24262	break;
24239	24263	}
24240		- case 2000LLU: // copy-back deleter (add to ProcCall)
	24264	+ case 2002LLU: // copy-back deleter (add to ProcCall)
24241	24265	{
24242	24266	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24243	24267	// copy mutable arguments back from call to add
24244		- label = 1985LLU; // continue to roll stack
	24268	+ label = 1987LLU; // continue to roll stack
24245	24269	break;
24246	24270	}
24247		- case 2001LLU: // return from add to ProcCall
	24271	+ case 2003LLU: // return from add to ProcCall
24248	24272	{
24249	24273	// copy mutable arguments back from call to add
24250	24274	// copy back results provided by call to add
24251	24275	stack[base + 30] = stack[base + 40LLU];
24252	24276	// call add from ProcCall
24253		- stack[base + 37LLU] = 2002LLU/throw to this address/;
	24277	+ stack[base + 37LLU] = 2004LLU/throw to this address/;
24254	24278	stack[base + 38LLU] = base;
24255		- stack[base + 39LLU] = 2003LLU;
	24279	+ stack[base + 39LLU] = 2005LLU;
24256	24280	// arguments for call to add
24257	24281	stack[base + 41LLU] = stack[base + 28]/cerescount/;
24258	24282	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24261,22 +24285,22 @@
24261	24285	label = 18446744073709551605LLU; // add
24262	24286	break;
24263	24287	}
24264		- case 2002LLU: // copy-back deleter (add to ProcCall)
	24288	+ case 2004LLU: // copy-back deleter (add to ProcCall)
24265	24289	{
24266	24290	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24267	24291	// copy mutable arguments back from call to add
24268		- label = 1985LLU; // continue to roll stack
	24292	+ label = 1987LLU; // continue to roll stack
24269	24293	break;
24270	24294	}
24271		- case 2003LLU: // return from add to ProcCall
	24295	+ case 2005LLU: // return from add to ProcCall
24272	24296	{
24273	24297	// copy mutable arguments back from call to add
24274	24298	// copy back results provided by call to add
24275	24299	stack[base + 30] = stack[base + 40LLU];
24276	24300	// call add from ProcCall
24277		- stack[base + 37LLU] = 2004LLU/throw to this address/;
	24301	+ stack[base + 37LLU] = 2006LLU/throw to this address/;
24278	24302	stack[base + 38LLU] = base;
24279		- stack[base + 39LLU] = 2005LLU;
	24303	+ stack[base + 39LLU] = 2007LLU;
24280	24304	// arguments for call to add
24281	24305	stack[base + 41LLU] = stack[base + 32]/index/;
24282	24306	stack[base + 42LLU] = stack[base + 30]/sum/;

		@@ -24285,22 +24309,22 @@
24285	24309	label = 18446744073709551605LLU; // add
24286	24310	break;
24287	24311	}
24288		- case 2004LLU: // copy-back deleter (add to ProcCall)
	24312	+ case 2006LLU: // copy-back deleter (add to ProcCall)
24289	24313	{
24290	24314	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
24291	24315	// copy mutable arguments back from call to add
24292		- label = 1985LLU; // continue to roll stack
	24316	+ label = 1987LLU; // continue to roll stack
24293	24317	break;
24294	24318	}
24295		- case 2005LLU: // return from add to ProcCall
	24319	+ case 2007LLU: // return from add to ProcCall
24296	24320	{
24297	24321	// copy mutable arguments back from call to add
24298	24322	// copy back results provided by call to add
24299	24323	stack[base + 30] = stack[base + 40LLU];
24300	24324	// call ParseToken from ProcCall
24301		- stack[base + 37LLU] = 2006LLU/throw to this address/;
	24325	+ stack[base + 37LLU] = 2008LLU/throw to this address/;
24302	24326	stack[base + 38LLU] = base;
24303		- stack[base + 39LLU] = 2007LLU;
	24327	+ stack[base + 39LLU] = 2009LLU;
24304	24328	// arguments for call to ParseToken
24305	24329	stack[base + 42LLU] = stack[base + 14]/lookahead/;
24306	24330	// set stack-base & callee-address

		@@ -24308,15 +24332,15 @@
24308	24332	label = 3LLU; // ParseToken
24309	24333	break;
24310	24334	}
24311		- case 2006LLU: // copy-back deleter (ParseToken to ProcCall)
	24335	+ case 2008LLU: // copy-back deleter (ParseToken to ProcCall)
24312	24336	{
24313	24337	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (ParseToken to ProcCall)\n");
24314	24338	// copy mutable arguments back from call to ParseToken
24315	24339	stack[base + 14]/lookahead/ = stack[base + 42LLU];
24316		- label = 1985LLU; // continue to roll stack
	24340	+ label = 1987LLU; // continue to roll stack
24317	24341	break;
24318	24342	}
24319		- case 2007LLU: // return from ParseToken to ProcCall
	24343	+ case 2009LLU: // return from ParseToken to ProcCall
24320	24344	{
24321	24345	// copy mutable arguments back from call to ParseToken
24322	24346	stack[base + 14]/lookahead/ = stack[base + 42LLU];

		@@ -24324,9 +24348,9 @@
24324	24348	stack[base + 15] = stack[base + 40LLU];
24325	24349	stack[base + 16] = stack[base + 41LLU];
24326	24350	// call isncs from ProcCall
24327		- stack[base + 37LLU] = 2008LLU/throw to this address/;
	24351	+ stack[base + 37LLU] = 2010LLU/throw to this address/;
24328	24352	stack[base + 38LLU] = base;
24329		- stack[base + 39LLU] = 2009LLU;
	24353	+ stack[base + 39LLU] = 2011LLU;
24330	24354	// arguments for call to isncs
24331	24355	stack[base + 41LLU] = stack[base + 15]/variant/;
24332	24356	// set stack-base & callee-address

		@@ -24334,14 +24358,14 @@
24334	24358	label = 272LLU; // isncs
24335	24359	break;
24336	24360	}
24337		- case 2008LLU: // copy-back deleter (isncs to ProcCall)
	24361	+ case 2010LLU: // copy-back deleter (isncs to ProcCall)
24338	24362	{
24339	24363	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (isncs to ProcCall)\n");
24340	24364	// copy mutable arguments back from call to isncs
24341		- label = 1985LLU; // continue to roll stack
	24365	+ label = 1987LLU; // continue to roll stack
24342	24366	break;
24343	24367	}
24344		- case 2009LLU: // return from isncs to ProcCall
	24368	+ case 2011LLU: // return from isncs to ProcCall
24345	24369	{
24346	24370	// copy mutable arguments back from call to isncs
24347	24371	// copy back results provided by call to isncs

		@@ -24348,7 +24372,7 @@
24348	24372	stack[base + 18] = stack[base + 40LLU];
24349	24373	if(!stack[base + 18]/isequal/)
24350	24374	{
24351		- label = 2010LLU; // jump to alternative
	24375	+ label = 2012LLU; // jump to alternative
24352	24376	break;
24353	24377	}
24354	24378

		@@ -24355,7 +24379,7 @@
24355	24379	// consequent
24356	24380	if(/param/0 != ((uint64_t )(stack[base + 35]/param*/))[0])
24357	24381	{
24358		- label = 2013LLU; // jump to alternative
	24382	+ label = 2015LLU; // jump to alternative
24359	24383	break;
24360	24384	}
24361	24385

		@@ -24365,7 +24389,7 @@
24365	24389	// case
24366	24390	if(/typeid/0 != ((uint64_t )(stack[base + 37]/typeid*/))[0])
24367	24391	{
24368		- label = 2016LLU; // jump to alternative
	24392	+ label = 2018LLU; // jump to alternative
24369	24393	break;
24370	24394	}
24371	24395

		@@ -24374,9 +24398,9 @@
24374	24398
24375	24399	// case
24376	24400	// call mktypename from ProcCall
24377		- stack[base + 42LLU] = 2018LLU/throw to this address/;
	24401	+ stack[base + 42LLU] = 2020LLU/throw to this address/;
24378	24402	stack[base + 43LLU] = base;
24379		- stack[base + 44LLU] = 2019LLU;
	24403	+ stack[base + 44LLU] = 2021LLU;
24380	24404	// arguments for call to mktypename
24381	24405	stack[base + 46LLU] = 881834713755418624LLU;
24382	24406	// set stack-base & callee-address

		@@ -24384,14 +24408,14 @@
24384	24408	label = 300LLU; // mktypename
24385	24409	break;
24386	24410	}
24387		- case 2018LLU: // copy-back deleter (mktypename to ProcCall)
	24411	+ case 2020LLU: // copy-back deleter (mktypename to ProcCall)
24388	24412	{
24389	24413	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (mktypename to ProcCall)\n");
24390	24414	// copy mutable arguments back from call to mktypename
24391		- label = 2017LLU; // continue to roll stack
	24415	+ label = 2019LLU; // continue to roll stack
24392	24416	break;
24393	24417	}
24394		- case 2019LLU: // return from mktypename to ProcCall
	24418	+ case 2021LLU: // return from mktypename to ProcCall
24395	24419	{
24396	24420	// copy mutable arguments back from call to mktypename
24397	24421	// copy back results provided by call to mktypename

		@@ -24399,7 +24423,7 @@
24399	24423	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
24400	24424	if(!newstack)
24401	24425	{
24402		- label = 2017LLU; // throw: begin to unroll stack
	24426	+ label = 2019LLU; // throw: begin to unroll stack
24403	24427	break;
24404	24428	}
24405	24429

		@@ -24406,9 +24430,9 @@
24406	24430	newstack[15LLU] = 9876543210LLU; // overflow-marker
24407	24431	// call equtype from ProcCall
24408	24432	newstack[0] = (uint64_t)stack; // backup stack location
24409		- newstack[1] = 2020LLU;
	24433	+ newstack[1] = 2022LLU;
24410	24434	newstack[2] = base;
24411		- newstack[3] = 2021LLU;
	24435	+ newstack[3] = 2023LLU;
24412	24436	// arguments for call to equtype
24413	24437	newstack[5LLU] = stack[base + 41]/type/;
24414	24438	newstack[6LLU] = stack[base + 39]/expected/;

		@@ -24418,7 +24442,7 @@
24418	24442	label = 342LLU; // equtype
24419	24443	break;
24420	24444	}
24421		- case 2020LLU: // copy-back deleter (equtype to ProcCall)
	24445	+ case 2022LLU: // copy-back deleter (equtype to ProcCall)
24422	24446	{
24423	24447	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
24424	24448	uint64_t oldstack = (uint64_t )stack[0];

		@@ -24430,10 +24454,10 @@
24430	24454	}
24431	24455	Free(15LLU + 1, sizeof(uint64_t), stack);
24432	24456	stack = oldstack;
24433		- label = 2017LLU; // continue to unroll stack
	24457	+ label = 2019LLU; // continue to unroll stack
24434	24458	break;
24435	24459	}
24436		- case 2021LLU: // return from equtype to ProcCall
	24460	+ case 2023LLU: // return from equtype to ProcCall
24437	24461	{
24438	24462	uint64_t oldstack = (uint64_t )stack[0];
24439	24463	// copy mutable arguments back from call to equtype

		@@ -24448,21 +24472,21 @@
24448	24472	stack = oldstack;
24449	24473	if(!stack[base + 18]/isequal/)
24450	24474	{
24451		- label = 2022LLU; // jump to alternative
	24475	+ label = 2024LLU; // jump to alternative
24452	24476	break;
24453	24477	}
24454	24478
24455	24479	// consequent
24456		- label = 2023LLU; // consequent complete
	24480	+ label = 2025LLU; // consequent complete
24457	24481	break;
24458	24482	}
24459		- case 2022LLU: // alternative
	24483	+ case 2024LLU: // alternative
24460	24484	{
24461	24485	fprintf(stderr, "%s", "in function ");
24462	24486	// call reportid from ProcCall
24463		- stack[base + 42LLU] = 2024LLU/throw to this address/;
	24487	+ stack[base + 42LLU] = 2026LLU/throw to this address/;
24464	24488	stack[base + 43LLU] = base;
24465		- stack[base + 44LLU] = 2025LLU;
	24489	+ stack[base + 44LLU] = 2027LLU;
24466	24490	// arguments for call to reportid
24467	24491	stack[base + 45LLU] = stack[base + 8]/fnid/;
24468	24492	// set stack-base & callee-address

		@@ -24470,21 +24494,21 @@
24470	24494	label = 18446744073709551586LLU; // reportid
24471	24495	break;
24472	24496	}
24473		- case 2024LLU: // copy-back deleter (reportid to ProcCall)
	24497	+ case 2026LLU: // copy-back deleter (reportid to ProcCall)
24474	24498	{
24475	24499	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
24476	24500	// copy mutable arguments back from call to reportid
24477		- label = 2017LLU; // continue to roll stack
	24501	+ label = 2019LLU; // continue to roll stack
24478	24502	break;
24479	24503	}
24480		- case 2025LLU: // return from reportid to ProcCall
	24504	+ case 2027LLU: // return from reportid to ProcCall
24481	24505	{
24482	24506	// copy mutable arguments back from call to reportid
24483	24507	fprintf(stderr, "%s", " call to ");
24484	24508	// call reportid from ProcCall
24485		- stack[base + 42LLU] = 2026LLU/throw to this address/;
	24509	+ stack[base + 42LLU] = 2028LLU/throw to this address/;
24486	24510	stack[base + 43LLU] = base;
24487		- stack[base + 44LLU] = 2027LLU;
	24511	+ stack[base + 44LLU] = 2029LLU;
24488	24512	// arguments for call to reportid
24489	24513	stack[base + 45LLU] = stack[base + 24]/ceid/;
24490	24514	// set stack-base & callee-address

		@@ -24492,21 +24516,21 @@
24492	24516	label = 18446744073709551586LLU; // reportid
24493	24517	break;
24494	24518	}
24495		- case 2026LLU: // copy-back deleter (reportid to ProcCall)
	24519	+ case 2028LLU: // copy-back deleter (reportid to ProcCall)
24496	24520	{
24497	24521	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
24498	24522	// copy mutable arguments back from call to reportid
24499		- label = 2017LLU; // continue to roll stack
	24523	+ label = 2019LLU; // continue to roll stack
24500	24524	break;
24501	24525	}
24502		- case 2027LLU: // return from reportid to ProcCall
	24526	+ case 2029LLU: // return from reportid to ProcCall
24503	24527	{
24504	24528	// copy mutable arguments back from call to reportid
24505	24529	fprintf(stderr, "%s", " at position ");
24506	24530	// call reportnr from ProcCall
24507		- stack[base + 42LLU] = 2028LLU/throw to this address/;
	24531	+ stack[base + 42LLU] = 2030LLU/throw to this address/;
24508	24532	stack[base + 43LLU] = base;
24509		- stack[base + 44LLU] = 2029LLU;
	24533	+ stack[base + 44LLU] = 2031LLU;
24510	24534	// arguments for call to reportnr
24511	24535	stack[base + 45LLU] = stack[base + 32]/index/;
24512	24536	// set stack-base & callee-address

		@@ -24514,14 +24538,14 @@
24514	24538	label = 18446744073709551589LLU; // reportnr
24515	24539	break;
24516	24540	}
24517		- case 2028LLU: // copy-back deleter (reportnr to ProcCall)
	24541	+ case 2030LLU: // copy-back deleter (reportnr to ProcCall)
24518	24542	{
24519	24543	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
24520	24544	// copy mutable arguments back from call to reportnr
24521		- label = 2017LLU; // continue to roll stack
	24545	+ label = 2019LLU; // continue to roll stack
24522	24546	break;
24523	24547	}
24524		- case 2029LLU: // return from reportnr to ProcCall
	24548	+ case 2031LLU: // return from reportnr to ProcCall
24525	24549	{
24526	24550	// copy mutable arguments back from call to reportnr
24527	24551	fprintf(stderr, "%s", " expected parameter of type ");

		@@ -24528,7 +24552,7 @@
24528	24552	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
24529	24553	if(!newstack)
24530	24554	{
24531		- label = 2017LLU; // throw: begin to unroll stack
	24555	+ label = 2019LLU; // throw: begin to unroll stack
24532	24556	break;
24533	24557	}
24534	24558

		@@ -24535,9 +24559,9 @@
24535	24559	newstack[10LLU] = 9876543210LLU; // overflow-marker
24536	24560	// call reporttype from ProcCall
24537	24561	newstack[0] = (uint64_t)stack; // backup stack location
24538		- newstack[1] = 2030LLU;
	24562	+ newstack[1] = 2032LLU;
24539	24563	newstack[2] = base;
24540		- newstack[3] = 2031LLU;
	24564	+ newstack[3] = 2033LLU;
24541	24565	// arguments for call to reporttype
24542	24566	newstack[4LLU] = stack[base + 39]/expected/;
24543	24567	stack = newstack;

		@@ -24546,7 +24570,7 @@
24546	24570	label = 316LLU; // reporttype
24547	24571	break;
24548	24572	}
24549		- case 2030LLU: // copy-back deleter (reporttype to ProcCall)
	24573	+ case 2032LLU: // copy-back deleter (reporttype to ProcCall)
24550	24574	{
24551	24575	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
24552	24576	uint64_t oldstack = (uint64_t )stack[0];

		@@ -24558,10 +24582,10 @@
24558	24582	}
24559	24583	Free(10LLU + 1, sizeof(uint64_t), stack);
24560	24584	stack = oldstack;
24561		- label = 2017LLU; // continue to unroll stack
	24585	+ label = 2019LLU; // continue to unroll stack
24562	24586	break;
24563	24587	}
24564		- case 2031LLU: // return from reporttype to ProcCall
	24588	+ case 2033LLU: // return from reporttype to ProcCall
24565	24589	{
24566	24590	uint64_t oldstack = (uint64_t )stack[0];
24567	24591	// copy mutable arguments back from call to reporttype

		@@ -24575,10 +24599,10 @@
24575	24599	fprintf(stderr, "%s", " but found constant-argument of type u64");
24576	24600	fprintf(stderr, "%s", "\n");
24577	24601	exit(-1);
24578		- label = 2023LLU; // alternative complete
	24602	+ label = 2025LLU; // alternative complete
24579	24603	break;
24580	24604	}
24581		- case 2023LLU: // completed if-then-else
	24605	+ case 2025LLU: // completed if-then-else
24582	24606	{
24583	24607
24584	24608	uint64_t newstack = (uint64_t )(stack[base + 41] - sizeof(uint64_t) * 4);

		@@ -24586,7 +24610,7 @@
24586	24610	newstack[0] = (uint64_t)stack; // backup stack location
24587	24611	newstack[1] = 1234567890;
24588	24612	newstack[2] = base;
24589		- newstack[3] = 2032LLU;
	24613	+ newstack[3] = 2034LLU;
24590	24614	stack = newstack;
24591	24615	// set stack-base & callee-address
24592	24616	base = 4/deloffset/;

		@@ -24593,7 +24617,7 @@
24593	24617	label = 296LLU; // ~type
24594	24618	break;
24595	24619	}
24596		- case 2032LLU: // return from ~type to ProcCall
	24620	+ case 2034LLU: // return from ~type to ProcCall
24597	24621	{
24598	24622	stack = (uint64_t *)stack[0];
24599	24623	// releasing toplevel container

		@@ -24601,26 +24625,26 @@
24601	24625
24602	24626	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
24603	24627	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
24604		- label = 2015LLU; // case complete
	24628	+ label = 2017LLU; // case complete
24605	24629	break;
24606	24630	}
24607		- case 2017LLU: // copy-back deleter (switch)
	24631	+ case 2019LLU: // copy-back deleter (switch)
24608	24632	{
24609	24633	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
24610	24634	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
24611		- label = 2014LLU; // continue to unroll stack
	24635	+ label = 2016LLU; // continue to unroll stack
24612	24636	break;
24613	24637	}
24614		- case 2016LLU: // try next case
	24638	+ case 2018LLU: // try next case
24615	24639	{
24616	24640	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
24617	24641	exit(-1);
24618	24642	}
24619		- case 2015LLU: // completed switch
	24643	+ case 2017LLU: // completed switch
24620	24644	{
24621	24645	if(!stack[base + 38]/mutable/)
24622	24646	{
24623		- label = 2033LLU; // jump to alternative
	24647	+ label = 2035LLU; // jump to alternative
24624	24648	break;
24625	24649	}
24626	24650

		@@ -24627,9 +24651,9 @@
24627	24651	// consequent
24628	24652	fprintf(stderr, "%s", "in function ");
24629	24653	// call reportid from ProcCall
24630		- stack[base + 39LLU] = 2035LLU/throw to this address/;
	24654	+ stack[base + 39LLU] = 2037LLU/throw to this address/;
24631	24655	stack[base + 40LLU] = base;
24632		- stack[base + 41LLU] = 2036LLU;
	24656	+ stack[base + 41LLU] = 2038LLU;
24633	24657	// arguments for call to reportid
24634	24658	stack[base + 42LLU] = stack[base + 8]/fnid/;
24635	24659	// set stack-base & callee-address

		@@ -24637,21 +24661,21 @@
24637	24661	label = 18446744073709551586LLU; // reportid
24638	24662	break;
24639	24663	}
24640		- case 2035LLU: // copy-back deleter (reportid to ProcCall)
	24664	+ case 2037LLU: // copy-back deleter (reportid to ProcCall)
24641	24665	{
24642	24666	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
24643	24667	// copy mutable arguments back from call to reportid
24644		- label = 2014LLU; // continue to roll stack
	24668	+ label = 2016LLU; // continue to roll stack
24645	24669	break;
24646	24670	}
24647		- case 2036LLU: // return from reportid to ProcCall
	24671	+ case 2038LLU: // return from reportid to ProcCall
24648	24672	{
24649	24673	// copy mutable arguments back from call to reportid
24650	24674	fprintf(stderr, "%s", ", calling ");
24651	24675	// call reportid from ProcCall
24652		- stack[base + 39LLU] = 2037LLU/throw to this address/;
	24676	+ stack[base + 39LLU] = 2039LLU/throw to this address/;
24653	24677	stack[base + 40LLU] = base;
24654		- stack[base + 41LLU] = 2038LLU;
	24678	+ stack[base + 41LLU] = 2040LLU;
24655	24679	// arguments for call to reportid
24656	24680	stack[base + 42LLU] = stack[base + 24]/ceid/;
24657	24681	// set stack-base & callee-address

		@@ -24659,22 +24683,22 @@
24659	24683	label = 18446744073709551586LLU; // reportid
24660	24684	break;
24661	24685	}
24662		- case 2037LLU: // copy-back deleter (reportid to ProcCall)
	24686	+ case 2039LLU: // copy-back deleter (reportid to ProcCall)
24663	24687	{
24664	24688	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
24665	24689	// copy mutable arguments back from call to reportid
24666		- label = 2014LLU; // continue to roll stack
	24690	+ label = 2016LLU; // continue to roll stack
24667	24691	break;
24668	24692	}
24669		- case 2038LLU: // return from reportid to ProcCall
	24693	+ case 2040LLU: // return from reportid to ProcCall
24670	24694	{
24671	24695	// copy mutable arguments back from call to reportid
24672	24696	fprintf(stderr, "%s", ": ");
24673	24697	fprintf(stderr, "%s", "can't use constant argument ");
24674	24698	// call printnr from ProcCall
24675		- stack[base + 39LLU] = 2039LLU/throw to this address/;
	24699	+ stack[base + 39LLU] = 2041LLU/throw to this address/;
24676	24700	stack[base + 40LLU] = base;
24677		- stack[base + 41LLU] = 2040LLU;
	24701	+ stack[base + 41LLU] = 2042LLU;
24678	24702	// arguments for call to printnr
24679	24703	stack[base + 42LLU] = stack[base + 16]/content/;
24680	24704	// set stack-base & callee-address

		@@ -24682,21 +24706,21 @@
24682	24706	label = 18446744073709551590LLU; // printnr
24683	24707	break;
24684	24708	}
24685		- case 2039LLU: // copy-back deleter (printnr to ProcCall)
	24709	+ case 2041LLU: // copy-back deleter (printnr to ProcCall)
24686	24710	{
24687	24711	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
24688	24712	// copy mutable arguments back from call to printnr
24689		- label = 2014LLU; // continue to roll stack
	24713	+ label = 2016LLU; // continue to roll stack
24690	24714	break;
24691	24715	}
24692		- case 2040LLU: // return from printnr to ProcCall
	24716	+ case 2042LLU: // return from printnr to ProcCall
24693	24717	{
24694	24718	// copy mutable arguments back from call to printnr
24695	24719	printf("%s", " for mutable parameter ");
24696	24720	// call reportti from ProcCall
24697		- stack[base + 39LLU] = 2041LLU/throw to this address/;
	24721	+ stack[base + 39LLU] = 2043LLU/throw to this address/;
24698	24722	stack[base + 40LLU] = base;
24699		- stack[base + 41LLU] = 2042LLU;
	24723	+ stack[base + 41LLU] = 2044LLU;
24700	24724	// arguments for call to reportti
24701	24725	stack[base + 42LLU] = stack[base + 37]/typeid/;
24702	24726	// set stack-base & callee-address

		@@ -24704,52 +24728,52 @@
24704	24728	label = 370LLU; // reportti
24705	24729	break;
24706	24730	}
24707		- case 2041LLU: // copy-back deleter (reportti to ProcCall)
	24731	+ case 2043LLU: // copy-back deleter (reportti to ProcCall)
24708	24732	{
24709	24733	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportti to ProcCall)\n");
24710	24734	// copy mutable arguments back from call to reportti
24711		- label = 2014LLU; // continue to roll stack
	24735	+ label = 2016LLU; // continue to roll stack
24712	24736	break;
24713	24737	}
24714		- case 2042LLU: // return from reportti to ProcCall
	24738	+ case 2044LLU: // return from reportti to ProcCall
24715	24739	{
24716	24740	// copy mutable arguments back from call to reportti
24717	24741	fprintf(stderr, "%s", "\n");
24718	24742	exit(-1);
24719		- label = 2034LLU; // consequent complete
	24743	+ label = 2036LLU; // consequent complete
24720	24744	break;
24721	24745	}
24722		- case 2033LLU: // alternative
	24746	+ case 2035LLU: // alternative
24723	24747	{
24724		- label = 2034LLU; // alternative complete
	24748	+ label = 2036LLU; // alternative complete
24725	24749	break;
24726	24750	}
24727		- case 2034LLU: // completed if-then-else
	24751	+ case 2036LLU: // completed if-then-else
24728	24752	{
24729	24753	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
24730	24754	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24731		- label = 2012LLU; // case complete
	24755	+ label = 2014LLU; // case complete
24732	24756	break;
24733	24757	}
24734		- case 2014LLU: // copy-back deleter (switch)
	24758	+ case 2016LLU: // copy-back deleter (switch)
24735	24759	{
24736	24760	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
24737	24761	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
24738		- label = 1985LLU; // continue to unroll stack
	24762	+ label = 1987LLU; // continue to unroll stack
24739	24763	break;
24740	24764	}
24741		- case 2013LLU: // try next case
	24765	+ case 2015LLU: // try next case
24742	24766	{
24743	24767	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
24744	24768	exit(-1);
24745	24769	}
24746		- case 2012LLU: // completed switch
	24770	+ case 2014LLU: // completed switch
24747	24771	{
24748	24772	printf("%s", "\n stack[base + ");
24749	24773	// call printnr from ProcCall
24750		- stack[base + 37LLU] = 2043LLU/throw to this address/;
	24774	+ stack[base + 37LLU] = 2045LLU/throw to this address/;
24751	24775	stack[base + 38LLU] = base;
24752		- stack[base + 39LLU] = 2044LLU;
	24776	+ stack[base + 39LLU] = 2046LLU;
24753	24777	// arguments for call to printnr
24754	24778	stack[base + 40LLU] = stack[base + 30]/sum/;
24755	24779	// set stack-base & callee-address

		@@ -24757,21 +24781,21 @@
24757	24781	label = 18446744073709551590LLU; // printnr
24758	24782	break;
24759	24783	}
24760		- case 2043LLU: // copy-back deleter (printnr to ProcCall)
	24784	+ case 2045LLU: // copy-back deleter (printnr to ProcCall)
24761	24785	{
24762	24786	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
24763	24787	// copy mutable arguments back from call to printnr
24764		- label = 1985LLU; // continue to roll stack
	24788	+ label = 1987LLU; // continue to roll stack
24765	24789	break;
24766	24790	}
24767		- case 2044LLU: // return from printnr to ProcCall
	24791	+ case 2046LLU: // return from printnr to ProcCall
24768	24792	{
24769	24793	// copy mutable arguments back from call to printnr
24770	24794	printf("%s", "LLU] = ");
24771	24795	// call printnr from ProcCall
24772		- stack[base + 37LLU] = 2045LLU/throw to this address/;
	24796	+ stack[base + 37LLU] = 2047LLU/throw to this address/;
24773	24797	stack[base + 38LLU] = base;
24774		- stack[base + 39LLU] = 2046LLU;
	24798	+ stack[base + 39LLU] = 2048LLU;
24775	24799	// arguments for call to printnr
24776	24800	stack[base + 40LLU] = stack[base + 16]/content/;
24777	24801	// set stack-base & callee-address

		@@ -24779,26 +24803,26 @@
24779	24803	label = 18446744073709551590LLU; // printnr
24780	24804	break;
24781	24805	}
24782		- case 2045LLU: // copy-back deleter (printnr to ProcCall)
	24806	+ case 2047LLU: // copy-back deleter (printnr to ProcCall)
24783	24807	{
24784	24808	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
24785	24809	// copy mutable arguments back from call to printnr
24786		- label = 1985LLU; // continue to roll stack
	24810	+ label = 1987LLU; // continue to roll stack
24787	24811	break;
24788	24812	}
24789		- case 2046LLU: // return from printnr to ProcCall
	24813	+ case 2048LLU: // return from printnr to ProcCall
24790	24814	{
24791	24815	// copy mutable arguments back from call to printnr
24792	24816	printf("%s", "LLU;");
24793		- label = 2011LLU; // consequent complete
	24817	+ label = 2013LLU; // consequent complete
24794	24818	break;
24795	24819	}
24796		- case 2010LLU: // alternative
	24820	+ case 2012LLU: // alternative
24797	24821	{
24798	24822	// call equ from ProcCall
24799		- stack[base + 37LLU] = 2047LLU/throw to this address/;
	24823	+ stack[base + 37LLU] = 2049LLU/throw to this address/;
24800	24824	stack[base + 38LLU] = base;
24801		- stack[base + 39LLU] = 2048LLU;
	24825	+ stack[base + 39LLU] = 2050LLU;
24802	24826	// arguments for call to equ
24803	24827	stack[base + 41LLU] = stack[base + 15]/variant/;
24804	24828	stack[base + 42LLU] = 4LLU;

		@@ -24807,14 +24831,14 @@
24807	24831	label = 18446744073709551600LLU; // equ
24808	24832	break;
24809	24833	}
24810		- case 2047LLU: // copy-back deleter (equ to ProcCall)
	24834	+ case 2049LLU: // copy-back deleter (equ to ProcCall)
24811	24835	{
24812	24836	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equ to ProcCall)\n");
24813	24837	// copy mutable arguments back from call to equ
24814		- label = 1985LLU; // continue to roll stack
	24838	+ label = 1987LLU; // continue to roll stack
24815	24839	break;
24816	24840	}
24817		- case 2048LLU: // return from equ to ProcCall
	24841	+ case 2050LLU: // return from equ to ProcCall
24818	24842	{
24819	24843	// copy mutable arguments back from call to equ
24820	24844	// copy back results provided by call to equ

		@@ -24821,7 +24845,7 @@
24821	24845	stack[base + 18] = stack[base + 40LLU];
24822	24846	if(!stack[base + 18]/isequal/)
24823	24847	{
24824		- label = 2049LLU; // jump to alternative
	24848	+ label = 2051LLU; // jump to alternative
24825	24849	break;
24826	24850	}
24827	24851

		@@ -24828,7 +24852,7 @@
24828	24852	// consequent
24829	24853	if(/param/0 != ((uint64_t )(stack[base + 35]/param*/))[0])
24830	24854	{
24831		- label = 2052LLU; // jump to alternative
	24855	+ label = 2054LLU; // jump to alternative
24832	24856	break;
24833	24857	}
24834	24858

		@@ -24838,7 +24862,7 @@
24838	24862	// case
24839	24863	if(/typeid/0 != ((uint64_t )(stack[base + 37]/typeid*/))[0])
24840	24864	{
24841		- label = 2055LLU; // jump to alternative
	24865	+ label = 2057LLU; // jump to alternative
24842	24866	break;
24843	24867	}
24844	24868

		@@ -24847,9 +24871,9 @@
24847	24871
24848	24872	// case
24849	24873	// call getlettype from ProcCall
24850		- stack[base + 42LLU] = 2057LLU/throw to this address/;
	24874	+ stack[base + 42LLU] = 2059LLU/throw to this address/;
24851	24875	stack[base + 43LLU] = base;
24852		- stack[base + 44LLU] = 2058LLU;
	24876	+ stack[base + 44LLU] = 2060LLU;
24853	24877	// arguments for call to getlettype
24854	24878	stack[base + 46LLU] = stack[base + 8]/fnid/;
24855	24879	stack[base + 47LLU] = stack[base + 16]/content/;

		@@ -24860,22 +24884,22 @@
24860	24884	label = 651LLU; // getlettype
24861	24885	break;
24862	24886	}
24863		- case 2057LLU: // copy-back deleter (getlettype to ProcCall)
	24887	+ case 2059LLU: // copy-back deleter (getlettype to ProcCall)
24864	24888	{
24865	24889	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (getlettype to ProcCall)\n");
24866	24890	// copy mutable arguments back from call to getlettype
24867		- label = 2056LLU; // continue to roll stack
	24891	+ label = 2058LLU; // continue to roll stack
24868	24892	break;
24869	24893	}
24870		- case 2058LLU: // return from getlettype to ProcCall
	24894	+ case 2060LLU: // return from getlettype to ProcCall
24871	24895	{
24872	24896	// copy mutable arguments back from call to getlettype
24873	24897	// copy back results provided by call to getlettype
24874	24898	stack[base + 41] = stack[base + 45LLU];
24875	24899	// call findletmut from ProcCall
24876		- stack[base + 43LLU] = 2059LLU/throw to this address/;
	24900	+ stack[base + 43LLU] = 2061LLU/throw to this address/;
24877	24901	stack[base + 44LLU] = base;
24878		- stack[base + 45LLU] = 2060LLU;
	24902	+ stack[base + 45LLU] = 2062LLU;
24879	24903	// arguments for call to findletmut
24880	24904	stack[base + 47LLU] = stack[base + 8]/fnid/;
24881	24905	stack[base + 48LLU] = stack[base + 16]/content/;

		@@ -24886,14 +24910,14 @@
24886	24910	label = 671LLU; // findletmut
24887	24911	break;
24888	24912	}
24889		- case 2059LLU: // copy-back deleter (findletmut to ProcCall)
	24913	+ case 2061LLU: // copy-back deleter (findletmut to ProcCall)
24890	24914	{
24891	24915	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (findletmut to ProcCall)\n");
24892	24916	// copy mutable arguments back from call to findletmut
24893		- label = 2056LLU; // continue to roll stack
	24917	+ label = 2058LLU; // continue to roll stack
24894	24918	break;
24895	24919	}
24896		- case 2060LLU: // return from findletmut to ProcCall
	24920	+ case 2062LLU: // return from findletmut to ProcCall
24897	24921	{
24898	24922	// copy mutable arguments back from call to findletmut
24899	24923	// copy back results provided by call to findletmut

		@@ -24901,7 +24925,7 @@
24901	24925	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
24902	24926	if(!newstack)
24903	24927	{
24904		- label = 2056LLU; // throw: begin to unroll stack
	24928	+ label = 2058LLU; // throw: begin to unroll stack
24905	24929	break;
24906	24930	}
24907	24931

		@@ -24908,9 +24932,9 @@
24908	24932	newstack[15LLU] = 9876543210LLU; // overflow-marker
24909	24933	// call equtype from ProcCall
24910	24934	newstack[0] = (uint64_t)stack; // backup stack location
24911		- newstack[1] = 2061LLU;
	24935	+ newstack[1] = 2063LLU;
24912	24936	newstack[2] = base;
24913		- newstack[3] = 2062LLU;
	24937	+ newstack[3] = 2064LLU;
24914	24938	// arguments for call to equtype
24915	24939	newstack[5LLU] = stack[base + 41]/type/;
24916	24940	newstack[6LLU] = stack[base + 39]/expected/;

		@@ -24920,7 +24944,7 @@
24920	24944	label = 342LLU; // equtype
24921	24945	break;
24922	24946	}
24923		- case 2061LLU: // copy-back deleter (equtype to ProcCall)
	24947	+ case 2063LLU: // copy-back deleter (equtype to ProcCall)
24924	24948	{
24925	24949	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
24926	24950	uint64_t oldstack = (uint64_t )stack[0];

		@@ -24932,10 +24956,10 @@
24932	24956	}
24933	24957	Free(15LLU + 1, sizeof(uint64_t), stack);
24934	24958	stack = oldstack;
24935		- label = 2056LLU; // continue to unroll stack
	24959	+ label = 2058LLU; // continue to unroll stack
24936	24960	break;
24937	24961	}
24938		- case 2062LLU: // return from equtype to ProcCall
	24962	+ case 2064LLU: // return from equtype to ProcCall
24939	24963	{
24940	24964	uint64_t oldstack = (uint64_t )stack[0];
24941	24965	// copy mutable arguments back from call to equtype

		@@ -24950,21 +24974,21 @@
24950	24974	stack = oldstack;
24951	24975	if(!stack[base + 18]/isequal/)
24952	24976	{
24953		- label = 2063LLU; // jump to alternative
	24977	+ label = 2065LLU; // jump to alternative
24954	24978	break;
24955	24979	}
24956	24980
24957	24981	// consequent
24958		- label = 2064LLU; // consequent complete
	24982	+ label = 2066LLU; // consequent complete
24959	24983	break;
24960	24984	}
24961		- case 2063LLU: // alternative
	24985	+ case 2065LLU: // alternative
24962	24986	{
24963	24987	fprintf(stderr, "%s", "in function ");
24964	24988	// call reportid from ProcCall
24965		- stack[base + 43LLU] = 2065LLU/throw to this address/;
	24989	+ stack[base + 43LLU] = 2067LLU/throw to this address/;
24966	24990	stack[base + 44LLU] = base;
24967		- stack[base + 45LLU] = 2066LLU;
	24991	+ stack[base + 45LLU] = 2068LLU;
24968	24992	// arguments for call to reportid
24969	24993	stack[base + 46LLU] = stack[base + 8]/fnid/;
24970	24994	// set stack-base & callee-address

		@@ -24972,21 +24996,21 @@
24972	24996	label = 18446744073709551586LLU; // reportid
24973	24997	break;
24974	24998	}
24975		- case 2065LLU: // copy-back deleter (reportid to ProcCall)
	24999	+ case 2067LLU: // copy-back deleter (reportid to ProcCall)
24976	25000	{
24977	25001	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
24978	25002	// copy mutable arguments back from call to reportid
24979		- label = 2056LLU; // continue to roll stack
	25003	+ label = 2058LLU; // continue to roll stack
24980	25004	break;
24981	25005	}
24982		- case 2066LLU: // return from reportid to ProcCall
	25006	+ case 2068LLU: // return from reportid to ProcCall
24983	25007	{
24984	25008	// copy mutable arguments back from call to reportid
24985	25009	fprintf(stderr, "%s", " call to ");
24986	25010	// call reportid from ProcCall
24987		- stack[base + 43LLU] = 2067LLU/throw to this address/;
	25011	+ stack[base + 43LLU] = 2069LLU/throw to this address/;
24988	25012	stack[base + 44LLU] = base;
24989		- stack[base + 45LLU] = 2068LLU;
	25013	+ stack[base + 45LLU] = 2070LLU;
24990	25014	// arguments for call to reportid
24991	25015	stack[base + 46LLU] = stack[base + 24]/ceid/;
24992	25016	// set stack-base & callee-address

		@@ -24994,21 +25018,21 @@
24994	25018	label = 18446744073709551586LLU; // reportid
24995	25019	break;
24996	25020	}
24997		- case 2067LLU: // copy-back deleter (reportid to ProcCall)
	25021	+ case 2069LLU: // copy-back deleter (reportid to ProcCall)
24998	25022	{
24999	25023	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25000	25024	// copy mutable arguments back from call to reportid
25001		- label = 2056LLU; // continue to roll stack
	25025	+ label = 2058LLU; // continue to roll stack
25002	25026	break;
25003	25027	}
25004		- case 2068LLU: // return from reportid to ProcCall
	25028	+ case 2070LLU: // return from reportid to ProcCall
25005	25029	{
25006	25030	// copy mutable arguments back from call to reportid
25007	25031	fprintf(stderr, "%s", " at position ");
25008	25032	// call reportnr from ProcCall
25009		- stack[base + 43LLU] = 2069LLU/throw to this address/;
	25033	+ stack[base + 43LLU] = 2071LLU/throw to this address/;
25010	25034	stack[base + 44LLU] = base;
25011		- stack[base + 45LLU] = 2070LLU;
	25035	+ stack[base + 45LLU] = 2072LLU;
25012	25036	// arguments for call to reportnr
25013	25037	stack[base + 46LLU] = stack[base + 32]/index/;
25014	25038	// set stack-base & callee-address

		@@ -25016,14 +25040,14 @@
25016	25040	label = 18446744073709551589LLU; // reportnr
25017	25041	break;
25018	25042	}
25019		- case 2069LLU: // copy-back deleter (reportnr to ProcCall)
	25043	+ case 2071LLU: // copy-back deleter (reportnr to ProcCall)
25020	25044	{
25021	25045	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
25022	25046	// copy mutable arguments back from call to reportnr
25023		- label = 2056LLU; // continue to roll stack
	25047	+ label = 2058LLU; // continue to roll stack
25024	25048	break;
25025	25049	}
25026		- case 2070LLU: // return from reportnr to ProcCall
	25050	+ case 2072LLU: // return from reportnr to ProcCall
25027	25051	{
25028	25052	// copy mutable arguments back from call to reportnr
25029	25053	fprintf(stderr, "%s", " parameter type ");

		@@ -25030,7 +25054,7 @@
25030	25054	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
25031	25055	if(!newstack)
25032	25056	{
25033		- label = 2056LLU; // throw: begin to unroll stack
	25057	+ label = 2058LLU; // throw: begin to unroll stack
25034	25058	break;
25035	25059	}
25036	25060

		@@ -25037,9 +25061,9 @@
25037	25061	newstack[10LLU] = 9876543210LLU; // overflow-marker
25038	25062	// call reporttype from ProcCall
25039	25063	newstack[0] = (uint64_t)stack; // backup stack location
25040		- newstack[1] = 2071LLU;
	25064	+ newstack[1] = 2073LLU;
25041	25065	newstack[2] = base;
25042		- newstack[3] = 2072LLU;
	25066	+ newstack[3] = 2074LLU;
25043	25067	// arguments for call to reporttype
25044	25068	newstack[4LLU] = stack[base + 39]/expected/;
25045	25069	stack = newstack;

		@@ -25048,7 +25072,7 @@
25048	25072	label = 316LLU; // reporttype
25049	25073	break;
25050	25074	}
25051		- case 2071LLU: // copy-back deleter (reporttype to ProcCall)
	25075	+ case 2073LLU: // copy-back deleter (reporttype to ProcCall)
25052	25076	{
25053	25077	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
25054	25078	uint64_t oldstack = (uint64_t )stack[0];

		@@ -25060,10 +25084,10 @@
25060	25084	}
25061	25085	Free(10LLU + 1, sizeof(uint64_t), stack);
25062	25086	stack = oldstack;
25063		- label = 2056LLU; // continue to unroll stack
	25087	+ label = 2058LLU; // continue to unroll stack
25064	25088	break;
25065	25089	}
25066		- case 2072LLU: // return from reporttype to ProcCall
	25090	+ case 2074LLU: // return from reporttype to ProcCall
25067	25091	{
25068	25092	uint64_t oldstack = (uint64_t )stack[0];
25069	25093	// copy mutable arguments back from call to reporttype

		@@ -25078,7 +25102,7 @@
25078	25102	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
25079	25103	if(!newstack)
25080	25104	{
25081		- label = 2056LLU; // throw: begin to unroll stack
	25105	+ label = 2058LLU; // throw: begin to unroll stack
25082	25106	break;
25083	25107	}
25084	25108

		@@ -25085,9 +25109,9 @@
25085	25109	newstack[10LLU] = 9876543210LLU; // overflow-marker
25086	25110	// call reporttype from ProcCall
25087	25111	newstack[0] = (uint64_t)stack; // backup stack location
25088		- newstack[1] = 2073LLU;
	25112	+ newstack[1] = 2075LLU;
25089	25113	newstack[2] = base;
25090		- newstack[3] = 2074LLU;
	25114	+ newstack[3] = 2076LLU;
25091	25115	// arguments for call to reporttype
25092	25116	newstack[4LLU] = stack[base + 41]/type/;
25093	25117	stack = newstack;

		@@ -25096,7 +25120,7 @@
25096	25120	label = 316LLU; // reporttype
25097	25121	break;
25098	25122	}
25099		- case 2073LLU: // copy-back deleter (reporttype to ProcCall)
	25123	+ case 2075LLU: // copy-back deleter (reporttype to ProcCall)
25100	25124	{
25101	25125	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
25102	25126	uint64_t oldstack = (uint64_t )stack[0];

		@@ -25108,10 +25132,10 @@
25108	25132	}
25109	25133	Free(10LLU + 1, sizeof(uint64_t), stack);
25110	25134	stack = oldstack;
25111		- label = 2056LLU; // continue to unroll stack
	25135	+ label = 2058LLU; // continue to unroll stack
25112	25136	break;
25113	25137	}
25114		- case 2074LLU: // return from reporttype to ProcCall
	25138	+ case 2076LLU: // return from reporttype to ProcCall
25115	25139	{
25116	25140	uint64_t oldstack = (uint64_t )stack[0];
25117	25141	// copy mutable arguments back from call to reporttype

		@@ -25124,14 +25148,14 @@
25124	25148	stack = oldstack;
25125	25149	fprintf(stderr, "%s", "\n");
25126	25150	exit(-1);
25127		- label = 2064LLU; // alternative complete
	25151	+ label = 2066LLU; // alternative complete
25128	25152	break;
25129	25153	}
25130		- case 2064LLU: // completed if-then-else
	25154	+ case 2066LLU: // completed if-then-else
25131	25155	{
25132	25156	if(!stack[base + 38]/mutable/)
25133	25157	{
25134		- label = 2075LLU; // jump to alternative
	25158	+ label = 2077LLU; // jump to alternative
25135	25159	break;
25136	25160	}
25137	25161

		@@ -25138,15 +25162,15 @@
25138	25162	// consequent
25139	25163	if(!stack[base + 42]/mutarg/)
25140	25164	{
25141		- label = 2077LLU; // jump to alternative
	25165	+ label = 2079LLU; // jump to alternative
25142	25166	break;
25143	25167	}
25144	25168
25145	25169	// consequent
25146	25170	// call lookidnr from ProcCall
25147		- stack[base + 44LLU] = 2079LLU/throw to this address/;
	25171	+ stack[base + 44LLU] = 2081LLU/throw to this address/;
25148	25172	stack[base + 45LLU] = base;
25149		- stack[base + 46LLU] = 2080LLU;
	25173	+ stack[base + 46LLU] = 2082LLU;
25150	25174	// arguments for call to lookidnr
25151	25175	stack[base + 48LLU] = stack[base + 19]/copyback/;
25152	25176	stack[base + 49LLU] = stack[base + 16]/content/;

		@@ -25155,14 +25179,14 @@
25155	25179	label = 800LLU; // lookidnr
25156	25180	break;
25157	25181	}
25158		- case 2079LLU: // copy-back deleter (lookidnr to ProcCall)
	25182	+ case 2081LLU: // copy-back deleter (lookidnr to ProcCall)
25159	25183	{
25160	25184	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (lookidnr to ProcCall)\n");
25161	25185	// copy mutable arguments back from call to lookidnr
25162		- label = 2056LLU; // continue to roll stack
	25186	+ label = 2058LLU; // continue to roll stack
25163	25187	break;
25164	25188	}
25165		- case 2080LLU: // return from lookidnr to ProcCall
	25189	+ case 2082LLU: // return from lookidnr to ProcCall
25166	25190	{
25167	25191	// copy mutable arguments back from call to lookidnr
25168	25192	// copy back results provided by call to lookidnr

		@@ -25169,7 +25193,7 @@
25169	25193	stack[base + 43] = stack[base + 47LLU];
25170	25194	if(!stack[base + 43]/found/)
25171	25195	{
25172		- label = 2081LLU; // jump to alternative
	25196	+ label = 2083LLU; // jump to alternative
25173	25197	break;
25174	25198	}
25175	25199

		@@ -25176,9 +25200,9 @@
25176	25200	// consequent
25177	25201	fprintf(stderr, "%s", "in function ");
25178	25202	// call reportid from ProcCall
25179		- stack[base + 44LLU] = 2083LLU/throw to this address/;
	25203	+ stack[base + 44LLU] = 2085LLU/throw to this address/;
25180	25204	stack[base + 45LLU] = base;
25181		- stack[base + 46LLU] = 2084LLU;
	25205	+ stack[base + 46LLU] = 2086LLU;
25182	25206	// arguments for call to reportid
25183	25207	stack[base + 47LLU] = stack[base + 8]/fnid/;
25184	25208	// set stack-base & callee-address

		@@ -25186,21 +25210,21 @@
25186	25210	label = 18446744073709551586LLU; // reportid
25187	25211	break;
25188	25212	}
25189		- case 2083LLU: // copy-back deleter (reportid to ProcCall)
	25213	+ case 2085LLU: // copy-back deleter (reportid to ProcCall)
25190	25214	{
25191	25215	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25192	25216	// copy mutable arguments back from call to reportid
25193		- label = 2056LLU; // continue to roll stack
	25217	+ label = 2058LLU; // continue to roll stack
25194	25218	break;
25195	25219	}
25196		- case 2084LLU: // return from reportid to ProcCall
	25220	+ case 2086LLU: // return from reportid to ProcCall
25197	25221	{
25198	25222	// copy mutable arguments back from call to reportid
25199	25223	fprintf(stderr, "%s", " call to ");
25200	25224	// call reportid from ProcCall
25201		- stack[base + 44LLU] = 2085LLU/throw to this address/;
	25225	+ stack[base + 44LLU] = 2087LLU/throw to this address/;
25202	25226	stack[base + 45LLU] = base;
25203		- stack[base + 46LLU] = 2086LLU;
	25227	+ stack[base + 46LLU] = 2088LLU;
25204	25228	// arguments for call to reportid
25205	25229	stack[base + 47LLU] = stack[base + 24]/ceid/;
25206	25230	// set stack-base & callee-address

		@@ -25208,21 +25232,21 @@
25208	25232	label = 18446744073709551586LLU; // reportid
25209	25233	break;
25210	25234	}
25211		- case 2085LLU: // copy-back deleter (reportid to ProcCall)
	25235	+ case 2087LLU: // copy-back deleter (reportid to ProcCall)
25212	25236	{
25213	25237	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25214	25238	// copy mutable arguments back from call to reportid
25215		- label = 2056LLU; // continue to roll stack
	25239	+ label = 2058LLU; // continue to roll stack
25216	25240	break;
25217	25241	}
25218		- case 2086LLU: // return from reportid to ProcCall
	25242	+ case 2088LLU: // return from reportid to ProcCall
25219	25243	{
25220	25244	// copy mutable arguments back from call to reportid
25221	25245	fprintf(stderr, "%s", " - duplicate mutable argument ");
25222	25246	// call reportid from ProcCall
25223		- stack[base + 44LLU] = 2087LLU/throw to this address/;
	25247	+ stack[base + 44LLU] = 2089LLU/throw to this address/;
25224	25248	stack[base + 45LLU] = base;
25225		- stack[base + 46LLU] = 2088LLU;
	25249	+ stack[base + 46LLU] = 2090LLU;
25226	25250	// arguments for call to reportid
25227	25251	stack[base + 47LLU] = stack[base + 16]/content/;
25228	25252	// set stack-base & callee-address

		@@ -25230,38 +25254,38 @@
25230	25254	label = 18446744073709551586LLU; // reportid
25231	25255	break;
25232	25256	}
25233		- case 2087LLU: // copy-back deleter (reportid to ProcCall)
	25257	+ case 2089LLU: // copy-back deleter (reportid to ProcCall)
25234	25258	{
25235	25259	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25236	25260	// copy mutable arguments back from call to reportid
25237		- label = 2056LLU; // continue to roll stack
	25261	+ label = 2058LLU; // continue to roll stack
25238	25262	break;
25239	25263	}
25240		- case 2088LLU: // return from reportid to ProcCall
	25264	+ case 2090LLU: // return from reportid to ProcCall
25241	25265	{
25242	25266	// copy mutable arguments back from call to reportid
25243	25267	fprintf(stderr, "%s", "\n");
25244	25268	exit(-1);
25245		- label = 2082LLU; // consequent complete
	25269	+ label = 2084LLU; // consequent complete
25246	25270	break;
25247	25271	}
25248		- case 2081LLU: // alternative
	25272	+ case 2083LLU: // alternative
25249	25273	{
25250		- label = 2082LLU; // alternative complete
	25274	+ label = 2084LLU; // alternative complete
25251	25275	break;
25252	25276	}
25253		- case 2082LLU: // completed if-then-else
	25277	+ case 2084LLU: // completed if-then-else
25254	25278	{
25255		- label = 2090LLU; // skip deleter
	25279	+ label = 2092LLU; // skip deleter
25256	25280	break;
25257	25281	}
25258		- case 2089LLU: // deleter
	25282	+ case 2091LLU: // deleter
25259	25283	{
25260	25284	// throw from ProcCall
25261	25285	if(!stack[base + 43])
25262	25286	{
25263	25287	fprintf(stderr, "in function ProcCall: unrolling stack, skipping already deleted/unscoped variable idnr \n");
25264		- label = 2056LLU; // skip, variable already deleted/unscoped
	25288	+ label = 2058LLU; // skip, variable already deleted/unscoped
25265	25289	break;
25266	25290	}
25267	25291	fprintf(stderr, "in function ProcCall: unrolling stack, variable idnr \n");

		@@ -25271,7 +25295,7 @@
25271	25295	newstack[0] = (uint64_t)stack; // backup stack location
25272	25296	newstack[1] = 1234567890;
25273	25297	newstack[2] = base;
25274		- newstack[3] = 2091LLU;
	25298	+ newstack[3] = 2093LLU;
25275	25299	stack = newstack;
25276	25300	// set stack-base & callee-address
25277	25301	base = 4/deloffset/;

		@@ -25278,21 +25302,21 @@
25278	25302	label = 798LLU; // ~idnr
25279	25303	break;
25280	25304	}
25281		- case 2091LLU: // return from ~idnr to ProcCall
	25305	+ case 2093LLU: // return from ~idnr to ProcCall
25282	25306	{
25283	25307	stack = (uint64_t *)stack[0];
25284	25308	// releasing toplevel container
25285	25309	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 43] - sizeof(uint64_t) 4));
25286	25310
25287		- label = 2056LLU; // continue unrolling stack, delete next variable
	25311	+ label = 2058LLU; // continue unrolling stack, delete next variable
25288	25312	break;
25289	25313	}
25290		- case 2090LLU: // skipped deleter
	25314	+ case 2092LLU: // skipped deleter
25291	25315	{
25292	25316	// construct idnr.idnr
25293	25317	if(!(stack[base + 43] = construct(2)))
25294	25318	{
25295		- label = 2056LLU; // throw: begin to unroll stack
	25319	+ label = 2058LLU; // throw: begin to unroll stack
25296	25320	break;
25297	25321	}
25298	25322

		@@ -25311,16 +25335,16 @@
25311	25335	stack[base + 19]/copyback/ = (uint64_t)list;
25312	25336	MOVE(&list->data, &stack[base + 43]/idnr/);
25313	25337	}
25314		- label = 2078LLU; // consequent complete
	25338	+ label = 2080LLU; // consequent complete
25315	25339	break;
25316	25340	}
25317		- case 2077LLU: // alternative
	25341	+ case 2079LLU: // alternative
25318	25342	{
25319	25343	fprintf(stderr, "%s", "in function ");
25320	25344	// call reportid from ProcCall
25321		- stack[base + 43LLU] = 2092LLU/throw to this address/;
	25345	+ stack[base + 43LLU] = 2094LLU/throw to this address/;
25322	25346	stack[base + 44LLU] = base;
25323		- stack[base + 45LLU] = 2093LLU;
	25347	+ stack[base + 45LLU] = 2095LLU;
25324	25348	// arguments for call to reportid
25325	25349	stack[base + 46LLU] = stack[base + 8]/fnid/;
25326	25350	// set stack-base & callee-address

		@@ -25328,21 +25352,21 @@
25328	25352	label = 18446744073709551586LLU; // reportid
25329	25353	break;
25330	25354	}
25331		- case 2092LLU: // copy-back deleter (reportid to ProcCall)
	25355	+ case 2094LLU: // copy-back deleter (reportid to ProcCall)
25332	25356	{
25333	25357	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25334	25358	// copy mutable arguments back from call to reportid
25335		- label = 2056LLU; // continue to roll stack
	25359	+ label = 2058LLU; // continue to roll stack
25336	25360	break;
25337	25361	}
25338		- case 2093LLU: // return from reportid to ProcCall
	25362	+ case 2095LLU: // return from reportid to ProcCall
25339	25363	{
25340	25364	// copy mutable arguments back from call to reportid
25341	25365	fprintf(stderr, "%s", ", call to ");
25342	25366	// call reportid from ProcCall
25343		- stack[base + 43LLU] = 2094LLU/throw to this address/;
	25367	+ stack[base + 43LLU] = 2096LLU/throw to this address/;
25344	25368	stack[base + 44LLU] = base;
25345		- stack[base + 45LLU] = 2095LLU;
	25369	+ stack[base + 45LLU] = 2097LLU;
25346	25370	// arguments for call to reportid
25347	25371	stack[base + 46LLU] = stack[base + 24]/ceid/;
25348	25372	// set stack-base & callee-address

		@@ -25350,14 +25374,14 @@
25350	25374	label = 18446744073709551586LLU; // reportid
25351	25375	break;
25352	25376	}
25353		- case 2094LLU: // copy-back deleter (reportid to ProcCall)
	25377	+ case 2096LLU: // copy-back deleter (reportid to ProcCall)
25354	25378	{
25355	25379	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25356	25380	// copy mutable arguments back from call to reportid
25357		- label = 2056LLU; // continue to roll stack
	25381	+ label = 2058LLU; // continue to roll stack
25358	25382	break;
25359	25383	}
25360		- case 2095LLU: // return from reportid to ProcCall
	25384	+ case 2097LLU: // return from reportid to ProcCall
25361	25385	{
25362	25386	// copy mutable arguments back from call to reportid
25363	25387	fprintf(stderr, "%s", ": can't put constant argument ");

		@@ -25364,7 +25388,7 @@
25364	25388	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
25365	25389	if(!newstack)
25366	25390	{
25367		- label = 2056LLU; // throw: begin to unroll stack
	25391	+ label = 2058LLU; // throw: begin to unroll stack
25368	25392	break;
25369	25393	}
25370	25394

		@@ -25371,9 +25395,9 @@
25371	25395	newstack[10LLU] = 9876543210LLU; // overflow-marker
25372	25396	// call reporttype from ProcCall
25373	25397	newstack[0] = (uint64_t)stack; // backup stack location
25374		- newstack[1] = 2096LLU;
	25398	+ newstack[1] = 2098LLU;
25375	25399	newstack[2] = base;
25376		- newstack[3] = 2097LLU;
	25400	+ newstack[3] = 2099LLU;
25377	25401	// arguments for call to reporttype
25378	25402	newstack[4LLU] = stack[base + 41]/type/;
25379	25403	stack = newstack;

		@@ -25382,7 +25406,7 @@
25382	25406	label = 316LLU; // reporttype
25383	25407	break;
25384	25408	}
25385		- case 2096LLU: // copy-back deleter (reporttype to ProcCall)
	25409	+ case 2098LLU: // copy-back deleter (reporttype to ProcCall)
25386	25410	{
25387	25411	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
25388	25412	uint64_t oldstack = (uint64_t )stack[0];

		@@ -25394,10 +25418,10 @@
25394	25418	}
25395	25419	Free(10LLU + 1, sizeof(uint64_t), stack);
25396	25420	stack = oldstack;
25397		- label = 2056LLU; // continue to unroll stack
	25421	+ label = 2058LLU; // continue to unroll stack
25398	25422	break;
25399	25423	}
25400		- case 2097LLU: // return from reporttype to ProcCall
	25424	+ case 2099LLU: // return from reporttype to ProcCall
25401	25425	{
25402	25426	uint64_t oldstack = (uint64_t )stack[0];
25403	25427	// copy mutable arguments back from call to reporttype

		@@ -25410,9 +25434,9 @@
25410	25434	stack = oldstack;
25411	25435	fprintf(stderr, "%s", " ");
25412	25436	// call reportid from ProcCall
25413		- stack[base + 43LLU] = 2098LLU/throw to this address/;
	25437	+ stack[base + 43LLU] = 2100LLU/throw to this address/;
25414	25438	stack[base + 44LLU] = base;
25415		- stack[base + 45LLU] = 2099LLU;
	25439	+ stack[base + 45LLU] = 2101LLU;
25416	25440	// arguments for call to reportid
25417	25441	stack[base + 46LLU] = stack[base + 16]/content/;
25418	25442	// set stack-base & callee-address

		@@ -25420,14 +25444,14 @@
25420	25444	label = 18446744073709551586LLU; // reportid
25421	25445	break;
25422	25446	}
25423		- case 2098LLU: // copy-back deleter (reportid to ProcCall)
	25447	+ case 2100LLU: // copy-back deleter (reportid to ProcCall)
25424	25448	{
25425	25449	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25426	25450	// copy mutable arguments back from call to reportid
25427		- label = 2056LLU; // continue to roll stack
	25451	+ label = 2058LLU; // continue to roll stack
25428	25452	break;
25429	25453	}
25430		- case 2099LLU: // return from reportid to ProcCall
	25454	+ case 2101LLU: // return from reportid to ProcCall
25431	25455	{
25432	25456	// copy mutable arguments back from call to reportid
25433	25457	fprintf(stderr, "%s", " into mutable parameter ");

		@@ -25434,7 +25458,7 @@
25434	25458	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
25435	25459	if(!newstack)
25436	25460	{
25437		- label = 2056LLU; // throw: begin to unroll stack
	25461	+ label = 2058LLU; // throw: begin to unroll stack
25438	25462	break;
25439	25463	}
25440	25464

		@@ -25441,9 +25465,9 @@
25441	25465	newstack[10LLU] = 9876543210LLU; // overflow-marker
25442	25466	// call reporttype from ProcCall
25443	25467	newstack[0] = (uint64_t)stack; // backup stack location
25444		- newstack[1] = 2100LLU;
	25468	+ newstack[1] = 2102LLU;
25445	25469	newstack[2] = base;
25446		- newstack[3] = 2101LLU;
	25470	+ newstack[3] = 2103LLU;
25447	25471	// arguments for call to reporttype
25448	25472	newstack[4LLU] = stack[base + 39]/expected/;
25449	25473	stack = newstack;

		@@ -25452,7 +25476,7 @@
25452	25476	label = 316LLU; // reporttype
25453	25477	break;
25454	25478	}
25455		- case 2100LLU: // copy-back deleter (reporttype to ProcCall)
	25479	+ case 2102LLU: // copy-back deleter (reporttype to ProcCall)
25456	25480	{
25457	25481	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
25458	25482	uint64_t oldstack = (uint64_t )stack[0];

		@@ -25464,10 +25488,10 @@
25464	25488	}
25465	25489	Free(10LLU + 1, sizeof(uint64_t), stack);
25466	25490	stack = oldstack;
25467		- label = 2056LLU; // continue to unroll stack
	25491	+ label = 2058LLU; // continue to unroll stack
25468	25492	break;
25469	25493	}
25470		- case 2101LLU: // return from reporttype to ProcCall
	25494	+ case 2103LLU: // return from reporttype to ProcCall
25471	25495	{
25472	25496	uint64_t oldstack = (uint64_t )stack[0];
25473	25497	// copy mutable arguments back from call to reporttype

		@@ -25479,9 +25503,9 @@
25479	25503	Free(10LLU + 1, sizeof(uint64_t), stack);
25480	25504	stack = oldstack;
25481	25505	// call reportid from ProcCall
25482		- stack[base + 43LLU] = 2102LLU/throw to this address/;
	25506	+ stack[base + 43LLU] = 2104LLU/throw to this address/;
25483	25507	stack[base + 44LLU] = base;
25484		- stack[base + 45LLU] = 2103LLU;
	25508	+ stack[base + 45LLU] = 2105LLU;
25485	25509	// arguments for call to reportid
25486	25510	stack[base + 46LLU] = stack[base + 40]/paramname/;
25487	25511	// set stack-base & callee-address

		@@ -25489,32 +25513,32 @@
25489	25513	label = 18446744073709551586LLU; // reportid
25490	25514	break;
25491	25515	}
25492		- case 2102LLU: // copy-back deleter (reportid to ProcCall)
	25516	+ case 2104LLU: // copy-back deleter (reportid to ProcCall)
25493	25517	{
25494	25518	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
25495	25519	// copy mutable arguments back from call to reportid
25496		- label = 2056LLU; // continue to roll stack
	25520	+ label = 2058LLU; // continue to roll stack
25497	25521	break;
25498	25522	}
25499		- case 2103LLU: // return from reportid to ProcCall
	25523	+ case 2105LLU: // return from reportid to ProcCall
25500	25524	{
25501	25525	// copy mutable arguments back from call to reportid
25502	25526	fprintf(stderr, "%s", "\n");
25503	25527	exit(-1);
25504		- label = 2078LLU; // alternative complete
	25528	+ label = 2080LLU; // alternative complete
25505	25529	break;
25506	25530	}
25507		- case 2078LLU: // completed if-then-else
	25531	+ case 2080LLU: // completed if-then-else
25508	25532	{
25509		- label = 2076LLU; // consequent complete
	25533	+ label = 2078LLU; // consequent complete
25510	25534	break;
25511	25535	}
25512		- case 2075LLU: // alternative
	25536	+ case 2077LLU: // alternative
25513	25537	{
25514		- label = 2076LLU; // alternative complete
	25538	+ label = 2078LLU; // alternative complete
25515	25539	break;
25516	25540	}
25517		- case 2076LLU: // completed if-then-else
	25541	+ case 2078LLU: // completed if-then-else
25518	25542	{
25519	25543
25520	25544	uint64_t newstack = (uint64_t )(stack[base + 41] - sizeof(uint64_t) * 4);

		@@ -25522,7 +25546,7 @@
25522	25546	newstack[0] = (uint64_t)stack; // backup stack location
25523	25547	newstack[1] = 1234567890;
25524	25548	newstack[2] = base;
25525		- newstack[3] = 2104LLU;
	25549	+ newstack[3] = 2106LLU;
25526	25550	stack = newstack;
25527	25551	// set stack-base & callee-address
25528	25552	base = 4/deloffset/;

		@@ -25529,7 +25553,7 @@
25529	25553	label = 296LLU; // ~type
25530	25554	break;
25531	25555	}
25532		- case 2104LLU: // return from ~type to ProcCall
	25556	+ case 2106LLU: // return from ~type to ProcCall
25533	25557	{
25534	25558	stack = (uint64_t *)stack[0];
25535	25559	// releasing toplevel container

		@@ -25537,28 +25561,28 @@
25537	25561
25538	25562	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
25539	25563	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
25540		- label = 2054LLU; // case complete
	25564	+ label = 2056LLU; // case complete
25541	25565	break;
25542	25566	}
25543		- case 2056LLU: // copy-back deleter (switch)
	25567	+ case 2058LLU: // copy-back deleter (switch)
25544	25568	{
25545	25569	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
25546	25570	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
25547		- label = 2053LLU; // continue to unroll stack
	25571	+ label = 2055LLU; // continue to unroll stack
25548	25572	break;
25549	25573	}
25550		- case 2055LLU: // try next case
	25574	+ case 2057LLU: // try next case
25551	25575	{
25552	25576	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
25553	25577	exit(-1);
25554	25578	}
25555		- case 2054LLU: // completed switch
	25579	+ case 2056LLU: // completed switch
25556	25580	{
25557	25581	printf("%s", "\n stack[base + ");
25558	25582	// call printnr from ProcCall
25559		- stack[base + 39LLU] = 2105LLU/throw to this address/;
	25583	+ stack[base + 39LLU] = 2107LLU/throw to this address/;
25560	25584	stack[base + 40LLU] = base;
25561		- stack[base + 41LLU] = 2106LLU;
	25585	+ stack[base + 41LLU] = 2108LLU;
25562	25586	// arguments for call to printnr
25563	25587	stack[base + 42LLU] = stack[base + 30]/sum/;
25564	25588	// set stack-base & callee-address

		@@ -25566,21 +25590,21 @@
25566	25590	label = 18446744073709551590LLU; // printnr
25567	25591	break;
25568	25592	}
25569		- case 2105LLU: // copy-back deleter (printnr to ProcCall)
	25593	+ case 2107LLU: // copy-back deleter (printnr to ProcCall)
25570	25594	{
25571	25595	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
25572	25596	// copy mutable arguments back from call to printnr
25573		- label = 2053LLU; // continue to roll stack
	25597	+ label = 2055LLU; // continue to roll stack
25574	25598	break;
25575	25599	}
25576		- case 2106LLU: // return from printnr to ProcCall
	25600	+ case 2108LLU: // return from printnr to ProcCall
25577	25601	{
25578	25602	// copy mutable arguments back from call to printnr
25579	25603	printf("%s", "LLU] = ");
25580	25604	// call emitvar from ProcCall
25581		- stack[base + 39LLU] = 2107LLU/throw to this address/;
	25605	+ stack[base + 39LLU] = 2109LLU/throw to this address/;
25582	25606	stack[base + 40LLU] = base;
25583		- stack[base + 41LLU] = 2108LLU;
	25607	+ stack[base + 41LLU] = 2110LLU;
25584	25608	// arguments for call to emitvar
25585	25609	stack[base + 42LLU] = stack[base + 8]/fnid/;
25586	25610	stack[base + 43LLU] = stack[base + 16]/content/;

		@@ -25591,46 +25615,46 @@
25591	25615	label = 695LLU; // emitvar
25592	25616	break;
25593	25617	}
25594		- case 2107LLU: // copy-back deleter (emitvar to ProcCall)
	25618	+ case 2109LLU: // copy-back deleter (emitvar to ProcCall)
25595	25619	{
25596	25620	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
25597	25621	// copy mutable arguments back from call to emitvar
25598		- label = 2053LLU; // continue to roll stack
	25622	+ label = 2055LLU; // continue to roll stack
25599	25623	break;
25600	25624	}
25601		- case 2108LLU: // return from emitvar to ProcCall
	25625	+ case 2110LLU: // return from emitvar to ProcCall
25602	25626	{
25603	25627	// copy mutable arguments back from call to emitvar
25604	25628	printf("%s", ";");
25605	25629	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
25606	25630	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
25607		- label = 2051LLU; // case complete
	25631	+ label = 2053LLU; // case complete
25608	25632	break;
25609	25633	}
25610		- case 2053LLU: // copy-back deleter (switch)
	25634	+ case 2055LLU: // copy-back deleter (switch)
25611	25635	{
25612	25636	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 38];
25613	25637	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 37];
25614		- label = 1985LLU; // continue to unroll stack
	25638	+ label = 1987LLU; // continue to unroll stack
25615	25639	break;
25616	25640	}
25617		- case 2052LLU: // try next case
	25641	+ case 2054LLU: // try next case
25618	25642	{
25619	25643	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
25620	25644	exit(-1);
25621	25645	}
25622		- case 2051LLU: // completed switch
	25646	+ case 2053LLU: // completed switch
25623	25647	{
25624		- label = 2050LLU; // consequent complete
	25648	+ label = 2052LLU; // consequent complete
25625	25649	break;
25626	25650	}
25627		- case 2049LLU: // alternative
	25651	+ case 2051LLU: // alternative
25628	25652	{
25629	25653	fprintf(stderr, "%s", "expected identifier or constant argument but found ");
25630	25654	// call printtoken from ProcCall
25631		- stack[base + 37LLU] = 2109LLU/throw to this address/;
	25655	+ stack[base + 37LLU] = 2111LLU/throw to this address/;
25632	25656	stack[base + 38LLU] = base;
25633		- stack[base + 39LLU] = 2110LLU;
	25657	+ stack[base + 39LLU] = 2112LLU;
25634	25658	// arguments for call to printtoken
25635	25659	stack[base + 40LLU] = stack[base + 15]/variant/;
25636	25660	stack[base + 41LLU] = stack[base + 16]/content/;

		@@ -25639,46 +25663,46 @@
25639	25663	label = 18446744073709551583LLU; // printtoken
25640	25664	break;
25641	25665	}
25642		- case 2109LLU: // copy-back deleter (printtoken to ProcCall)
	25666	+ case 2111LLU: // copy-back deleter (printtoken to ProcCall)
25643	25667	{
25644	25668	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printtoken to ProcCall)\n");
25645	25669	// copy mutable arguments back from call to printtoken
25646		- label = 1985LLU; // continue to roll stack
	25670	+ label = 1987LLU; // continue to roll stack
25647	25671	break;
25648	25672	}
25649		- case 2110LLU: // return from printtoken to ProcCall
	25673	+ case 2112LLU: // return from printtoken to ProcCall
25650	25674	{
25651	25675	// copy mutable arguments back from call to printtoken
25652	25676	fprintf(stderr, "%s", "\n");
25653	25677	exit(-1);
25654		- label = 2050LLU; // alternative complete
	25678	+ label = 2052LLU; // alternative complete
25655	25679	break;
25656	25680	}
25657		- case 2050LLU: // completed if-then-else
	25681	+ case 2052LLU: // completed if-then-else
25658	25682	{
25659		- label = 2011LLU; // alternative complete
	25683	+ label = 2013LLU; // alternative complete
25660	25684	break;
25661	25685	}
25662		- case 2011LLU: // completed if-then-else
	25686	+ case 2013LLU: // completed if-then-else
25663	25687	{
25664	25688	((struct listnode )(stack[base + 36]/previous*/))->data = stack[base + 35];
25665		- label = 1983LLU; // repeat
	25689	+ label = 1985LLU; // repeat
25666	25690	break;
25667	25691	}
25668		- case 1985LLU: // copy-back deleter for while next
	25692	+ case 1987LLU: // copy-back deleter for while next
25669	25693	{
25670	25694	((struct listnode )(stack[base + 36]/previous*/))->data = stack[base + 35];
25671		- label = 1939LLU; // continue to unroll stack
	25695	+ label = 1941LLU; // continue to unroll stack
25672	25696	break;
25673	25697	}
25674		- case 1984LLU: // loop finished
	25698	+ case 1986LLU: // loop finished
25675	25699	{
25676	25700	printf("%s", "\n // set stack-base & callee-address");
25677	25701	stack[base + 30]/sum/ = 0;
25678	25702	// call add from ProcCall
25679		- stack[base + 34LLU] = 2111LLU/throw to this address/;
	25703	+ stack[base + 34LLU] = 2113LLU/throw to this address/;
25680	25704	stack[base + 35LLU] = base;
25681		- stack[base + 36LLU] = 2112LLU;
	25705	+ stack[base + 36LLU] = 2114LLU;
25682	25706	// arguments for call to add
25683	25707	stack[base + 38LLU] = stack[base + 4]/offset/;
25684	25708	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -25687,22 +25711,22 @@
25687	25711	label = 18446744073709551605LLU; // add
25688	25712	break;
25689	25713	}
25690		- case 2111LLU: // copy-back deleter (add to ProcCall)
	25714	+ case 2113LLU: // copy-back deleter (add to ProcCall)
25691	25715	{
25692	25716	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
25693	25717	// copy mutable arguments back from call to add
25694		- label = 1939LLU; // continue to roll stack
	25718	+ label = 1941LLU; // continue to roll stack
25695	25719	break;
25696	25720	}
25697		- case 2112LLU: // return from add to ProcCall
	25721	+ case 2114LLU: // return from add to ProcCall
25698	25722	{
25699	25723	// copy mutable arguments back from call to add
25700	25724	// copy back results provided by call to add
25701	25725	stack[base + 30] = stack[base + 37LLU];
25702	25726	// call add from ProcCall
25703		- stack[base + 34LLU] = 2113LLU/throw to this address/;
	25727	+ stack[base + 34LLU] = 2115LLU/throw to this address/;
25704	25728	stack[base + 35LLU] = base;
25705		- stack[base + 36LLU] = 2114LLU;
	25729	+ stack[base + 36LLU] = 2116LLU;
25706	25730	// arguments for call to add
25707	25731	stack[base + 38LLU] = 3LLU;
25708	25732	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -25711,22 +25735,22 @@
25711	25735	label = 18446744073709551605LLU; // add
25712	25736	break;
25713	25737	}
25714		- case 2113LLU: // copy-back deleter (add to ProcCall)
	25738	+ case 2115LLU: // copy-back deleter (add to ProcCall)
25715	25739	{
25716	25740	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
25717	25741	// copy mutable arguments back from call to add
25718		- label = 1939LLU; // continue to roll stack
	25742	+ label = 1941LLU; // continue to roll stack
25719	25743	break;
25720	25744	}
25721		- case 2114LLU: // return from add to ProcCall
	25745	+ case 2116LLU: // return from add to ProcCall
25722	25746	{
25723	25747	// copy mutable arguments back from call to add
25724	25748	// copy back results provided by call to add
25725	25749	stack[base + 30] = stack[base + 37LLU];
25726	25750	// call add from ProcCall
25727		- stack[base + 34LLU] = 2115LLU/throw to this address/;
	25751	+ stack[base + 34LLU] = 2117LLU/throw to this address/;
25728	25752	stack[base + 35LLU] = base;
25729		- stack[base + 36LLU] = 2116LLU;
	25753	+ stack[base + 36LLU] = 2118LLU;
25730	25754	// arguments for call to add
25731	25755	stack[base + 38LLU] = stack[base + 10]/fnrescount/;
25732	25756	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -25735,22 +25759,22 @@
25735	25759	label = 18446744073709551605LLU; // add
25736	25760	break;
25737	25761	}
25738		- case 2115LLU: // copy-back deleter (add to ProcCall)
	25762	+ case 2117LLU: // copy-back deleter (add to ProcCall)
25739	25763	{
25740	25764	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
25741	25765	// copy mutable arguments back from call to add
25742		- label = 1939LLU; // continue to roll stack
	25766	+ label = 1941LLU; // continue to roll stack
25743	25767	break;
25744	25768	}
25745		- case 2116LLU: // return from add to ProcCall
	25769	+ case 2118LLU: // return from add to ProcCall
25746	25770	{
25747	25771	// copy mutable arguments back from call to add
25748	25772	// copy back results provided by call to add
25749	25773	stack[base + 30] = stack[base + 37LLU];
25750	25774	// call add from ProcCall
25751		- stack[base + 34LLU] = 2117LLU/throw to this address/;
	25775	+ stack[base + 34LLU] = 2119LLU/throw to this address/;
25752	25776	stack[base + 35LLU] = base;
25753		- stack[base + 36LLU] = 2118LLU;
	25777	+ stack[base + 36LLU] = 2120LLU;
25754	25778	// arguments for call to add
25755	25779	stack[base + 38LLU] = stack[base + 11]/fnargcount/;
25756	25780	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -25759,14 +25783,14 @@
25759	25783	label = 18446744073709551605LLU; // add
25760	25784	break;
25761	25785	}
25762		- case 2117LLU: // copy-back deleter (add to ProcCall)
	25786	+ case 2119LLU: // copy-back deleter (add to ProcCall)
25763	25787	{
25764	25788	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
25765	25789	// copy mutable arguments back from call to add
25766		- label = 1939LLU; // continue to roll stack
	25790	+ label = 1941LLU; // continue to roll stack
25767	25791	break;
25768	25792	}
25769		- case 2118LLU: // return from add to ProcCall
	25793	+ case 2120LLU: // return from add to ProcCall
25770	25794	{
25771	25795	// copy mutable arguments back from call to add
25772	25796	// copy back results provided by call to add

		@@ -25773,9 +25797,9 @@
25773	25797	stack[base + 30] = stack[base + 37LLU];
25774	25798	printf("%s", "\n base += ");
25775	25799	// call printnr from ProcCall
25776		- stack[base + 34LLU] = 2119LLU/throw to this address/;
	25800	+ stack[base + 34LLU] = 2121LLU/throw to this address/;
25777	25801	stack[base + 35LLU] = base;
25778		- stack[base + 36LLU] = 2120LLU;
	25802	+ stack[base + 36LLU] = 2122LLU;
25779	25803	// arguments for call to printnr
25780	25804	stack[base + 37LLU] = stack[base + 30]/sum/;
25781	25805	// set stack-base & callee-address

		@@ -25783,22 +25807,22 @@
25783	25807	label = 18446744073709551590LLU; // printnr
25784	25808	break;
25785	25809	}
25786		- case 2119LLU: // copy-back deleter (printnr to ProcCall)
	25810	+ case 2121LLU: // copy-back deleter (printnr to ProcCall)
25787	25811	{
25788	25812	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
25789	25813	// copy mutable arguments back from call to printnr
25790		- label = 1939LLU; // continue to roll stack
	25814	+ label = 1941LLU; // continue to roll stack
25791	25815	break;
25792	25816	}
25793		- case 2120LLU: // return from printnr to ProcCall
	25817	+ case 2122LLU: // return from printnr to ProcCall
25794	25818	{
25795	25819	// copy mutable arguments back from call to printnr
25796	25820	printf("%s", "LLU;");
25797	25821	printf("%s", "\n label = ");
25798	25822	// call printnr from ProcCall
25799		- stack[base + 34LLU] = 2121LLU/throw to this address/;
	25823	+ stack[base + 34LLU] = 2123LLU/throw to this address/;
25800	25824	stack[base + 35LLU] = base;
25801		- stack[base + 36LLU] = 2122LLU;
	25825	+ stack[base + 36LLU] = 2124LLU;
25802	25826	// arguments for call to printnr
25803	25827	stack[base + 37LLU] = stack[base + 20]/celabel/;
25804	25828	// set stack-base & callee-address

		@@ -25806,21 +25830,21 @@
25806	25830	label = 18446744073709551590LLU; // printnr
25807	25831	break;
25808	25832	}
25809		- case 2121LLU: // copy-back deleter (printnr to ProcCall)
	25833	+ case 2123LLU: // copy-back deleter (printnr to ProcCall)
25810	25834	{
25811	25835	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
25812	25836	// copy mutable arguments back from call to printnr
25813		- label = 1939LLU; // continue to roll stack
	25837	+ label = 1941LLU; // continue to roll stack
25814	25838	break;
25815	25839	}
25816		- case 2122LLU: // return from printnr to ProcCall
	25840	+ case 2124LLU: // return from printnr to ProcCall
25817	25841	{
25818	25842	// copy mutable arguments back from call to printnr
25819	25843	printf("%s", "LLU; // ");
25820	25844	// call printid from ProcCall
25821		- stack[base + 34LLU] = 2123LLU/throw to this address/;
	25845	+ stack[base + 34LLU] = 2125LLU/throw to this address/;
25822	25846	stack[base + 35LLU] = base;
25823		- stack[base + 36LLU] = 2124LLU;
	25847	+ stack[base + 36LLU] = 2126LLU;
25824	25848	// arguments for call to printid
25825	25849	stack[base + 37LLU] = stack[base + 24]/ceid/;
25826	25850	// set stack-base & callee-address

		@@ -25828,14 +25852,14 @@
25828	25852	label = 18446744073709551587LLU; // printid
25829	25853	break;
25830	25854	}
25831		- case 2123LLU: // copy-back deleter (printid to ProcCall)
	25855	+ case 2125LLU: // copy-back deleter (printid to ProcCall)
25832	25856	{
25833	25857	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25834	25858	// copy mutable arguments back from call to printid
25835		- label = 1939LLU; // continue to roll stack
	25859	+ label = 1941LLU; // continue to roll stack
25836	25860	break;
25837	25861	}
25838		- case 2124LLU: // return from printid to ProcCall
	25862	+ case 2126LLU: // return from printid to ProcCall
25839	25863	{
25840	25864	// copy mutable arguments back from call to printid
25841	25865	printf("%s", "\n break;");

		@@ -25842,7 +25866,7 @@
25842	25866	printf("%s", "\n }");
25843	25867	if(/scope/0 != ((uint64_t )(stack[base + 3]/scope*/))[0])
25844	25868	{
25845		- label = 2126LLU; // jump to alternative
	25869	+ label = 2128LLU; // jump to alternative
25846	25870	break;
25847	25871	}
25848	25872

		@@ -25852,9 +25876,9 @@
25852	25876	// case
25853	25877	printf("%s", "\n case ");
25854	25878	// call printnr from ProcCall
25855		- stack[base + 36LLU] = 2128LLU/throw to this address/;
	25879	+ stack[base + 36LLU] = 2130LLU/throw to this address/;
25856	25880	stack[base + 37LLU] = base;
25857		- stack[base + 38LLU] = 2129LLU;
	25881	+ stack[base + 38LLU] = 2131LLU;
25858	25882	// arguments for call to printnr
25859	25883	stack[base + 39LLU] = stack[base + 33]/labelfail/;
25860	25884	// set stack-base & callee-address

		@@ -25862,21 +25886,21 @@
25862	25886	label = 18446744073709551590LLU; // printnr
25863	25887	break;
25864	25888	}
25865		- case 2128LLU: // copy-back deleter (printnr to ProcCall)
	25889	+ case 2130LLU: // copy-back deleter (printnr to ProcCall)
25866	25890	{
25867	25891	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
25868	25892	// copy mutable arguments back from call to printnr
25869		- label = 2127LLU; // continue to roll stack
	25893	+ label = 2129LLU; // continue to roll stack
25870	25894	break;
25871	25895	}
25872		- case 2129LLU: // return from printnr to ProcCall
	25896	+ case 2131LLU: // return from printnr to ProcCall
25873	25897	{
25874	25898	// copy mutable arguments back from call to printnr
25875	25899	printf("%s", "LLU: // copy-back deleter (");
25876	25900	// call printid from ProcCall
25877		- stack[base + 36LLU] = 2130LLU/throw to this address/;
	25901	+ stack[base + 36LLU] = 2132LLU/throw to this address/;
25878	25902	stack[base + 37LLU] = base;
25879		- stack[base + 38LLU] = 2131LLU;
	25903	+ stack[base + 38LLU] = 2133LLU;
25880	25904	// arguments for call to printid
25881	25905	stack[base + 39LLU] = stack[base + 24]/ceid/;
25882	25906	// set stack-base & callee-address

		@@ -25884,21 +25908,21 @@
25884	25908	label = 18446744073709551587LLU; // printid
25885	25909	break;
25886	25910	}
25887		- case 2130LLU: // copy-back deleter (printid to ProcCall)
	25911	+ case 2132LLU: // copy-back deleter (printid to ProcCall)
25888	25912	{
25889	25913	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25890	25914	// copy mutable arguments back from call to printid
25891		- label = 2127LLU; // continue to roll stack
	25915	+ label = 2129LLU; // continue to roll stack
25892	25916	break;
25893	25917	}
25894		- case 2131LLU: // return from printid to ProcCall
	25918	+ case 2133LLU: // return from printid to ProcCall
25895	25919	{
25896	25920	// copy mutable arguments back from call to printid
25897	25921	printf("%s", " to ");
25898	25922	// call printid from ProcCall
25899		- stack[base + 36LLU] = 2132LLU/throw to this address/;
	25923	+ stack[base + 36LLU] = 2134LLU/throw to this address/;
25900	25924	stack[base + 37LLU] = base;
25901		- stack[base + 38LLU] = 2133LLU;
	25925	+ stack[base + 38LLU] = 2135LLU;
25902	25926	// arguments for call to printid
25903	25927	stack[base + 39LLU] = stack[base + 8]/fnid/;
25904	25928	// set stack-base & callee-address

		@@ -25906,14 +25930,14 @@
25906	25930	label = 18446744073709551587LLU; // printid
25907	25931	break;
25908	25932	}
25909		- case 2132LLU: // copy-back deleter (printid to ProcCall)
	25933	+ case 2134LLU: // copy-back deleter (printid to ProcCall)
25910	25934	{
25911	25935	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25912	25936	// copy mutable arguments back from call to printid
25913		- label = 2127LLU; // continue to roll stack
	25937	+ label = 2129LLU; // continue to roll stack
25914	25938	break;
25915	25939	}
25916		- case 2133LLU: // return from printid to ProcCall
	25940	+ case 2135LLU: // return from printid to ProcCall
25917	25941	{
25918	25942	// copy mutable arguments back from call to printid
25919	25943	printf("%s", ")");

		@@ -25920,9 +25944,9 @@
25920	25944	printf("%s", "\n {");
25921	25945	printf("%s", "\n fprintf(stderr, \"in function ");
25922	25946	// call printid from ProcCall
25923		- stack[base + 36LLU] = 2134LLU/throw to this address/;
	25947	+ stack[base + 36LLU] = 2136LLU/throw to this address/;
25924	25948	stack[base + 37LLU] = base;
25925		- stack[base + 38LLU] = 2135LLU;
	25949	+ stack[base + 38LLU] = 2137LLU;
25926	25950	// arguments for call to printid
25927	25951	stack[base + 39LLU] = stack[base + 8]/fnid/;
25928	25952	// set stack-base & callee-address

		@@ -25930,21 +25954,21 @@
25930	25954	label = 18446744073709551587LLU; // printid
25931	25955	break;
25932	25956	}
25933		- case 2134LLU: // copy-back deleter (printid to ProcCall)
	25957	+ case 2136LLU: // copy-back deleter (printid to ProcCall)
25934	25958	{
25935	25959	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25936	25960	// copy mutable arguments back from call to printid
25937		- label = 2127LLU; // continue to roll stack
	25961	+ label = 2129LLU; // continue to roll stack
25938	25962	break;
25939	25963	}
25940		- case 2135LLU: // return from printid to ProcCall
	25964	+ case 2137LLU: // return from printid to ProcCall
25941	25965	{
25942	25966	// copy mutable arguments back from call to printid
25943	25967	printf("%s", ": unrolling stack, copy-back (");
25944	25968	// call printid from ProcCall
25945		- stack[base + 36LLU] = 2136LLU/throw to this address/;
	25969	+ stack[base + 36LLU] = 2138LLU/throw to this address/;
25946	25970	stack[base + 37LLU] = base;
25947		- stack[base + 38LLU] = 2137LLU;
	25971	+ stack[base + 38LLU] = 2139LLU;
25948	25972	// arguments for call to printid
25949	25973	stack[base + 39LLU] = stack[base + 24]/ceid/;
25950	25974	// set stack-base & callee-address

		@@ -25952,21 +25976,21 @@
25952	25976	label = 18446744073709551587LLU; // printid
25953	25977	break;
25954	25978	}
25955		- case 2136LLU: // copy-back deleter (printid to ProcCall)
	25979	+ case 2138LLU: // copy-back deleter (printid to ProcCall)
25956	25980	{
25957	25981	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25958	25982	// copy mutable arguments back from call to printid
25959		- label = 2127LLU; // continue to roll stack
	25983	+ label = 2129LLU; // continue to roll stack
25960	25984	break;
25961	25985	}
25962		- case 2137LLU: // return from printid to ProcCall
	25986	+ case 2139LLU: // return from printid to ProcCall
25963	25987	{
25964	25988	// copy mutable arguments back from call to printid
25965	25989	printf("%s", " to ");
25966	25990	// call printid from ProcCall
25967		- stack[base + 36LLU] = 2138LLU/throw to this address/;
	25991	+ stack[base + 36LLU] = 2140LLU/throw to this address/;
25968	25992	stack[base + 37LLU] = base;
25969		- stack[base + 38LLU] = 2139LLU;
	25993	+ stack[base + 38LLU] = 2141LLU;
25970	25994	// arguments for call to printid
25971	25995	stack[base + 39LLU] = stack[base + 8]/fnid/;
25972	25996	// set stack-base & callee-address

		@@ -25974,14 +25998,14 @@
25974	25998	label = 18446744073709551587LLU; // printid
25975	25999	break;
25976	26000	}
25977		- case 2138LLU: // copy-back deleter (printid to ProcCall)
	26001	+ case 2140LLU: // copy-back deleter (printid to ProcCall)
25978	26002	{
25979	26003	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
25980	26004	// copy mutable arguments back from call to printid
25981		- label = 2127LLU; // continue to roll stack
	26005	+ label = 2129LLU; // continue to roll stack
25982	26006	break;
25983	26007	}
25984		- case 2139LLU: // return from printid to ProcCall
	26008	+ case 2141LLU: // return from printid to ProcCall
25985	26009	{
25986	26010	// copy mutable arguments back from call to printid
25987	26011	printf("%s", ")");

		@@ -25988,9 +26012,9 @@
25988	26012	printf("%s", "\\n\");");
25989	26013	printf("%s", "\n // copy mutable arguments back from call to ");
25990	26014	// call printid from ProcCall
25991		- stack[base + 36LLU] = 2140LLU/throw to this address/;
	26015	+ stack[base + 36LLU] = 2142LLU/throw to this address/;
25992	26016	stack[base + 37LLU] = base;
25993		- stack[base + 38LLU] = 2141LLU;
	26017	+ stack[base + 38LLU] = 2143LLU;
25994	26018	// arguments for call to printid
25995	26019	stack[base + 39LLU] = stack[base + 24]/ceid/;
25996	26020	// set stack-base & callee-address

		@@ -25998,25 +26022,25 @@
25998	26022	label = 18446744073709551587LLU; // printid
25999	26023	break;
26000	26024	}
26001		- case 2140LLU: // copy-back deleter (printid to ProcCall)
	26025	+ case 2142LLU: // copy-back deleter (printid to ProcCall)
26002	26026	{
26003	26027	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
26004	26028	// copy mutable arguments back from call to printid
26005		- label = 2127LLU; // continue to roll stack
	26029	+ label = 2129LLU; // continue to roll stack
26006	26030	break;
26007	26031	}
26008		- case 2141LLU: // return from printid to ProcCall
	26032	+ case 2143LLU: // return from printid to ProcCall
26009	26033	{
26010	26034	// copy mutable arguments back from call to printid
26011	26035	flippedassign(stack[base + 19]/copyback/, &stack[base + 36]);
26012		- label = 2142LLU; // start to repeat
	26036	+ label = 2144LLU; // start to repeat
26013	26037	break;
26014	26038	}
26015		- case 2142LLU: // repeat from here
	26039	+ case 2144LLU: // repeat from here
26016	26040	{
26017	26041	if(!stack[base + 36])
26018	26042	{
26019		- label = 2143LLU; // break loop
	26043	+ label = 2145LLU; // break loop
26020	26044	break;
26021	26045	}
26022	26046

		@@ -26026,7 +26050,7 @@
26026	26050	stack[base + 36] = (uint64_t)(((const struct listnode *)(stack[base + 36]))->next);
26027	26051	if(/idnr/0 != ((uint64_t )(stack[base + 37]/idnr*/))[0])
26028	26052	{
26029		- label = 2146LLU; // jump to alternative
	26053	+ label = 2148LLU; // jump to alternative
26030	26054	break;
26031	26055	}
26032	26056

		@@ -26036,9 +26060,9 @@
26036	26060	// case
26037	26061	printf("%s", "\n ");
26038	26062	// call emitvar from ProcCall
26039		- stack[base + 41LLU] = 2148LLU/throw to this address/;
	26063	+ stack[base + 41LLU] = 2150LLU/throw to this address/;
26040	26064	stack[base + 42LLU] = base;
26041		- stack[base + 43LLU] = 2149LLU;
	26065	+ stack[base + 43LLU] = 2151LLU;
26042	26066	// arguments for call to emitvar
26043	26067	stack[base + 44LLU] = stack[base + 8]/fnid/;
26044	26068	stack[base + 45LLU] = stack[base + 39]/content/;

		@@ -26049,21 +26073,21 @@
26049	26073	label = 695LLU; // emitvar
26050	26074	break;
26051	26075	}
26052		- case 2148LLU: // copy-back deleter (emitvar to ProcCall)
	26076	+ case 2150LLU: // copy-back deleter (emitvar to ProcCall)
26053	26077	{
26054	26078	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
26055	26079	// copy mutable arguments back from call to emitvar
26056		- label = 2147LLU; // continue to roll stack
	26080	+ label = 2149LLU; // continue to roll stack
26057	26081	break;
26058	26082	}
26059		- case 2149LLU: // return from emitvar to ProcCall
	26083	+ case 2151LLU: // return from emitvar to ProcCall
26060	26084	{
26061	26085	// copy mutable arguments back from call to emitvar
26062	26086	printf("%s", " = stack[base + ");
26063	26087	// call printnr from ProcCall
26064		- stack[base + 41LLU] = 2150LLU/throw to this address/;
	26088	+ stack[base + 41LLU] = 2152LLU/throw to this address/;
26065	26089	stack[base + 42LLU] = base;
26066		- stack[base + 43LLU] = 2151LLU;
	26090	+ stack[base + 43LLU] = 2153LLU;
26067	26091	// arguments for call to printnr
26068	26092	stack[base + 44LLU] = stack[base + 40]/sum/;
26069	26093	// set stack-base & callee-address

		@@ -26071,53 +26095,53 @@
26071	26095	label = 18446744073709551590LLU; // printnr
26072	26096	break;
26073	26097	}
26074		- case 2150LLU: // copy-back deleter (printnr to ProcCall)
	26098	+ case 2152LLU: // copy-back deleter (printnr to ProcCall)
26075	26099	{
26076	26100	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
26077	26101	// copy mutable arguments back from call to printnr
26078		- label = 2147LLU; // continue to roll stack
	26102	+ label = 2149LLU; // continue to roll stack
26079	26103	break;
26080	26104	}
26081		- case 2151LLU: // return from printnr to ProcCall
	26105	+ case 2153LLU: // return from printnr to ProcCall
26082	26106	{
26083	26107	// copy mutable arguments back from call to printnr
26084	26108	printf("%s", "LLU];");
26085	26109	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
26086	26110	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
26087		- label = 2145LLU; // case complete
	26111	+ label = 2147LLU; // case complete
26088	26112	break;
26089	26113	}
26090		- case 2147LLU: // copy-back deleter (switch)
	26114	+ case 2149LLU: // copy-back deleter (switch)
26091	26115	{
26092	26116	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 40];
26093	26117	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 39];
26094		- label = 2144LLU; // continue to unroll stack
	26118	+ label = 2146LLU; // continue to unroll stack
26095	26119	break;
26096	26120	}
26097		- case 2146LLU: // try next case
	26121	+ case 2148LLU: // try next case
26098	26122	{
26099	26123	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
26100	26124	exit(-1);
26101	26125	}
26102		- case 2145LLU: // completed switch
	26126	+ case 2147LLU: // completed switch
26103	26127	{
26104	26128	((struct listnode )(stack[base + 38]/previous*/))->data = stack[base + 37];
26105		- label = 2142LLU; // repeat
	26129	+ label = 2144LLU; // repeat
26106	26130	break;
26107	26131	}
26108		- case 2144LLU: // copy-back deleter for while next
	26132	+ case 2146LLU: // copy-back deleter for while next
26109	26133	{
26110	26134	((struct listnode )(stack[base + 38]/previous*/))->data = stack[base + 37];
26111		- label = 2127LLU; // continue to unroll stack
	26135	+ label = 2129LLU; // continue to unroll stack
26112	26136	break;
26113	26137	}
26114		- case 2143LLU: // loop finished
	26138	+ case 2145LLU: // loop finished
26115	26139	{
26116	26140	printf("%s", "\n label = ");
26117	26141	// call printnr from ProcCall
26118		- stack[base + 39LLU] = 2152LLU/throw to this address/;
	26142	+ stack[base + 39LLU] = 2154LLU/throw to this address/;
26119	26143	stack[base + 40LLU] = base;
26120		- stack[base + 41LLU] = 2153LLU;
	26144	+ stack[base + 41LLU] = 2155LLU;
26121	26145	// arguments for call to printnr
26122	26146	stack[base + 42LLU] = stack[base + 34]/labelthrow/;
26123	26147	// set stack-base & callee-address

		@@ -26125,14 +26149,14 @@
26125	26149	label = 18446744073709551590LLU; // printnr
26126	26150	break;
26127	26151	}
26128		- case 2152LLU: // copy-back deleter (printnr to ProcCall)
	26152	+ case 2154LLU: // copy-back deleter (printnr to ProcCall)
26129	26153	{
26130	26154	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
26131	26155	// copy mutable arguments back from call to printnr
26132		- label = 2127LLU; // continue to roll stack
	26156	+ label = 2129LLU; // continue to roll stack
26133	26157	break;
26134	26158	}
26135		- case 2153LLU: // return from printnr to ProcCall
	26159	+ case 2155LLU: // return from printnr to ProcCall
26136	26160	{
26137	26161	// copy mutable arguments back from call to printnr
26138	26162	printf("%s", "LLU; // continue to roll stack");

		@@ -26140,28 +26164,28 @@
26140	26164	printf("%s", "\n }");
26141	26165	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 35];
26142	26166	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 34];
26143		- label = 2125LLU; // case complete
	26167	+ label = 2127LLU; // case complete
26144	26168	break;
26145	26169	}
26146		- case 2127LLU: // copy-back deleter (switch)
	26170	+ case 2129LLU: // copy-back deleter (switch)
26147	26171	{
26148	26172	((uint64_t **)(stack[base + 3]))[1][1] = stack[base + 35];
26149	26173	((uint64_t **)(stack[base + 3]))[1][0] = stack[base + 34];
26150		- label = 1939LLU; // continue to unroll stack
	26174	+ label = 1941LLU; // continue to unroll stack
26151	26175	break;
26152	26176	}
26153		- case 2126LLU: // try next case
	26177	+ case 2128LLU: // try next case
26154	26178	{
26155	26179	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
26156	26180	exit(-1);
26157	26181	}
26158		- case 2125LLU: // completed switch
	26182	+ case 2127LLU: // completed switch
26159	26183	{
26160	26184	printf("%s", "\n case ");
26161	26185	// call printnr from ProcCall
26162		- stack[base + 34LLU] = 2154LLU/throw to this address/;
	26186	+ stack[base + 34LLU] = 2156LLU/throw to this address/;
26163	26187	stack[base + 35LLU] = base;
26164		- stack[base + 36LLU] = 2155LLU;
	26188	+ stack[base + 36LLU] = 2157LLU;
26165	26189	// arguments for call to printnr
26166	26190	stack[base + 37LLU] = stack[base + 17]/label/;
26167	26191	// set stack-base & callee-address

		@@ -26169,21 +26193,21 @@
26169	26193	label = 18446744073709551590LLU; // printnr
26170	26194	break;
26171	26195	}
26172		- case 2154LLU: // copy-back deleter (printnr to ProcCall)
	26196	+ case 2156LLU: // copy-back deleter (printnr to ProcCall)
26173	26197	{
26174	26198	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
26175	26199	// copy mutable arguments back from call to printnr
26176		- label = 1939LLU; // continue to roll stack
	26200	+ label = 1941LLU; // continue to roll stack
26177	26201	break;
26178	26202	}
26179		- case 2155LLU: // return from printnr to ProcCall
	26203	+ case 2157LLU: // return from printnr to ProcCall
26180	26204	{
26181	26205	// copy mutable arguments back from call to printnr
26182	26206	printf("%s", "LLU: // return from ");
26183	26207	// call printid from ProcCall
26184		- stack[base + 34LLU] = 2156LLU/throw to this address/;
	26208	+ stack[base + 34LLU] = 2158LLU/throw to this address/;
26185	26209	stack[base + 35LLU] = base;
26186		- stack[base + 36LLU] = 2157LLU;
	26210	+ stack[base + 36LLU] = 2159LLU;
26187	26211	// arguments for call to printid
26188	26212	stack[base + 37LLU] = stack[base + 24]/ceid/;
26189	26213	// set stack-base & callee-address

		@@ -26191,21 +26215,21 @@
26191	26215	label = 18446744073709551587LLU; // printid
26192	26216	break;
26193	26217	}
26194		- case 2156LLU: // copy-back deleter (printid to ProcCall)
	26218	+ case 2158LLU: // copy-back deleter (printid to ProcCall)
26195	26219	{
26196	26220	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
26197	26221	// copy mutable arguments back from call to printid
26198		- label = 1939LLU; // continue to roll stack
	26222	+ label = 1941LLU; // continue to roll stack
26199	26223	break;
26200	26224	}
26201		- case 2157LLU: // return from printid to ProcCall
	26225	+ case 2159LLU: // return from printid to ProcCall
26202	26226	{
26203	26227	// copy mutable arguments back from call to printid
26204	26228	printf("%s", " to ");
26205	26229	// call printid from ProcCall
26206		- stack[base + 34LLU] = 2158LLU/throw to this address/;
	26230	+ stack[base + 34LLU] = 2160LLU/throw to this address/;
26207	26231	stack[base + 35LLU] = base;
26208		- stack[base + 36LLU] = 2159LLU;
	26232	+ stack[base + 36LLU] = 2161LLU;
26209	26233	// arguments for call to printid
26210	26234	stack[base + 37LLU] = stack[base + 8]/fnid/;
26211	26235	// set stack-base & callee-address

		@@ -26213,22 +26237,22 @@
26213	26237	label = 18446744073709551587LLU; // printid
26214	26238	break;
26215	26239	}
26216		- case 2158LLU: // copy-back deleter (printid to ProcCall)
	26240	+ case 2160LLU: // copy-back deleter (printid to ProcCall)
26217	26241	{
26218	26242	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
26219	26243	// copy mutable arguments back from call to printid
26220		- label = 1939LLU; // continue to roll stack
	26244	+ label = 1941LLU; // continue to roll stack
26221	26245	break;
26222	26246	}
26223		- case 2159LLU: // return from printid to ProcCall
	26247	+ case 2161LLU: // return from printid to ProcCall
26224	26248	{
26225	26249	// copy mutable arguments back from call to printid
26226	26250	printf("%s", "\n {");
26227	26251	printf("%s", "\n // copy mutable arguments back from call to ");
26228	26252	// call printid from ProcCall
26229		- stack[base + 34LLU] = 2160LLU/throw to this address/;
	26253	+ stack[base + 34LLU] = 2162LLU/throw to this address/;
26230	26254	stack[base + 35LLU] = base;
26231		- stack[base + 36LLU] = 2161LLU;
	26255	+ stack[base + 36LLU] = 2163LLU;
26232	26256	// arguments for call to printid
26233	26257	stack[base + 37LLU] = stack[base + 24]/ceid/;
26234	26258	// set stack-base & callee-address

		@@ -26236,24 +26260,24 @@
26236	26260	label = 18446744073709551587LLU; // printid
26237	26261	break;
26238	26262	}
26239		- case 2160LLU: // copy-back deleter (printid to ProcCall)
	26263	+ case 2162LLU: // copy-back deleter (printid to ProcCall)
26240	26264	{
26241	26265	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
26242	26266	// copy mutable arguments back from call to printid
26243		- label = 1939LLU; // continue to roll stack
	26267	+ label = 1941LLU; // continue to roll stack
26244	26268	break;
26245	26269	}
26246		- case 2161LLU: // return from printid to ProcCall
	26270	+ case 2163LLU: // return from printid to ProcCall
26247	26271	{
26248	26272	// copy mutable arguments back from call to printid
26249		- label = 2162LLU; // start to repeat
	26273	+ label = 2164LLU; // start to repeat
26250	26274	break;
26251	26275	}
26252		- case 2162LLU: // repeat from here
	26276	+ case 2164LLU: // repeat from here
26253	26277	{
26254	26278	if(!stack[base + 19])
26255	26279	{
26256		- label = 2163LLU; // break loop
	26280	+ label = 2165LLU; // break loop
26257	26281	break;
26258	26282	}
26259	26283

		@@ -26266,7 +26290,7 @@
26266	26290	}
26267	26291	if(/idnr/0 != ((uint64_t )(stack[base + 34]/idnr*/))[0])
26268	26292	{
26269		- label = 2165LLU; // jump to alternative
	26293	+ label = 2167LLU; // jump to alternative
26270	26294	break;
26271	26295	}
26272	26296

		@@ -26276,9 +26300,9 @@
26276	26300	// case
26277	26301	printf("%s", "\n ");
26278	26302	// call emitvar from ProcCall
26279		- stack[base + 37LLU] = 2167LLU/throw to this address/;
	26303	+ stack[base + 37LLU] = 2169LLU/throw to this address/;
26280	26304	stack[base + 38LLU] = base;
26281		- stack[base + 39LLU] = 2168LLU;
	26305	+ stack[base + 39LLU] = 2170LLU;
26282	26306	// arguments for call to emitvar
26283	26307	stack[base + 40LLU] = stack[base + 8]/fnid/;
26284	26308	stack[base + 41LLU] = stack[base + 35]/content/;

		@@ -26289,21 +26313,21 @@
26289	26313	label = 695LLU; // emitvar
26290	26314	break;
26291	26315	}
26292		- case 2167LLU: // copy-back deleter (emitvar to ProcCall)
	26316	+ case 2169LLU: // copy-back deleter (emitvar to ProcCall)
26293	26317	{
26294	26318	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvar to ProcCall)\n");
26295	26319	// copy mutable arguments back from call to emitvar
26296		- label = 2166LLU; // continue to roll stack
	26320	+ label = 2168LLU; // continue to roll stack
26297	26321	break;
26298	26322	}
26299		- case 2168LLU: // return from emitvar to ProcCall
	26323	+ case 2170LLU: // return from emitvar to ProcCall
26300	26324	{
26301	26325	// copy mutable arguments back from call to emitvar
26302	26326	printf("%s", " = stack[base + ");
26303	26327	// call printnr from ProcCall
26304		- stack[base + 37LLU] = 2169LLU/throw to this address/;
	26328	+ stack[base + 37LLU] = 2171LLU/throw to this address/;
26305	26329	stack[base + 38LLU] = base;
26306		- stack[base + 39LLU] = 2170LLU;
	26330	+ stack[base + 39LLU] = 2172LLU;
26307	26331	// arguments for call to printnr
26308	26332	stack[base + 40LLU] = stack[base + 36]/sum/;
26309	26333	// set stack-base & callee-address

		@@ -26311,35 +26335,35 @@
26311	26335	label = 18446744073709551590LLU; // printnr
26312	26336	break;
26313	26337	}
26314		- case 2169LLU: // copy-back deleter (printnr to ProcCall)
	26338	+ case 2171LLU: // copy-back deleter (printnr to ProcCall)
26315	26339	{
26316	26340	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
26317	26341	// copy mutable arguments back from call to printnr
26318		- label = 2166LLU; // continue to roll stack
	26342	+ label = 2168LLU; // continue to roll stack
26319	26343	break;
26320	26344	}
26321		- case 2170LLU: // return from printnr to ProcCall
	26345	+ case 2172LLU: // return from printnr to ProcCall
26322	26346	{
26323	26347	// copy mutable arguments back from call to printnr
26324	26348	printf("%s", "LLU];");
26325	26349	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
26326	26350	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
26327		- label = 2164LLU; // case complete
	26351	+ label = 2166LLU; // case complete
26328	26352	break;
26329	26353	}
26330		- case 2166LLU: // copy-back deleter (switch)
	26354	+ case 2168LLU: // copy-back deleter (switch)
26331	26355	{
26332	26356	((uint64_t **)(stack[base + 34]))[1][1] = stack[base + 36];
26333	26357	((uint64_t **)(stack[base + 34]))[1][0] = stack[base + 35];
26334		- label = 1939LLU; // continue to unroll stack
	26358	+ label = 1941LLU; // continue to unroll stack
26335	26359	break;
26336	26360	}
26337		- case 2165LLU: // try next case
	26361	+ case 2167LLU: // try next case
26338	26362	{
26339	26363	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
26340	26364	exit(-1);
26341	26365	}
26342		- case 2164LLU: // completed switch
	26366	+ case 2166LLU: // completed switch
26343	26367	{
26344	26368
26345	26369	uint64_t newstack = (uint64_t )(stack[base + 34] - sizeof(uint64_t) * 4);

		@@ -26347,7 +26371,7 @@
26347	26371	newstack[0] = (uint64_t)stack; // backup stack location
26348	26372	newstack[1] = 1234567890;
26349	26373	newstack[2] = base;
26350		- newstack[3] = 2171LLU;
	26374	+ newstack[3] = 2173LLU;
26351	26375	stack = newstack;
26352	26376	// set stack-base & callee-address
26353	26377	base = 4/deloffset/;

		@@ -26354,20 +26378,20 @@
26354	26378	label = 798LLU; // ~idnr
26355	26379	break;
26356	26380	}
26357		- case 2171LLU: // return from ~idnr to ProcCall
	26381	+ case 2173LLU: // return from ~idnr to ProcCall
26358	26382	{
26359	26383	stack = (uint64_t *)stack[0];
26360	26384	// releasing toplevel container
26361	26385	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 34] - sizeof(uint64_t) 4));
26362	26386
26363		- label = 2162LLU; // repeat
	26387	+ label = 2164LLU; // repeat
26364	26388	break;
26365	26389	}
26366		- case 2163LLU: // loop finished
	26390	+ case 2165LLU: // loop finished
26367	26391	{
26368	26392	if(!stack[base + 28]/cerescount/)
26369	26393	{
26370		- label = 2172LLU; // jump to alternative
	26394	+ label = 2174LLU; // jump to alternative
26371	26395	break;
26372	26396	}
26373	26397

		@@ -26374,9 +26398,9 @@
26374	26398	// consequent
26375	26399	printf("%s", "\n // copy back results provided by call to ");
26376	26400	// call printid from ProcCall
26377		- stack[base + 34LLU] = 2174LLU/throw to this address/;
	26401	+ stack[base + 34LLU] = 2176LLU/throw to this address/;
26378	26402	stack[base + 35LLU] = base;
26379		- stack[base + 36LLU] = 2175LLU;
	26403	+ stack[base + 36LLU] = 2177LLU;
26380	26404	// arguments for call to printid
26381	26405	stack[base + 37LLU] = stack[base + 24]/ceid/;
26382	26406	// set stack-base & callee-address

		@@ -26384,26 +26408,26 @@
26384	26408	label = 18446744073709551587LLU; // printid
26385	26409	break;
26386	26410	}
26387		- case 2174LLU: // copy-back deleter (printid to ProcCall)
	26411	+ case 2176LLU: // copy-back deleter (printid to ProcCall)
26388	26412	{
26389	26413	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printid to ProcCall)\n");
26390	26414	// copy mutable arguments back from call to printid
26391		- label = 1939LLU; // continue to roll stack
	26415	+ label = 1941LLU; // continue to roll stack
26392	26416	break;
26393	26417	}
26394		- case 2175LLU: // return from printid to ProcCall
	26418	+ case 2177LLU: // return from printid to ProcCall
26395	26419	{
26396	26420	// copy mutable arguments back from call to printid
26397	26421	stack[base + 31]/n/ = stack[base + 28]/cerescount/;
26398	26422	flippedassign(stack[base + 21]/cerestypes/, &stack[base + 34]);
26399		- label = 2176LLU; // start to repeat
	26423	+ label = 2178LLU; // start to repeat
26400	26424	break;
26401	26425	}
26402		- case 2176LLU: // repeat from here
	26426	+ case 2178LLU: // repeat from here
26403	26427	{
26404	26428	if(!stack[base + 34])
26405	26429	{
26406		- label = 2177LLU; // break loop
	26430	+ label = 2179LLU; // break loop
26407	26431	break;
26408	26432	}
26409	26433

		@@ -26412,9 +26436,9 @@
26412	26436	stack[base + 36]/previous/ = stack[base + 34];
26413	26437	stack[base + 34] = (uint64_t)(((const struct listnode *)(stack[base + 34]))->next);
26414	26438	// call sub from ProcCall
26415		- stack[base + 37LLU] = 2179LLU/throw to this address/;
	26439	+ stack[base + 37LLU] = 2181LLU/throw to this address/;
26416	26440	stack[base + 38LLU] = base;
26417		- stack[base + 39LLU] = 2180LLU;
	26441	+ stack[base + 39LLU] = 2182LLU;
26418	26442	// arguments for call to sub
26419	26443	stack[base + 41LLU] = stack[base + 28]/cerescount/;
26420	26444	stack[base + 42LLU] = stack[base + 31]/n/;

		@@ -26423,22 +26447,22 @@
26423	26447	label = 18446744073709551604LLU; // sub
26424	26448	break;
26425	26449	}
26426		- case 2179LLU: // copy-back deleter (sub to ProcCall)
	26450	+ case 2181LLU: // copy-back deleter (sub to ProcCall)
26427	26451	{
26428	26452	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
26429	26453	// copy mutable arguments back from call to sub
26430		- label = 2178LLU; // continue to roll stack
	26454	+ label = 2180LLU; // continue to roll stack
26431	26455	break;
26432	26456	}
26433		- case 2180LLU: // return from sub to ProcCall
	26457	+ case 2182LLU: // return from sub to ProcCall
26434	26458	{
26435	26459	// copy mutable arguments back from call to sub
26436	26460	// copy back results provided by call to sub
26437	26461	stack[base + 32] = stack[base + 40LLU];
26438	26462	// call sub from ProcCall
26439		- stack[base + 37LLU] = 2181LLU/throw to this address/;
	26463	+ stack[base + 37LLU] = 2183LLU/throw to this address/;
26440	26464	stack[base + 38LLU] = base;
26441		- stack[base + 39LLU] = 2182LLU;
	26465	+ stack[base + 39LLU] = 2184LLU;
26442	26466	// arguments for call to sub
26443	26467	stack[base + 41LLU] = stack[base + 31]/n/;
26444	26468	stack[base + 42LLU] = 1LLU;

		@@ -26447,14 +26471,14 @@
26447	26471	label = 18446744073709551604LLU; // sub
26448	26472	break;
26449	26473	}
26450		- case 2181LLU: // copy-back deleter (sub to ProcCall)
	26474	+ case 2183LLU: // copy-back deleter (sub to ProcCall)
26451	26475	{
26452	26476	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (sub to ProcCall)\n");
26453	26477	// copy mutable arguments back from call to sub
26454		- label = 2178LLU; // continue to roll stack
	26478	+ label = 2180LLU; // continue to roll stack
26455	26479	break;
26456	26480	}
26457		- case 2182LLU: // return from sub to ProcCall
	26481	+ case 2184LLU: // return from sub to ProcCall
26458	26482	{
26459	26483	// copy mutable arguments back from call to sub
26460	26484	// copy back results provided by call to sub

		@@ -26463,7 +26487,7 @@
26463	26487	struct listnode list = (struct listnode )stack[base + 0]/dsttypeids/;
26464	26488	if(!list)
26465	26489	{
26466		- label = 2183LLU; // jump to alternative
	26490	+ label = 2185LLU; // jump to alternative
26467	26491	break;
26468	26492	}
26469	26493

		@@ -26475,7 +26499,7 @@
26475	26499	}
26476	26500	if(/typeidx/0 != ((uint64_t )(stack[base + 37]/typeidx*/))[0])
26477	26501	{
26478		- label = 2186LLU; // jump to alternative
	26502	+ label = 2189LLU; // jump to alternative
26479	26503	break;
26480	26504	}
26481	26505

		@@ -26485,7 +26509,7 @@
26485	26509	// case
26486	26510	if(/result/0 != ((uint64_t )(stack[base + 35]/result*/))[0])
26487	26511	{
26488		- label = 2189LLU; // jump to alternative
	26512	+ label = 2192LLU; // jump to alternative
26489	26513	break;
26490	26514	}
26491	26515

		@@ -26496,7 +26520,7 @@
26496	26520	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
26497	26521	if(!newstack)
26498	26522	{
26499		- label = 2190LLU; // throw: begin to unroll stack
	26523	+ label = 2193LLU; // throw: begin to unroll stack
26500	26524	break;
26501	26525	}
26502	26526

		@@ -26503,9 +26527,9 @@
26503	26527	newstack[15LLU] = 9876543210LLU; // overflow-marker
26504	26528	// call equtype from ProcCall
26505	26529	newstack[0] = (uint64_t)stack; // backup stack location
26506		- newstack[1] = 2191LLU;
	26530	+ newstack[1] = 2194LLU;
26507	26531	newstack[2] = base;
26508		- newstack[3] = 2192LLU;
	26532	+ newstack[3] = 2195LLU;
26509	26533	// arguments for call to equtype
26510	26534	newstack[5LLU] = stack[base + 38]/dsttype/;
26511	26535	newstack[6LLU] = stack[base + 40]/srctype/;

		@@ -26515,7 +26539,7 @@
26515	26539	label = 342LLU; // equtype
26516	26540	break;
26517	26541	}
26518		- case 2191LLU: // copy-back deleter (equtype to ProcCall)
	26542	+ case 2194LLU: // copy-back deleter (equtype to ProcCall)
26519	26543	{
26520	26544	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (equtype to ProcCall)\n");
26521	26545	uint64_t oldstack = (uint64_t )stack[0];

		@@ -26527,10 +26551,10 @@
26527	26551	}
26528	26552	Free(15LLU + 1, sizeof(uint64_t), stack);
26529	26553	stack = oldstack;
26530		- label = 2190LLU; // continue to unroll stack
	26554	+ label = 2193LLU; // continue to unroll stack
26531	26555	break;
26532	26556	}
26533		- case 2192LLU: // return from equtype to ProcCall
	26557	+ case 2195LLU: // return from equtype to ProcCall
26534	26558	{
26535	26559	uint64_t oldstack = (uint64_t )stack[0];
26536	26560	// copy mutable arguments back from call to equtype

		@@ -26545,21 +26569,21 @@
26545	26569	stack = oldstack;
26546	26570	if(!stack[base + 18]/isequal/)
26547	26571	{
26548		- label = 2193LLU; // jump to alternative
	26572	+ label = 2196LLU; // jump to alternative
26549	26573	break;
26550	26574	}
26551	26575
26552	26576	// consequent
26553		- label = 2194LLU; // consequent complete
	26577	+ label = 2197LLU; // consequent complete
26554	26578	break;
26555	26579	}
26556		- case 2193LLU: // alternative
	26580	+ case 2196LLU: // alternative
26557	26581	{
26558	26582	fprintf(stderr, "%s", "in function ");
26559	26583	// call reportid from ProcCall
26560		- stack[base + 42LLU] = 2195LLU/throw to this address/;
	26584	+ stack[base + 42LLU] = 2198LLU/throw to this address/;
26561	26585	stack[base + 43LLU] = base;
26562		- stack[base + 44LLU] = 2196LLU;
	26586	+ stack[base + 44LLU] = 2199LLU;
26563	26587	// arguments for call to reportid
26564	26588	stack[base + 45LLU] = stack[base + 8]/fnid/;
26565	26589	// set stack-base & callee-address

		@@ -26567,21 +26591,21 @@
26567	26591	label = 18446744073709551586LLU; // reportid
26568	26592	break;
26569	26593	}
26570		- case 2195LLU: // copy-back deleter (reportid to ProcCall)
	26594	+ case 2198LLU: // copy-back deleter (reportid to ProcCall)
26571	26595	{
26572	26596	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
26573	26597	// copy mutable arguments back from call to reportid
26574		- label = 2190LLU; // continue to roll stack
	26598	+ label = 2193LLU; // continue to roll stack
26575	26599	break;
26576	26600	}
26577		- case 2196LLU: // return from reportid to ProcCall
	26601	+ case 2199LLU: // return from reportid to ProcCall
26578	26602	{
26579	26603	// copy mutable arguments back from call to reportid
26580	26604	fprintf(stderr, "%s", " call to ");
26581	26605	// call reportid from ProcCall
26582		- stack[base + 42LLU] = 2197LLU/throw to this address/;
	26606	+ stack[base + 42LLU] = 2200LLU/throw to this address/;
26583	26607	stack[base + 43LLU] = base;
26584		- stack[base + 44LLU] = 2198LLU;
	26608	+ stack[base + 44LLU] = 2201LLU;
26585	26609	// arguments for call to reportid
26586	26610	stack[base + 45LLU] = stack[base + 24]/ceid/;
26587	26611	// set stack-base & callee-address

		@@ -26589,21 +26613,21 @@
26589	26613	label = 18446744073709551586LLU; // reportid
26590	26614	break;
26591	26615	}
26592		- case 2197LLU: // copy-back deleter (reportid to ProcCall)
	26616	+ case 2200LLU: // copy-back deleter (reportid to ProcCall)
26593	26617	{
26594	26618	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
26595	26619	// copy mutable arguments back from call to reportid
26596		- label = 2190LLU; // continue to roll stack
	26620	+ label = 2193LLU; // continue to roll stack
26597	26621	break;
26598	26622	}
26599		- case 2198LLU: // return from reportid to ProcCall
	26623	+ case 2201LLU: // return from reportid to ProcCall
26600	26624	{
26601	26625	// copy mutable arguments back from call to reportid
26602	26626	fprintf(stderr, "%s", " at position ");
26603	26627	// call reportnr from ProcCall
26604		- stack[base + 42LLU] = 2199LLU/throw to this address/;
	26628	+ stack[base + 42LLU] = 2202LLU/throw to this address/;
26605	26629	stack[base + 43LLU] = base;
26606		- stack[base + 44LLU] = 2200LLU;
	26630	+ stack[base + 44LLU] = 2203LLU;
26607	26631	// arguments for call to reportnr
26608	26632	stack[base + 45LLU] = stack[base + 32]/index/;
26609	26633	// set stack-base & callee-address

		@@ -26611,14 +26635,14 @@
26611	26635	label = 18446744073709551589LLU; // reportnr
26612	26636	break;
26613	26637	}
26614		- case 2199LLU: // copy-back deleter (reportnr to ProcCall)
	26638	+ case 2202LLU: // copy-back deleter (reportnr to ProcCall)
26615	26639	{
26616	26640	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
26617	26641	// copy mutable arguments back from call to reportnr
26618		- label = 2190LLU; // continue to roll stack
	26642	+ label = 2193LLU; // continue to roll stack
26619	26643	break;
26620	26644	}
26621		- case 2200LLU: // return from reportnr to ProcCall
	26645	+ case 2203LLU: // return from reportnr to ProcCall
26622	26646	{
26623	26647	// copy mutable arguments back from call to reportnr
26624	26648	fprintf(stderr, "%s", " cannot return source of type ");

		@@ -26625,7 +26649,7 @@
26625	26649	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
26626	26650	if(!newstack)
26627	26651	{
26628		- label = 2190LLU; // throw: begin to unroll stack
	26652	+ label = 2193LLU; // throw: begin to unroll stack
26629	26653	break;
26630	26654	}
26631	26655

		@@ -26632,9 +26656,9 @@
26632	26656	newstack[10LLU] = 9876543210LLU; // overflow-marker
26633	26657	// call reporttype from ProcCall
26634	26658	newstack[0] = (uint64_t)stack; // backup stack location
26635		- newstack[1] = 2201LLU;
	26659	+ newstack[1] = 2204LLU;
26636	26660	newstack[2] = base;
26637		- newstack[3] = 2202LLU;
	26661	+ newstack[3] = 2205LLU;
26638	26662	// arguments for call to reporttype
26639	26663	newstack[4LLU] = stack[base + 40]/srctype/;
26640	26664	stack = newstack;

		@@ -26643,7 +26667,7 @@
26643	26667	label = 316LLU; // reporttype
26644	26668	break;
26645	26669	}
26646		- case 2201LLU: // copy-back deleter (reporttype to ProcCall)
	26670	+ case 2204LLU: // copy-back deleter (reporttype to ProcCall)
26647	26671	{
26648	26672	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
26649	26673	uint64_t oldstack = (uint64_t )stack[0];

		@@ -26655,10 +26679,10 @@
26655	26679	}
26656	26680	Free(10LLU + 1, sizeof(uint64_t), stack);
26657	26681	stack = oldstack;
26658		- label = 2190LLU; // continue to unroll stack
	26682	+ label = 2193LLU; // continue to unroll stack
26659	26683	break;
26660	26684	}
26661		- case 2202LLU: // return from reporttype to ProcCall
	26685	+ case 2205LLU: // return from reporttype to ProcCall
26662	26686	{
26663	26687	uint64_t oldstack = (uint64_t )stack[0];
26664	26688	// copy mutable arguments back from call to reporttype

		@@ -26673,7 +26697,7 @@
26673	26697	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
26674	26698	if(!newstack)
26675	26699	{
26676		- label = 2190LLU; // throw: begin to unroll stack
	26700	+ label = 2193LLU; // throw: begin to unroll stack
26677	26701	break;
26678	26702	}
26679	26703

		@@ -26680,9 +26704,9 @@
26680	26704	newstack[10LLU] = 9876543210LLU; // overflow-marker
26681	26705	// call reporttype from ProcCall
26682	26706	newstack[0] = (uint64_t)stack; // backup stack location
26683		- newstack[1] = 2203LLU;
	26707	+ newstack[1] = 2206LLU;
26684	26708	newstack[2] = base;
26685		- newstack[3] = 2204LLU;
	26709	+ newstack[3] = 2207LLU;
26686	26710	// arguments for call to reporttype
26687	26711	newstack[4LLU] = stack[base + 38]/dsttype/;
26688	26712	stack = newstack;

		@@ -26691,7 +26715,7 @@
26691	26715	label = 316LLU; // reporttype
26692	26716	break;
26693	26717	}
26694		- case 2203LLU: // copy-back deleter (reporttype to ProcCall)
	26718	+ case 2206LLU: // copy-back deleter (reporttype to ProcCall)
26695	26719	{
26696	26720	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reporttype to ProcCall)\n");
26697	26721	uint64_t oldstack = (uint64_t )stack[0];

		@@ -26703,10 +26727,10 @@
26703	26727	}
26704	26728	Free(10LLU + 1, sizeof(uint64_t), stack);
26705	26729	stack = oldstack;
26706		- label = 2190LLU; // continue to unroll stack
	26730	+ label = 2193LLU; // continue to unroll stack
26707	26731	break;
26708	26732	}
26709		- case 2204LLU: // return from reporttype to ProcCall
	26733	+ case 2207LLU: // return from reporttype to ProcCall
26710	26734	{
26711	26735	uint64_t oldstack = (uint64_t )stack[0];
26712	26736	// copy mutable arguments back from call to reporttype

		@@ -26719,16 +26743,16 @@
26719	26743	stack = oldstack;
26720	26744	fprintf(stderr, "%s", "\n");
26721	26745	exit(-1);
26722		- label = 2194LLU; // alternative complete
	26746	+ label = 2197LLU; // alternative complete
26723	26747	break;
26724	26748	}
26725		- case 2194LLU: // completed if-then-else
	26749	+ case 2197LLU: // completed if-then-else
26726	26750	{
26727	26751	stack[base + 30]/sum/ = 0;
26728	26752	// call add from ProcCall
26729		- stack[base + 42LLU] = 2205LLU/throw to this address/;
	26753	+ stack[base + 42LLU] = 2208LLU/throw to this address/;
26730	26754	stack[base + 43LLU] = base;
26731		- stack[base + 44LLU] = 2206LLU;
	26755	+ stack[base + 44LLU] = 2209LLU;
26732	26756	// arguments for call to add
26733	26757	stack[base + 46LLU] = stack[base + 10]/fnrescount/;
26734	26758	stack[base + 47LLU] = stack[base + 30]/sum/;

		@@ -26737,22 +26761,22 @@
26737	26761	label = 18446744073709551605LLU; // add
26738	26762	break;
26739	26763	}
26740		- case 2205LLU: // copy-back deleter (add to ProcCall)
	26764	+ case 2208LLU: // copy-back deleter (add to ProcCall)
26741	26765	{
26742	26766	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
26743	26767	// copy mutable arguments back from call to add
26744		- label = 2190LLU; // continue to roll stack
	26768	+ label = 2193LLU; // continue to roll stack
26745	26769	break;
26746	26770	}
26747		- case 2206LLU: // return from add to ProcCall
	26771	+ case 2209LLU: // return from add to ProcCall
26748	26772	{
26749	26773	// copy mutable arguments back from call to add
26750	26774	// copy back results provided by call to add
26751	26775	stack[base + 30] = stack[base + 45LLU];
26752	26776	// call add from ProcCall
26753		- stack[base + 42LLU] = 2207LLU/throw to this address/;
	26777	+ stack[base + 42LLU] = 2210LLU/throw to this address/;
26754	26778	stack[base + 43LLU] = base;
26755		- stack[base + 44LLU] = 2208LLU;
	26779	+ stack[base + 44LLU] = 2211LLU;
26756	26780	// arguments for call to add
26757	26781	stack[base + 46LLU] = stack[base + 11]/fnargcount/;
26758	26782	stack[base + 47LLU] = stack[base + 30]/sum/;

		@@ -26761,22 +26785,22 @@
26761	26785	label = 18446744073709551605LLU; // add
26762	26786	break;
26763	26787	}
26764		- case 2207LLU: // copy-back deleter (add to ProcCall)
	26788	+ case 2210LLU: // copy-back deleter (add to ProcCall)
26765	26789	{
26766	26790	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
26767	26791	// copy mutable arguments back from call to add
26768		- label = 2190LLU; // continue to roll stack
	26792	+ label = 2193LLU; // continue to roll stack
26769	26793	break;
26770	26794	}
26771		- case 2208LLU: // return from add to ProcCall
	26795	+ case 2211LLU: // return from add to ProcCall
26772	26796	{
26773	26797	// copy mutable arguments back from call to add
26774	26798	// copy back results provided by call to add
26775	26799	stack[base + 30] = stack[base + 45LLU];
26776	26800	// call add from ProcCall
26777		- stack[base + 42LLU] = 2209LLU/throw to this address/;
	26801	+ stack[base + 42LLU] = 2212LLU/throw to this address/;
26778	26802	stack[base + 43LLU] = base;
26779		- stack[base + 44LLU] = 2210LLU;
	26803	+ stack[base + 44LLU] = 2213LLU;
26780	26804	// arguments for call to add
26781	26805	stack[base + 46LLU] = stack[base + 4]/offset/;
26782	26806	stack[base + 47LLU] = stack[base + 30]/sum/;

		@@ -26785,22 +26809,22 @@
26785	26809	label = 18446744073709551605LLU; // add
26786	26810	break;
26787	26811	}
26788		- case 2209LLU: // copy-back deleter (add to ProcCall)
	26812	+ case 2212LLU: // copy-back deleter (add to ProcCall)
26789	26813	{
26790	26814	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
26791	26815	// copy mutable arguments back from call to add
26792		- label = 2190LLU; // continue to roll stack
	26816	+ label = 2193LLU; // continue to roll stack
26793	26817	break;
26794	26818	}
26795		- case 2210LLU: // return from add to ProcCall
	26819	+ case 2213LLU: // return from add to ProcCall
26796	26820	{
26797	26821	// copy mutable arguments back from call to add
26798	26822	// copy back results provided by call to add
26799	26823	stack[base + 30] = stack[base + 45LLU];
26800	26824	// call add from ProcCall
26801		- stack[base + 42LLU] = 2211LLU/throw to this address/;
	26825	+ stack[base + 42LLU] = 2214LLU/throw to this address/;
26802	26826	stack[base + 43LLU] = base;
26803		- stack[base + 44LLU] = 2212LLU;
	26827	+ stack[base + 44LLU] = 2215LLU;
26804	26828	// arguments for call to add
26805	26829	stack[base + 46LLU] = 3LLU;
26806	26830	stack[base + 47LLU] = stack[base + 30]/sum/;

		@@ -26809,22 +26833,22 @@
26809	26833	label = 18446744073709551605LLU; // add
26810	26834	break;
26811	26835	}
26812		- case 2211LLU: // copy-back deleter (add to ProcCall)
	26836	+ case 2214LLU: // copy-back deleter (add to ProcCall)
26813	26837	{
26814	26838	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
26815	26839	// copy mutable arguments back from call to add
26816		- label = 2190LLU; // continue to roll stack
	26840	+ label = 2193LLU; // continue to roll stack
26817	26841	break;
26818	26842	}
26819		- case 2212LLU: // return from add to ProcCall
	26843	+ case 2215LLU: // return from add to ProcCall
26820	26844	{
26821	26845	// copy mutable arguments back from call to add
26822	26846	// copy back results provided by call to add
26823	26847	stack[base + 30] = stack[base + 45LLU];
26824	26848	// call add from ProcCall
26825		- stack[base + 42LLU] = 2213LLU/throw to this address/;
	26849	+ stack[base + 42LLU] = 2216LLU/throw to this address/;
26826	26850	stack[base + 43LLU] = base;
26827		- stack[base + 44LLU] = 2214LLU;
	26851	+ stack[base + 44LLU] = 2217LLU;
26828	26852	// arguments for call to add
26829	26853	stack[base + 46LLU] = stack[base + 32]/index/;
26830	26854	stack[base + 47LLU] = stack[base + 30]/sum/;

		@@ -26833,14 +26857,14 @@
26833	26857	label = 18446744073709551605LLU; // add
26834	26858	break;
26835	26859	}
26836		- case 2213LLU: // copy-back deleter (add to ProcCall)
	26860	+ case 2216LLU: // copy-back deleter (add to ProcCall)
26837	26861	{
26838	26862	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
26839	26863	// copy mutable arguments back from call to add
26840		- label = 2190LLU; // continue to roll stack
	26864	+ label = 2193LLU; // continue to roll stack
26841	26865	break;
26842	26866	}
26843		- case 2214LLU: // return from add to ProcCall
	26867	+ case 2217LLU: // return from add to ProcCall
26844	26868	{
26845	26869	// copy mutable arguments back from call to add
26846	26870	// copy back results provided by call to add

		@@ -26847,9 +26871,9 @@
26847	26871	stack[base + 30] = stack[base + 45LLU];
26848	26872	printf("%s", "\n ");
26849	26873	// call emitvaridx from ProcCall
26850		- stack[base + 42LLU] = 2215LLU/throw to this address/;
	26874	+ stack[base + 42LLU] = 2218LLU/throw to this address/;
26851	26875	stack[base + 43LLU] = base;
26852		- stack[base + 44LLU] = 2216LLU;
	26876	+ stack[base + 44LLU] = 2219LLU;
26853	26877	// arguments for call to emitvaridx
26854	26878	stack[base + 45LLU] = stack[base + 39]/INDEX/;
26855	26879	// set stack-base & callee-address

		@@ -26857,21 +26881,21 @@
26857	26881	label = 691LLU; // emitvaridx
26858	26882	break;
26859	26883	}
26860		- case 2215LLU: // copy-back deleter (emitvaridx to ProcCall)
	26884	+ case 2218LLU: // copy-back deleter (emitvaridx to ProcCall)
26861	26885	{
26862	26886	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (emitvaridx to ProcCall)\n");
26863	26887	// copy mutable arguments back from call to emitvaridx
26864		- label = 2190LLU; // continue to roll stack
	26888	+ label = 2193LLU; // continue to roll stack
26865	26889	break;
26866	26890	}
26867		- case 2216LLU: // return from emitvaridx to ProcCall
	26891	+ case 2219LLU: // return from emitvaridx to ProcCall
26868	26892	{
26869	26893	// copy mutable arguments back from call to emitvaridx
26870	26894	printf("%s", " = stack[base + ");
26871	26895	// call printnr from ProcCall
26872		- stack[base + 42LLU] = 2217LLU/throw to this address/;
	26896	+ stack[base + 42LLU] = 2220LLU/throw to this address/;
26873	26897	stack[base + 43LLU] = base;
26874		- stack[base + 44LLU] = 2218LLU;
	26898	+ stack[base + 44LLU] = 2221LLU;
26875	26899	// arguments for call to printnr
26876	26900	stack[base + 45LLU] = stack[base + 30]/sum/;
26877	26901	// set stack-base & callee-address

		@@ -26879,54 +26903,54 @@
26879	26903	label = 18446744073709551590LLU; // printnr
26880	26904	break;
26881	26905	}
26882		- case 2217LLU: // copy-back deleter (printnr to ProcCall)
	26906	+ case 2220LLU: // copy-back deleter (printnr to ProcCall)
26883	26907	{
26884	26908	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (printnr to ProcCall)\n");
26885	26909	// copy mutable arguments back from call to printnr
26886		- label = 2190LLU; // continue to roll stack
	26910	+ label = 2193LLU; // continue to roll stack
26887	26911	break;
26888	26912	}
26889		- case 2218LLU: // return from printnr to ProcCall
	26913	+ case 2221LLU: // return from printnr to ProcCall
26890	26914	{
26891	26915	// copy mutable arguments back from call to printnr
26892	26916	printf("%s", "LLU];");
26893	26917	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 41];
26894	26918	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 40];
26895		- label = 2188LLU; // case complete
	26919	+ label = 2191LLU; // case complete
26896	26920	break;
26897	26921	}
26898		- case 2190LLU: // copy-back deleter (switch)
	26922	+ case 2193LLU: // copy-back deleter (switch)
26899	26923	{
26900	26924	((uint64_t **)(stack[base + 35]))[1][1] = stack[base + 41];
26901	26925	((uint64_t **)(stack[base + 35]))[1][0] = stack[base + 40];
26902		- label = 2187LLU; // continue to unroll stack
	26926	+ label = 2190LLU; // continue to unroll stack
26903	26927	break;
26904	26928	}
26905		- case 2189LLU: // try next case
	26929	+ case 2192LLU: // try next case
26906	26930	{
26907	26931	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
26908	26932	exit(-1);
26909	26933	}
26910		- case 2188LLU: // completed switch
	26934	+ case 2191LLU: // completed switch
26911	26935	{
26912	26936	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 39];
26913	26937	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 38];
26914		- label = 2185LLU; // case complete
	26938	+ label = 2188LLU; // case complete
26915	26939	break;
26916	26940	}
26917		- case 2187LLU: // copy-back deleter (switch)
	26941	+ case 2190LLU: // copy-back deleter (switch)
26918	26942	{
26919	26943	((uint64_t **)(stack[base + 37]))[1][1] = stack[base + 39];
26920	26944	((uint64_t **)(stack[base + 37]))[1][0] = stack[base + 38];
26921		- label = 2178LLU; // continue to unroll stack
	26945	+ label = 2187LLU; // continue to unroll stack
26922	26946	break;
26923	26947	}
26924		- case 2186LLU: // try next case
	26948	+ case 2189LLU: // try next case
26925	26949	{
26926	26950	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
26927	26951	exit(-1);
26928	26952	}
26929		- case 2185LLU: // completed switch
	26953	+ case 2188LLU: // completed switch
26930	26954	{
26931	26955
26932	26956	uint64_t newstack = (uint64_t )(stack[base + 37] - sizeof(uint64_t) * 4);

		@@ -26934,7 +26958,7 @@
26934	26958	newstack[0] = (uint64_t)stack; // backup stack location
26935	26959	newstack[1] = 1234567890;
26936	26960	newstack[2] = base;
26937		- newstack[3] = 2219LLU;
	26961	+ newstack[3] = 2222LLU;
26938	26962	stack = newstack;
26939	26963	// set stack-base & callee-address
26940	26964	base = 4/deloffset/;

		@@ -26941,22 +26965,46 @@
26941	26965	label = 379LLU; // ~typeidx
26942	26966	break;
26943	26967	}
26944		- case 2219LLU: // return from ~typeidx to ProcCall
	26968	+ case 2222LLU: // return from ~typeidx to ProcCall
26945	26969	{
26946	26970	stack = (uint64_t *)stack[0];
26947	26971	// releasing toplevel container
26948	26972	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 37] - sizeof(uint64_t) 4));
26949	26973
26950		- label = 2184LLU; // consequent complete
	26974	+ label = 2186LLU; // consequent complete
26951	26975	break;
26952	26976	}
26953		- case 2183LLU: // alternative
	26977	+ case 2187LLU: // copy-back deleter (if pop)
26954	26978	{
	26979	+
	26980	+ uint64_t newstack = (uint64_t )(stack[base + 37] - sizeof(uint64_t) * 4);
	26981	+ // call ~typeidx from ProcCall
	26982	+ newstack[0] = (uint64_t)stack; // backup stack location
	26983	+ newstack[1] = 1234567890;
	26984	+ newstack[2] = base;
	26985	+ newstack[3] = 2223LLU;
	26986	+ stack = newstack;
	26987	+ // set stack-base & callee-address
	26988	+ base = 4/deloffset/;
	26989	+ label = 379LLU; // ~typeidx
	26990	+ break;
	26991	+ }
	26992	+ case 2223LLU: // return from ~typeidx to ProcCall
	26993	+ {
	26994	+ stack = (uint64_t *)stack[0];
	26995	+ // releasing toplevel container
	26996	+ Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 37] - sizeof(uint64_t) 4));
	26997	+
	26998	+ label = 2180LLU; // consequent complete
	26999	+ break;
	27000	+ }
	27001	+ case 2185LLU: // alternative
	27002	+ {
26955	27003	fprintf(stderr, "%s", "in function ");
26956	27004	// call reportid from ProcCall
26957		- stack[base + 38LLU] = 2220LLU/throw to this address/;
	27005	+ stack[base + 38LLU] = 2224LLU/throw to this address/;
26958	27006	stack[base + 39LLU] = base;
26959		- stack[base + 40LLU] = 2221LLU;
	27007	+ stack[base + 40LLU] = 2225LLU;
26960	27008	// arguments for call to reportid
26961	27009	stack[base + 41LLU] = stack[base + 8]/fnid/;
26962	27010	// set stack-base & callee-address

		@@ -26964,21 +27012,21 @@
26964	27012	label = 18446744073709551586LLU; // reportid
26965	27013	break;
26966	27014	}
26967		- case 2220LLU: // copy-back deleter (reportid to ProcCall)
	27015	+ case 2224LLU: // copy-back deleter (reportid to ProcCall)
26968	27016	{
26969	27017	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
26970	27018	// copy mutable arguments back from call to reportid
26971		- label = 2178LLU; // continue to roll stack
	27019	+ label = 2180LLU; // continue to roll stack
26972	27020	break;
26973	27021	}
26974		- case 2221LLU: // return from reportid to ProcCall
	27022	+ case 2225LLU: // return from reportid to ProcCall
26975	27023	{
26976	27024	// copy mutable arguments back from call to reportid
26977	27025	fprintf(stderr, "%s", " call to ");
26978	27026	// call reportid from ProcCall
26979		- stack[base + 38LLU] = 2222LLU/throw to this address/;
	27027	+ stack[base + 38LLU] = 2226LLU/throw to this address/;
26980	27028	stack[base + 39LLU] = base;
26981		- stack[base + 40LLU] = 2223LLU;
	27029	+ stack[base + 40LLU] = 2227LLU;
26982	27030	// arguments for call to reportid
26983	27031	stack[base + 41LLU] = stack[base + 24]/ceid/;
26984	27032	// set stack-base & callee-address

		@@ -26986,21 +27034,21 @@
26986	27034	label = 18446744073709551586LLU; // reportid
26987	27035	break;
26988	27036	}
26989		- case 2222LLU: // copy-back deleter (reportid to ProcCall)
	27037	+ case 2226LLU: // copy-back deleter (reportid to ProcCall)
26990	27038	{
26991	27039	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
26992	27040	// copy mutable arguments back from call to reportid
26993		- label = 2178LLU; // continue to roll stack
	27041	+ label = 2180LLU; // continue to roll stack
26994	27042	break;
26995	27043	}
26996		- case 2223LLU: // return from reportid to ProcCall
	27044	+ case 2227LLU: // return from reportid to ProcCall
26997	27045	{
26998	27046	// copy mutable arguments back from call to reportid
26999	27047	fprintf(stderr, "%s", " at position ");
27000	27048	// call reportnr from ProcCall
27001		- stack[base + 38LLU] = 2224LLU/throw to this address/;
	27049	+ stack[base + 38LLU] = 2228LLU/throw to this address/;
27002	27050	stack[base + 39LLU] = base;
27003		- stack[base + 40LLU] = 2225LLU;
	27051	+ stack[base + 40LLU] = 2229LLU;
27004	27052	// arguments for call to reportnr
27005	27053	stack[base + 41LLU] = stack[base + 32]/index/;
27006	27054	// set stack-base & callee-address

		@@ -27008,51 +27056,51 @@
27008	27056	label = 18446744073709551589LLU; // reportnr
27009	27057	break;
27010	27058	}
27011		- case 2224LLU: // copy-back deleter (reportnr to ProcCall)
	27059	+ case 2228LLU: // copy-back deleter (reportnr to ProcCall)
27012	27060	{
27013	27061	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportnr to ProcCall)\n");
27014	27062	// copy mutable arguments back from call to reportnr
27015		- label = 2178LLU; // continue to roll stack
	27063	+ label = 2180LLU; // continue to roll stack
27016	27064	break;
27017	27065	}
27018		- case 2225LLU: // return from reportnr to ProcCall
	27066	+ case 2229LLU: // return from reportnr to ProcCall
27019	27067	{
27020	27068	// copy mutable arguments back from call to reportnr
27021	27069	fprintf(stderr, "%s", " not enough destination-variables for results");
27022	27070	fprintf(stderr, "%s", "\n");
27023	27071	exit(-1);
27024		- label = 2184LLU; // alternative complete
	27072	+ label = 2186LLU; // alternative complete
27025	27073	break;
27026	27074	}
27027		- case 2184LLU: // completed if-then-else
	27075	+ case 2186LLU: // completed if-then-else
27028	27076	{
27029	27077	((struct listnode )(stack[base + 36]/previous*/))->data = stack[base + 35];
27030		- label = 2176LLU; // repeat
	27078	+ label = 2178LLU; // repeat
27031	27079	break;
27032	27080	}
27033		- case 2178LLU: // copy-back deleter for while next
	27081	+ case 2180LLU: // copy-back deleter for while next
27034	27082	{
27035	27083	((struct listnode )(stack[base + 36]/previous*/))->data = stack[base + 35];
27036		- label = 1939LLU; // continue to unroll stack
	27084	+ label = 1941LLU; // continue to unroll stack
27037	27085	break;
27038	27086	}
27039		- case 2177LLU: // loop finished
	27087	+ case 2179LLU: // loop finished
27040	27088	{
27041		- label = 2173LLU; // consequent complete
	27089	+ label = 2175LLU; // consequent complete
27042	27090	break;
27043	27091	}
27044		- case 2172LLU: // alternative
	27092	+ case 2174LLU: // alternative
27045	27093	{
27046		- label = 2173LLU; // alternative complete
	27094	+ label = 2175LLU; // alternative complete
27047	27095	break;
27048	27096	}
27049		- case 2173LLU: // completed if-then-else
	27097	+ case 2175LLU: // completed if-then-else
27050	27098	{
27051	27099	stack[base + 30]/sum/ = 0;
27052	27100	// call add from ProcCall
27053		- stack[base + 34LLU] = 2226LLU/throw to this address/;
	27101	+ stack[base + 34LLU] = 2230LLU/throw to this address/;
27054	27102	stack[base + 35LLU] = base;
27055		- stack[base + 36LLU] = 2227LLU;
	27103	+ stack[base + 36LLU] = 2231LLU;
27056	27104	// arguments for call to add
27057	27105	stack[base + 38LLU] = stack[base + 4]/offset/;
27058	27106	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -27061,22 +27109,22 @@
27061	27109	label = 18446744073709551605LLU; // add
27062	27110	break;
27063	27111	}
27064		- case 2226LLU: // copy-back deleter (add to ProcCall)
	27112	+ case 2230LLU: // copy-back deleter (add to ProcCall)
27065	27113	{
27066	27114	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
27067	27115	// copy mutable arguments back from call to add
27068		- label = 1939LLU; // continue to roll stack
	27116	+ label = 1941LLU; // continue to roll stack
27069	27117	break;
27070	27118	}
27071		- case 2227LLU: // return from add to ProcCall
	27119	+ case 2231LLU: // return from add to ProcCall
27072	27120	{
27073	27121	// copy mutable arguments back from call to add
27074	27122	// copy back results provided by call to add
27075	27123	stack[base + 30] = stack[base + 37LLU];
27076	27124	// call add from ProcCall
27077		- stack[base + 34LLU] = 2228LLU/throw to this address/;
	27125	+ stack[base + 34LLU] = 2232LLU/throw to this address/;
27078	27126	stack[base + 35LLU] = base;
27079		- stack[base + 36LLU] = 2229LLU;
	27127	+ stack[base + 36LLU] = 2233LLU;
27080	27128	// arguments for call to add
27081	27129	stack[base + 38LLU] = 3LLU;
27082	27130	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -27085,22 +27133,22 @@
27085	27133	label = 18446744073709551605LLU; // add
27086	27134	break;
27087	27135	}
27088		- case 2228LLU: // copy-back deleter (add to ProcCall)
	27136	+ case 2232LLU: // copy-back deleter (add to ProcCall)
27089	27137	{
27090	27138	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
27091	27139	// copy mutable arguments back from call to add
27092		- label = 1939LLU; // continue to roll stack
	27140	+ label = 1941LLU; // continue to roll stack
27093	27141	break;
27094	27142	}
27095		- case 2229LLU: // return from add to ProcCall
	27143	+ case 2233LLU: // return from add to ProcCall
27096	27144	{
27097	27145	// copy mutable arguments back from call to add
27098	27146	// copy back results provided by call to add
27099	27147	stack[base + 30] = stack[base + 37LLU];
27100	27148	// call add from ProcCall
27101		- stack[base + 34LLU] = 2230LLU/throw to this address/;
	27149	+ stack[base + 34LLU] = 2234LLU/throw to this address/;
27102	27150	stack[base + 35LLU] = base;
27103		- stack[base + 36LLU] = 2231LLU;
	27151	+ stack[base + 36LLU] = 2235LLU;
27104	27152	// arguments for call to add
27105	27153	stack[base + 38LLU] = stack[base + 28]/cerescount/;
27106	27154	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -27109,22 +27157,22 @@
27109	27157	label = 18446744073709551605LLU; // add
27110	27158	break;
27111	27159	}
27112		- case 2230LLU: // copy-back deleter (add to ProcCall)
	27160	+ case 2234LLU: // copy-back deleter (add to ProcCall)
27113	27161	{
27114	27162	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
27115	27163	// copy mutable arguments back from call to add
27116		- label = 1939LLU; // continue to roll stack
	27164	+ label = 1941LLU; // continue to roll stack
27117	27165	break;
27118	27166	}
27119		- case 2231LLU: // return from add to ProcCall
	27167	+ case 2235LLU: // return from add to ProcCall
27120	27168	{
27121	27169	// copy mutable arguments back from call to add
27122	27170	// copy back results provided by call to add
27123	27171	stack[base + 30] = stack[base + 37LLU];
27124	27172	// call add from ProcCall
27125		- stack[base + 34LLU] = 2232LLU/throw to this address/;
	27173	+ stack[base + 34LLU] = 2236LLU/throw to this address/;
27126	27174	stack[base + 35LLU] = base;
27127		- stack[base + 36LLU] = 2233LLU;
	27175	+ stack[base + 36LLU] = 2237LLU;
27128	27176	// arguments for call to add
27129	27177	stack[base + 38LLU] = stack[base + 29]/ceargcount/;
27130	27178	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -27133,22 +27181,22 @@
27133	27181	label = 18446744073709551605LLU; // add
27134	27182	break;
27135	27183	}
27136		- case 2232LLU: // copy-back deleter (add to ProcCall)
	27184	+ case 2236LLU: // copy-back deleter (add to ProcCall)
27137	27185	{
27138	27186	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
27139	27187	// copy mutable arguments back from call to add
27140		- label = 1939LLU; // continue to roll stack
	27188	+ label = 1941LLU; // continue to roll stack
27141	27189	break;
27142	27190	}
27143		- case 2233LLU: // return from add to ProcCall
	27191	+ case 2237LLU: // return from add to ProcCall
27144	27192	{
27145	27193	// copy mutable arguments back from call to add
27146	27194	// copy back results provided by call to add
27147	27195	stack[base + 30] = stack[base + 37LLU];
27148	27196	// call add from ProcCall
27149		- stack[base + 34LLU] = 2234LLU/throw to this address/;
	27197	+ stack[base + 34LLU] = 2238LLU/throw to this address/;
27150	27198	stack[base + 35LLU] = base;
27151		- stack[base + 36LLU] = 2235LLU;
	27199	+ stack[base + 36LLU] = 2239LLU;
27152	27200	// arguments for call to add
27153	27201	stack[base + 38LLU] = stack[base + 23]/cemaxcount/;
27154	27202	stack[base + 39LLU] = stack[base + 30]/sum/;

		@@ -27157,22 +27205,22 @@
27157	27205	label = 18446744073709551605LLU; // add
27158	27206	break;
27159	27207	}
27160		- case 2234LLU: // copy-back deleter (add to ProcCall)
	27208	+ case 2238LLU: // copy-back deleter (add to ProcCall)
27161	27209	{
27162	27210	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (add to ProcCall)\n");
27163	27211	// copy mutable arguments back from call to add
27164		- label = 1939LLU; // continue to roll stack
	27212	+ label = 1941LLU; // continue to roll stack
27165	27213	break;
27166	27214	}
27167		- case 2235LLU: // return from add to ProcCall
	27215	+ case 2239LLU: // return from add to ProcCall
27168	27216	{
27169	27217	// copy mutable arguments back from call to add
27170	27218	// copy back results provided by call to add
27171	27219	stack[base + 30] = stack[base + 37LLU];
27172	27220	// call max from ProcCall
27173		- stack[base + 34LLU] = 2236LLU/throw to this address/;
	27221	+ stack[base + 34LLU] = 2240LLU/throw to this address/;
27174	27222	stack[base + 35LLU] = base;
27175		- stack[base + 36LLU] = 2237LLU;
	27223	+ stack[base + 36LLU] = 2241LLU;
27176	27224	// arguments for call to max
27177	27225	stack[base + 38LLU] = stack[base + 30]/sum/;
27178	27226	stack[base + 39LLU] = stack[base + 12]/fnmaxcount/;

		@@ -27181,14 +27229,14 @@
27181	27229	label = 18446744073709551606LLU; // max
27182	27230	break;
27183	27231	}
27184		- case 2236LLU: // copy-back deleter (max to ProcCall)
	27232	+ case 2240LLU: // copy-back deleter (max to ProcCall)
27185	27233	{
27186	27234	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (max to ProcCall)\n");
27187	27235	// copy mutable arguments back from call to max
27188		- label = 1939LLU; // continue to roll stack
	27236	+ label = 1941LLU; // continue to roll stack
27189	27237	break;
27190	27238	}
27191		- case 2237LLU: // return from max to ProcCall
	27239	+ case 2241LLU: // return from max to ProcCall
27192	27240	{
27193	27241	// copy mutable arguments back from call to max
27194	27242	// copy back results provided by call to max

		@@ -27200,7 +27248,7 @@
27200	27248	{
27201	27249	if(!stack[base + 0]/dsttypeids/)
27202	27250	{
27203		- label = 2238LLU; // jump to alternative
	27251	+ label = 2242LLU; // jump to alternative
27204	27252	break;
27205	27253	}
27206	27254

		@@ -27207,9 +27255,9 @@
27207	27255	// consequent
27208	27256	fprintf(stderr, "%s", "in function ");
27209	27257	// call reportid from ProcCall
27210		- stack[base + 30LLU] = 2240LLU/throw to this address/;
	27258	+ stack[base + 30LLU] = 2244LLU/throw to this address/;
27211	27259	stack[base + 31LLU] = base;
27212		- stack[base + 32LLU] = 2241LLU;
	27260	+ stack[base + 32LLU] = 2245LLU;
27213	27261	// arguments for call to reportid
27214	27262	stack[base + 33LLU] = stack[base + 8]/fnid/;
27215	27263	// set stack-base & callee-address

		@@ -27217,7 +27265,7 @@
27217	27265	label = 18446744073709551586LLU; // reportid
27218	27266	break;
27219	27267	}
27220		- case 2240LLU: // copy-back deleter (reportid to ProcCall)
	27268	+ case 2244LLU: // copy-back deleter (reportid to ProcCall)
27221	27269	{
27222	27270	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
27223	27271	// copy mutable arguments back from call to reportid

		@@ -27224,14 +27272,14 @@
27224	27272	label = 1596LLU; // continue to roll stack
27225	27273	break;
27226	27274	}
27227		- case 2241LLU: // return from reportid to ProcCall
	27275	+ case 2245LLU: // return from reportid to ProcCall
27228	27276	{
27229	27277	// copy mutable arguments back from call to reportid
27230	27278	fprintf(stderr, "%s", " call to ");
27231	27279	// call reportid from ProcCall
27232		- stack[base + 30LLU] = 2242LLU/throw to this address/;
	27280	+ stack[base + 30LLU] = 2246LLU/throw to this address/;
27233	27281	stack[base + 31LLU] = base;
27234		- stack[base + 32LLU] = 2243LLU;
	27282	+ stack[base + 32LLU] = 2247LLU;
27235	27283	// arguments for call to reportid
27236	27284	stack[base + 33LLU] = stack[base + 24]/ceid/;
27237	27285	// set stack-base & callee-address

		@@ -27239,7 +27287,7 @@
27239	27287	label = 18446744073709551586LLU; // reportid
27240	27288	break;
27241	27289	}
27242		- case 2242LLU: // copy-back deleter (reportid to ProcCall)
	27290	+ case 2246LLU: // copy-back deleter (reportid to ProcCall)
27243	27291	{
27244	27292	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (reportid to ProcCall)\n");
27245	27293	// copy mutable arguments back from call to reportid

		@@ -27246,21 +27294,21 @@
27246	27294	label = 1596LLU; // continue to roll stack
27247	27295	break;
27248	27296	}
27249		- case 2243LLU: // return from reportid to ProcCall
	27297	+ case 2247LLU: // return from reportid to ProcCall
27250	27298	{
27251	27299	// copy mutable arguments back from call to reportid
27252	27300	fprintf(stderr, "%s", " not enough results to fill all destination-variables");
27253	27301	fprintf(stderr, "%s", "\n");
27254	27302	exit(-1);
27255		- label = 2239LLU; // consequent complete
	27303	+ label = 2243LLU; // consequent complete
27256	27304	break;
27257	27305	}
27258		- case 2238LLU: // alternative
	27306	+ case 2242LLU: // alternative
27259	27307	{
27260		- label = 2239LLU; // alternative complete
	27308	+ label = 2243LLU; // alternative complete
27261	27309	break;
27262	27310	}
27263		- case 2239LLU: // completed if-then-else
	27311	+ case 2243LLU: // completed if-then-else
27264	27312	{
27265	27313	((uint64_t **)(stack[base + 13]))[1][7] = stack[base + 27];
27266	27314	((uint64_t **)(stack[base + 13]))[1][6] = stack[base + 26];

		@@ -27294,14 +27342,14 @@
27294	27342	case 1575LLU: // completed switch
27295	27343	{
27296	27344	// delete list
27297		- label = 2244LLU; // start to repeat
	27345	+ label = 2248LLU; // start to repeat
27298	27346	break;
27299	27347	}
27300		- case 2244LLU: // repeat from here
	27348	+ case 2248LLU: // repeat from here
27301	27349	{
27302	27350	if(!stack[base + 19])
27303	27351	{
27304		- label = 2245LLU; // break loop
	27352	+ label = 2249LLU; // break loop
27305	27353	break;
27306	27354	}
27307	27355

		@@ -27312,7 +27360,7 @@
27312	27360	newstack[0] = (uint64_t)stack; // backup stack location
27313	27361	newstack[1] = 1234567890;
27314	27362	newstack[2] = base;
27315		- newstack[3] = 2246LLU;
	27363	+ newstack[3] = 2250LLU;
27316	27364	stack = newstack;
27317	27365	// set stack-base & callee-address
27318	27366	base = 4/deloffset/;

		@@ -27319,7 +27367,7 @@
27319	27367	label = 798LLU; // ~idnr
27320	27368	break;
27321	27369	}
27322		- case 2246LLU: // return from ~idnr to ProcCall
	27370	+ case 2250LLU: // return from ~idnr to ProcCall
27323	27371	{
27324	27372	stack = (uint64_t *)stack[0];
27325	27373	// releasing toplevel container

		@@ -27330,15 +27378,15 @@
27330	27378	stack[base + 19] = (uint64_t)list->next;
27331	27379	Free(1, sizeof(struct listnode), list);
27332	27380	}
27333		- label = 2244LLU; // repeat
	27381	+ label = 2248LLU; // repeat
27334	27382	break;
27335	27383	}
27336		- case 2245LLU: // loop finished
	27384	+ case 2249LLU: // loop finished
27337	27385	{
27338	27386	// call MATCHPEEK from ProcCall
27339		- stack[base + 19LLU] = 2247LLU/throw to this address/;
	27387	+ stack[base + 19LLU] = 2251LLU/throw to this address/;
27340	27388	stack[base + 20LLU] = base;
27341		- stack[base + 21LLU] = 2248LLU;
	27389	+ stack[base + 21LLU] = 2252LLU;
27342	27390	// arguments for call to MATCHPEEK
27343	27391	stack[base + 22LLU] = stack[base + 8]/fnid/;
27344	27392	stack[base + 23LLU] = 41LLU;

		@@ -27348,7 +27396,7 @@
27348	27396	label = 198LLU; // MATCHPEEK
27349	27397	break;
27350	27398	}
27351		- case 2247LLU: // copy-back deleter (MATCHPEEK to ProcCall)
	27399	+ case 2251LLU: // copy-back deleter (MATCHPEEK to ProcCall)
27352	27400	{
27353	27401	fprintf(stderr, "in function ProcCall: unrolling stack, copy-back (MATCHPEEK to ProcCall)\n");
27354	27402	// copy mutable arguments back from call to MATCHPEEK

		@@ -27356,7 +27404,7 @@
27356	27404	label = 1568LLU; // continue to roll stack
27357	27405	break;
27358	27406	}
27359		- case 2248LLU: // return from MATCHPEEK to ProcCall
	27407	+ case 2252LLU: // return from MATCHPEEK to ProcCall
27360	27408	{
27361	27409	// copy mutable arguments back from call to MATCHPEEK
27362	27410	stack[base + 14]/lookahead/ = stack[base + 24LLU];

		@@ -27365,7 +27413,7 @@
27365	27413	base = stack[base - 2];
27366	27414	break;
27367	27415	}
27368		- case 2250LLU: // function initfrom failed
	27416	+ case 2254LLU: // function initfrom failed
27369	27417	{
27370	27418	fprintf(stderr, "function initfrom failed\n");
27371	27419	label = stack[base - 3];

		@@ -27372,7 +27420,7 @@
27372	27420	base = stack[base - 2];
27373	27421	break;
27374	27422	}
27375		- case 2249LLU: // initfrom
	27423	+ case 2253LLU: // initfrom
27376	27424	{
27377	27425	//#define arg0 0
27378	27426	//#define arg1 1

		@@ -27383,67 +27431,67 @@
27383	27431	//#define arg6 6
27384	27432	//#define arg7 7
27385	27433	//#define arg8 8
27386		- label = 2252LLU; // skip deleter
	27434	+ label = 2256LLU; // skip deleter
27387	27435	break;
27388	27436	}
27389		- case 2251LLU: // deleter
	27437	+ case 2255LLU: // deleter
27390	27438	{
27391	27439	// throw from initfrom
27392	27440	if(!stack[base + 9])
27393	27441	{
27394	27442	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27395		- label = 2250LLU; // skip, variable already deleted/unscoped
	27443	+ label = 2254LLU; // skip, variable already deleted/unscoped
27396	27444	break;
27397	27445	}
27398	27446	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27399		- label = 2250LLU; // continue unrolling stack, delete next variable
	27447	+ label = 2254LLU; // continue unrolling stack, delete next variable
27400	27448	break;
27401	27449	}
27402		- case 2252LLU: // skipped deleter
	27450	+ case 2256LLU: // skipped deleter
27403	27451	{
27404	27452	stack[base + 9] = 0;
27405		- label = 2254LLU; // skip deleter
	27453	+ label = 2258LLU; // skip deleter
27406	27454	break;
27407	27455	}
27408		- case 2253LLU: // deleter
	27456	+ case 2257LLU: // deleter
27409	27457	{
27410	27458	// throw from initfrom
27411	27459	if(!stack[base + 10])
27412	27460	{
27413	27461	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27414		- label = 2251LLU; // skip, variable already deleted/unscoped
	27462	+ label = 2255LLU; // skip, variable already deleted/unscoped
27415	27463	break;
27416	27464	}
27417	27465	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27418		- label = 2251LLU; // continue unrolling stack, delete next variable
	27466	+ label = 2255LLU; // continue unrolling stack, delete next variable
27419	27467	break;
27420	27468	}
27421		- case 2254LLU: // skipped deleter
	27469	+ case 2258LLU: // skipped deleter
27422	27470	{
27423	27471	stack[base + 10] = 0;
27424		- label = 2256LLU; // skip deleter
	27472	+ label = 2260LLU; // skip deleter
27425	27473	break;
27426	27474	}
27427		- case 2255LLU: // deleter
	27475	+ case 2259LLU: // deleter
27428	27476	{
27429	27477	// throw from initfrom
27430	27478	if(!stack[base + 11])
27431	27479	{
27432	27480	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27433		- label = 2253LLU; // skip, variable already deleted/unscoped
	27481	+ label = 2257LLU; // skip, variable already deleted/unscoped
27434	27482	break;
27435	27483	}
27436	27484	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27437		- label = 2253LLU; // continue unrolling stack, delete next variable
	27485	+ label = 2257LLU; // continue unrolling stack, delete next variable
27438	27486	break;
27439	27487	}
27440		- case 2256LLU: // skipped deleter
	27488	+ case 2260LLU: // skipped deleter
27441	27489	{
27442	27490	stack[base + 11] = 0;
27443	27491	// call add from initfrom
27444		- stack[base + 12LLU] = 2257LLU/throw to this address/;
	27492	+ stack[base + 12LLU] = 2261LLU/throw to this address/;
27445	27493	stack[base + 13LLU] = base;
27446		- stack[base + 14LLU] = 2258LLU;
	27494	+ stack[base + 14LLU] = 2262LLU;
27447	27495	// arguments for call to add
27448	27496	stack[base + 16LLU] = 1LLU;
27449	27497	stack[base + 17LLU] = stack[base + 7]/label/;

		@@ -27452,40 +27500,40 @@
27452	27500	label = 18446744073709551605LLU; // add
27453	27501	break;
27454	27502	}
27455		- case 2257LLU: // copy-back deleter (add to initfrom)
	27503	+ case 2261LLU: // copy-back deleter (add to initfrom)
27456	27504	{
27457	27505	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
27458	27506	// copy mutable arguments back from call to add
27459		- label = 2255LLU; // continue to roll stack
	27507	+ label = 2259LLU; // continue to roll stack
27460	27508	break;
27461	27509	}
27462		- case 2258LLU: // return from add to initfrom
	27510	+ case 2262LLU: // return from add to initfrom
27463	27511	{
27464	27512	// copy mutable arguments back from call to add
27465	27513	// copy back results provided by call to add
27466	27514	stack[base + 7] = stack[base + 15LLU];
27467		- label = 2260LLU; // skip deleter
	27515	+ label = 2264LLU; // skip deleter
27468	27516	break;
27469	27517	}
27470		- case 2259LLU: // deleter
	27518	+ case 2263LLU: // deleter
27471	27519	{
27472	27520	// throw from initfrom
27473	27521	if(!stack[base + 12])
27474	27522	{
27475	27523	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27476		- label = 2255LLU; // skip, variable already deleted/unscoped
	27524	+ label = 2259LLU; // skip, variable already deleted/unscoped
27477	27525	break;
27478	27526	}
27479	27527	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27480		- label = 2255LLU; // continue unrolling stack, delete next variable
	27528	+ label = 2259LLU; // continue unrolling stack, delete next variable
27481	27529	break;
27482	27530	}
27483		- case 2260LLU: // skipped deleter
	27531	+ case 2264LLU: // skipped deleter
27484	27532	{
27485	27533	stack[base + 12] = stack[base + 7]/label/;
27486	27534	if(/scope/0 != ((uint64_t )(stack[base + 5]/scope*/))[0])
27487	27535	{
27488		- label = 2262LLU; // jump to alternative
	27536	+ label = 2266LLU; // jump to alternative
27489	27537	break;
27490	27538	}
27491	27539

		@@ -27494,9 +27542,9 @@
27494	27542
27495	27543	// case
27496	27544	// call add from initfrom
27497		- stack[base + 15LLU] = 2264LLU/throw to this address/;
	27545	+ stack[base + 15LLU] = 2268LLU/throw to this address/;
27498	27546	stack[base + 16LLU] = base;
27499		- stack[base + 17LLU] = 2265LLU;
	27547	+ stack[base + 17LLU] = 2269LLU;
27500	27548	// arguments for call to add
27501	27549	stack[base + 19LLU] = 1LLU;
27502	27550	stack[base + 20LLU] = stack[base + 7]/label/;

		@@ -27505,42 +27553,42 @@
27505	27553	label = 18446744073709551605LLU; // add
27506	27554	break;
27507	27555	}
27508		- case 2264LLU: // copy-back deleter (add to initfrom)
	27556	+ case 2268LLU: // copy-back deleter (add to initfrom)
27509	27557	{
27510	27558	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (add to initfrom)\n");
27511	27559	// copy mutable arguments back from call to add
27512		- label = 2263LLU; // continue to roll stack
	27560	+ label = 2267LLU; // continue to roll stack
27513	27561	break;
27514	27562	}
27515		- case 2265LLU: // return from add to initfrom
	27563	+ case 2269LLU: // return from add to initfrom
27516	27564	{
27517	27565	// copy mutable arguments back from call to add
27518	27566	// copy back results provided by call to add
27519	27567	stack[base + 7] = stack[base + 18LLU];
27520		- label = 2267LLU; // skip deleter
	27568	+ label = 2271LLU; // skip deleter
27521	27569	break;
27522	27570	}
27523		- case 2266LLU: // deleter
	27571	+ case 2270LLU: // deleter
27524	27572	{
27525	27573	// throw from initfrom
27526	27574	if(!stack[base + 15])
27527	27575	{
27528	27576	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
27529		- label = 2263LLU; // skip, variable already deleted/unscoped
	27577	+ label = 2267LLU; // skip, variable already deleted/unscoped
27530	27578	break;
27531	27579	}
27532	27580	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
27533		- label = 2263LLU; // continue unrolling stack, delete next variable
	27581	+ label = 2267LLU; // continue unrolling stack, delete next variable
27534	27582	break;
27535	27583	}
27536		- case 2267LLU: // skipped deleter
	27584	+ case 2271LLU: // skipped deleter
27537	27585	{
27538	27586	stack[base + 15] = stack[base + 7]/label/;
27539	27587	printf("%s", "\n label = ");
27540	27588	// call printnr from initfrom
27541		- stack[base + 16LLU] = 2268LLU/throw to this address/;
	27589	+ stack[base + 16LLU] = 2272LLU/throw to this address/;
27542	27590	stack[base + 17LLU] = base;
27543		- stack[base + 18LLU] = 2269LLU;
	27591	+ stack[base + 18LLU] = 2273LLU;
27544	27592	// arguments for call to printnr
27545	27593	stack[base + 19LLU] = stack[base + 15]/labelskip/;
27546	27594	// set stack-base & callee-address

		@@ -27548,14 +27596,14 @@
27548	27596	label = 18446744073709551590LLU; // printnr
27549	27597	break;
27550	27598	}
27551		- case 2268LLU: // copy-back deleter (printnr to initfrom)
	27599	+ case 2272LLU: // copy-back deleter (printnr to initfrom)
27552	27600	{
27553	27601	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27554	27602	// copy mutable arguments back from call to printnr
27555		- label = 2266LLU; // continue to roll stack
	27603	+ label = 2270LLU; // continue to roll stack
27556	27604	break;
27557	27605	}
27558		- case 2269LLU: // return from printnr to initfrom
	27606	+ case 2273LLU: // return from printnr to initfrom
27559	27607	{
27560	27608	// copy mutable arguments back from call to printnr
27561	27609	printf("%s", "LLU; // skip deleter");

		@@ -27563,9 +27611,9 @@
27563	27611	printf("%s", "\n }");
27564	27612	printf("%s", "\n case ");
27565	27613	// call printnr from initfrom
27566		- stack[base + 16LLU] = 2270LLU/throw to this address/;
	27614	+ stack[base + 16LLU] = 2274LLU/throw to this address/;
27567	27615	stack[base + 17LLU] = base;
27568		- stack[base + 18LLU] = 2271LLU;
	27616	+ stack[base + 18LLU] = 2275LLU;
27569	27617	// arguments for call to printnr
27570	27618	stack[base + 19LLU] = stack[base + 12]/labelfail/;
27571	27619	// set stack-base & callee-address

		@@ -27573,14 +27621,14 @@
27573	27621	label = 18446744073709551590LLU; // printnr
27574	27622	break;
27575	27623	}
27576		- case 2270LLU: // copy-back deleter (printnr to initfrom)
	27624	+ case 2274LLU: // copy-back deleter (printnr to initfrom)
27577	27625	{
27578	27626	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27579	27627	// copy mutable arguments back from call to printnr
27580		- label = 2266LLU; // continue to roll stack
	27628	+ label = 2270LLU; // continue to roll stack
27581	27629	break;
27582	27630	}
27583		- case 2271LLU: // return from printnr to initfrom
	27631	+ case 2275LLU: // return from printnr to initfrom
27584	27632	{
27585	27633	// copy mutable arguments back from call to printnr
27586	27634	printf("%s", "LLU: // deleter");

		@@ -27587,9 +27635,9 @@
27587	27635	printf("%s", "\n {");
27588	27636	printf("%s", "\n // throw from ");
27589	27637	// call printid from initfrom
27590		- stack[base + 16LLU] = 2272LLU/throw to this address/;
	27638	+ stack[base + 16LLU] = 2276LLU/throw to this address/;
27591	27639	stack[base + 17LLU] = base;
27592		- stack[base + 18LLU] = 2273LLU;
	27640	+ stack[base + 18LLU] = 2277LLU;
27593	27641	// arguments for call to printid
27594	27642	stack[base + 19LLU] = stack[base + 0]/fnid/;
27595	27643	// set stack-base & callee-address

		@@ -27597,21 +27645,21 @@
27597	27645	label = 18446744073709551587LLU; // printid
27598	27646	break;
27599	27647	}
27600		- case 2272LLU: // copy-back deleter (printid to initfrom)
	27648	+ case 2276LLU: // copy-back deleter (printid to initfrom)
27601	27649	{
27602	27650	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27603	27651	// copy mutable arguments back from call to printid
27604		- label = 2266LLU; // continue to roll stack
	27652	+ label = 2270LLU; // continue to roll stack
27605	27653	break;
27606	27654	}
27607		- case 2273LLU: // return from printid to initfrom
	27655	+ case 2277LLU: // return from printid to initfrom
27608	27656	{
27609	27657	// copy mutable arguments back from call to printid
27610	27658	printf("%s", "\n if(!");
27611	27659	// call emitvaridx from initfrom
27612		- stack[base + 16LLU] = 2274LLU/throw to this address/;
	27660	+ stack[base + 16LLU] = 2278LLU/throw to this address/;
27613	27661	stack[base + 17LLU] = base;
27614		- stack[base + 18LLU] = 2275LLU;
	27662	+ stack[base + 18LLU] = 2279LLU;
27615	27663	// arguments for call to emitvaridx
27616	27664	stack[base + 19LLU] = stack[base + 2]/dstindex/;
27617	27665	// set stack-base & callee-address

		@@ -27619,14 +27667,14 @@
27619	27667	label = 691LLU; // emitvaridx
27620	27668	break;
27621	27669	}
27622		- case 2274LLU: // copy-back deleter (emitvaridx to initfrom)
	27670	+ case 2278LLU: // copy-back deleter (emitvaridx to initfrom)
27623	27671	{
27624	27672	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
27625	27673	// copy mutable arguments back from call to emitvaridx
27626		- label = 2266LLU; // continue to roll stack
	27674	+ label = 2270LLU; // continue to roll stack
27627	27675	break;
27628	27676	}
27629		- case 2275LLU: // return from emitvaridx to initfrom
	27677	+ case 2279LLU: // return from emitvaridx to initfrom
27630	27678	{
27631	27679	// copy mutable arguments back from call to emitvaridx
27632	27680	printf("%s", ")");

		@@ -27633,9 +27681,9 @@
27633	27681	printf("%s", "\n {");
27634	27682	printf("%s", "\n fprintf(stderr, \"in function ");
27635	27683	// call printid from initfrom
27636		- stack[base + 16LLU] = 2276LLU/throw to this address/;
	27684	+ stack[base + 16LLU] = 2280LLU/throw to this address/;
27637	27685	stack[base + 17LLU] = base;
27638		- stack[base + 18LLU] = 2277LLU;
	27686	+ stack[base + 18LLU] = 2281LLU;
27639	27687	// arguments for call to printid
27640	27688	stack[base + 19LLU] = stack[base + 0]/fnid/;
27641	27689	// set stack-base & callee-address

		@@ -27643,14 +27691,14 @@
27643	27691	label = 18446744073709551587LLU; // printid
27644	27692	break;
27645	27693	}
27646		- case 2276LLU: // copy-back deleter (printid to initfrom)
	27694	+ case 2280LLU: // copy-back deleter (printid to initfrom)
27647	27695	{
27648	27696	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27649	27697	// copy mutable arguments back from call to printid
27650		- label = 2266LLU; // continue to roll stack
	27698	+ label = 2270LLU; // continue to roll stack
27651	27699	break;
27652	27700	}
27653		- case 2277LLU: // return from printid to initfrom
	27701	+ case 2281LLU: // return from printid to initfrom
27654	27702	{
27655	27703	// copy mutable arguments back from call to printid
27656	27704	printf("%s", ": unrolling stack, skipping already deleted/unscoped variable ");

		@@ -27657,7 +27705,7 @@
27657	27705	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
27658	27706	if(!newstack)
27659	27707	{
27660		- label = 2266LLU; // throw: begin to unroll stack
	27708	+ label = 2270LLU; // throw: begin to unroll stack
27661	27709	break;
27662	27710	}
27663	27711

		@@ -27664,9 +27712,9 @@
27664	27712	newstack[10LLU] = 9876543210LLU; // overflow-marker
27665	27713	// call printtype from initfrom
27666	27714	newstack[0] = (uint64_t)stack; // backup stack location
27667		- newstack[1] = 2278LLU;
	27715	+ newstack[1] = 2282LLU;
27668	27716	newstack[2] = base;
27669		- newstack[3] = 2279LLU;
	27717	+ newstack[3] = 2283LLU;
27670	27718	// arguments for call to printtype
27671	27719	newstack[4LLU] = stack[base + 1]/dsttype/;
27672	27720	stack = newstack;

		@@ -27675,7 +27723,7 @@
27675	27723	label = 305LLU; // printtype
27676	27724	break;
27677	27725	}
27678		- case 2278LLU: // copy-back deleter (printtype to initfrom)
	27726	+ case 2282LLU: // copy-back deleter (printtype to initfrom)
27679	27727	{
27680	27728	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
27681	27729	uint64_t oldstack = (uint64_t )stack[0];

		@@ -27687,10 +27735,10 @@
27687	27735	}
27688	27736	Free(10LLU + 1, sizeof(uint64_t), stack);
27689	27737	stack = oldstack;
27690		- label = 2266LLU; // continue to unroll stack
	27738	+ label = 2270LLU; // continue to unroll stack
27691	27739	break;
27692	27740	}
27693		- case 2279LLU: // return from printtype to initfrom
	27741	+ case 2283LLU: // return from printtype to initfrom
27694	27742	{
27695	27743	uint64_t oldstack = (uint64_t )stack[0];
27696	27744	// copy mutable arguments back from call to printtype

		@@ -27703,9 +27751,9 @@
27703	27751	stack = oldstack;
27704	27752	printf("%s", " ");
27705	27753	// call printid from initfrom
27706		- stack[base + 16LLU] = 2280LLU/throw to this address/;
	27754	+ stack[base + 16LLU] = 2284LLU/throw to this address/;
27707	27755	stack[base + 17LLU] = base;
27708		- stack[base + 18LLU] = 2281LLU;
	27756	+ stack[base + 18LLU] = 2285LLU;
27709	27757	// arguments for call to printid
27710	27758	stack[base + 19LLU] = stack[base + 11]/content/;
27711	27759	// set stack-base & callee-address

		@@ -27713,22 +27761,22 @@
27713	27761	label = 18446744073709551587LLU; // printid
27714	27762	break;
27715	27763	}
27716		- case 2280LLU: // copy-back deleter (printid to initfrom)
	27764	+ case 2284LLU: // copy-back deleter (printid to initfrom)
27717	27765	{
27718	27766	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27719	27767	// copy mutable arguments back from call to printid
27720		- label = 2266LLU; // continue to roll stack
	27768	+ label = 2270LLU; // continue to roll stack
27721	27769	break;
27722	27770	}
27723		- case 2281LLU: // return from printid to initfrom
	27771	+ case 2285LLU: // return from printid to initfrom
27724	27772	{
27725	27773	// copy mutable arguments back from call to printid
27726	27774	printf("%s", "\\n\");");
27727	27775	printf("%s", "\n label = ");
27728	27776	// call printnr from initfrom
27729		- stack[base + 16LLU] = 2282LLU/throw to this address/;
	27777	+ stack[base + 16LLU] = 2286LLU/throw to this address/;
27730	27778	stack[base + 17LLU] = base;
27731		- stack[base + 18LLU] = 2283LLU;
	27779	+ stack[base + 18LLU] = 2287LLU;
27732	27780	// arguments for call to printnr
27733	27781	stack[base + 19LLU] = stack[base + 13]/labelthrow/;
27734	27782	// set stack-base & callee-address

		@@ -27736,14 +27784,14 @@
27736	27784	label = 18446744073709551590LLU; // printnr
27737	27785	break;
27738	27786	}
27739		- case 2282LLU: // copy-back deleter (printnr to initfrom)
	27787	+ case 2286LLU: // copy-back deleter (printnr to initfrom)
27740	27788	{
27741	27789	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27742	27790	// copy mutable arguments back from call to printnr
27743		- label = 2266LLU; // continue to roll stack
	27791	+ label = 2270LLU; // continue to roll stack
27744	27792	break;
27745	27793	}
27746		- case 2283LLU: // return from printnr to initfrom
	27794	+ case 2287LLU: // return from printnr to initfrom
27747	27795	{
27748	27796	// copy mutable arguments back from call to printnr
27749	27797	printf("%s", "LLU; // skip, variable already deleted/unscoped");

		@@ -27751,9 +27799,9 @@
27751	27799	printf("%s", "\n }");
27752	27800	printf("%s", "\n fprintf(stderr, \"in function ");
27753	27801	// call printid from initfrom
27754		- stack[base + 16LLU] = 2284LLU/throw to this address/;
	27802	+ stack[base + 16LLU] = 2288LLU/throw to this address/;
27755	27803	stack[base + 17LLU] = base;
27756		- stack[base + 18LLU] = 2285LLU;
	27804	+ stack[base + 18LLU] = 2289LLU;
27757	27805	// arguments for call to printid
27758	27806	stack[base + 19LLU] = stack[base + 0]/fnid/;
27759	27807	// set stack-base & callee-address

		@@ -27761,14 +27809,14 @@
27761	27809	label = 18446744073709551587LLU; // printid
27762	27810	break;
27763	27811	}
27764		- case 2284LLU: // copy-back deleter (printid to initfrom)
	27812	+ case 2288LLU: // copy-back deleter (printid to initfrom)
27765	27813	{
27766	27814	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27767	27815	// copy mutable arguments back from call to printid
27768		- label = 2266LLU; // continue to roll stack
	27816	+ label = 2270LLU; // continue to roll stack
27769	27817	break;
27770	27818	}
27771		- case 2285LLU: // return from printid to initfrom
	27819	+ case 2289LLU: // return from printid to initfrom
27772	27820	{
27773	27821	// copy mutable arguments back from call to printid
27774	27822	printf("%s", ": unrolling stack, variable ");

		@@ -27775,7 +27823,7 @@
27775	27823	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
27776	27824	if(!newstack)
27777	27825	{
27778		- label = 2266LLU; // throw: begin to unroll stack
	27826	+ label = 2270LLU; // throw: begin to unroll stack
27779	27827	break;
27780	27828	}
27781	27829

		@@ -27782,9 +27830,9 @@
27782	27830	newstack[10LLU] = 9876543210LLU; // overflow-marker
27783	27831	// call printtype from initfrom
27784	27832	newstack[0] = (uint64_t)stack; // backup stack location
27785		- newstack[1] = 2286LLU;
	27833	+ newstack[1] = 2290LLU;
27786	27834	newstack[2] = base;
27787		- newstack[3] = 2287LLU;
	27835	+ newstack[3] = 2291LLU;
27788	27836	// arguments for call to printtype
27789	27837	newstack[4LLU] = stack[base + 1]/dsttype/;
27790	27838	stack = newstack;

		@@ -27793,7 +27841,7 @@
27793	27841	label = 305LLU; // printtype
27794	27842	break;
27795	27843	}
27796		- case 2286LLU: // copy-back deleter (printtype to initfrom)
	27844	+ case 2290LLU: // copy-back deleter (printtype to initfrom)
27797	27845	{
27798	27846	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printtype to initfrom)\n");
27799	27847	uint64_t oldstack = (uint64_t )stack[0];

		@@ -27805,10 +27853,10 @@
27805	27853	}
27806	27854	Free(10LLU + 1, sizeof(uint64_t), stack);
27807	27855	stack = oldstack;
27808		- label = 2266LLU; // continue to unroll stack
	27856	+ label = 2270LLU; // continue to unroll stack
27809	27857	break;
27810	27858	}
27811		- case 2287LLU: // return from printtype to initfrom
	27859	+ case 2291LLU: // return from printtype to initfrom
27812	27860	{
27813	27861	uint64_t oldstack = (uint64_t )stack[0];
27814	27862	// copy mutable arguments back from call to printtype

		@@ -27821,9 +27869,9 @@
27821	27869	stack = oldstack;
27822	27870	printf("%s", " ");
27823	27871	// call printid from initfrom
27824		- stack[base + 16LLU] = 2288LLU/throw to this address/;
	27872	+ stack[base + 16LLU] = 2292LLU/throw to this address/;
27825	27873	stack[base + 17LLU] = base;
27826		- stack[base + 18LLU] = 2289LLU;
	27874	+ stack[base + 18LLU] = 2293LLU;
27827	27875	// arguments for call to printid
27828	27876	stack[base + 19LLU] = stack[base + 11]/content/;
27829	27877	// set stack-base & callee-address

		@@ -27831,14 +27879,14 @@
27831	27879	label = 18446744073709551587LLU; // printid
27832	27880	break;
27833	27881	}
27834		- case 2288LLU: // copy-back deleter (printid to initfrom)
	27882	+ case 2292LLU: // copy-back deleter (printid to initfrom)
27835	27883	{
27836	27884	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
27837	27885	// copy mutable arguments back from call to printid
27838		- label = 2266LLU; // continue to roll stack
	27886	+ label = 2270LLU; // continue to roll stack
27839	27887	break;
27840	27888	}
27841		- case 2289LLU: // return from printid to initfrom
	27889	+ case 2293LLU: // return from printid to initfrom
27842	27890	{
27843	27891	// copy mutable arguments back from call to printid
27844	27892	printf("%s", "\\n\");");

		@@ -27845,7 +27893,7 @@
27845	27893	uint64_t newstack = (uint64_t )Calloc(75LLU + 1, sizeof(uint64_t));
27846	27894	if(!newstack)
27847	27895	{
27848		- label = 2266LLU; // throw: begin to unroll stack
	27896	+ label = 2270LLU; // throw: begin to unroll stack
27849	27897	break;
27850	27898	}
27851	27899

		@@ -27852,9 +27900,9 @@
27852	27900	newstack[75LLU] = 9876543210LLU; // overflow-marker
27853	27901	// call calldestr from initfrom
27854	27902	newstack[0] = (uint64_t)stack; // backup stack location
27855		- newstack[1] = 2290LLU;
	27903	+ newstack[1] = 2294LLU;
27856	27904	newstack[2] = base;
27857		- newstack[3] = 2291LLU;
	27905	+ newstack[3] = 2295LLU;
27858	27906	// arguments for call to calldestr
27859	27907	newstack[4LLU] = stack[base + 0]/fnid/;
27860	27908	newstack[5LLU] = stack[base + 3]/typedefs/;

		@@ -27868,7 +27916,7 @@
27868	27916	label = 1084LLU; // calldestr
27869	27917	break;
27870	27918	}
27871		- case 2290LLU: // copy-back deleter (calldestr to initfrom)
	27919	+ case 2294LLU: // copy-back deleter (calldestr to initfrom)
27872	27920	{
27873	27921	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (calldestr to initfrom)\n");
27874	27922	uint64_t oldstack = (uint64_t )stack[0];

		@@ -27881,10 +27929,10 @@
27881	27929	}
27882	27930	Free(75LLU + 1, sizeof(uint64_t), stack);
27883	27931	stack = oldstack;
27884		- label = 2266LLU; // continue to unroll stack
	27932	+ label = 2270LLU; // continue to unroll stack
27885	27933	break;
27886	27934	}
27887		- case 2291LLU: // return from calldestr to initfrom
	27935	+ case 2295LLU: // return from calldestr to initfrom
27888	27936	{
27889	27937	uint64_t oldstack = (uint64_t )stack[0];
27890	27938	// copy mutable arguments back from call to calldestr

		@@ -27898,9 +27946,9 @@
27898	27946	stack = oldstack;
27899	27947	printf("%s", "\n label = ");
27900	27948	// call printnr from initfrom
27901		- stack[base + 16LLU] = 2292LLU/throw to this address/;
	27949	+ stack[base + 16LLU] = 2296LLU/throw to this address/;
27902	27950	stack[base + 17LLU] = base;
27903		- stack[base + 18LLU] = 2293LLU;
	27951	+ stack[base + 18LLU] = 2297LLU;
27904	27952	// arguments for call to printnr
27905	27953	stack[base + 19LLU] = stack[base + 13]/labelthrow/;
27906	27954	// set stack-base & callee-address

		@@ -27908,14 +27956,14 @@
27908	27956	label = 18446744073709551590LLU; // printnr
27909	27957	break;
27910	27958	}
27911		- case 2292LLU: // copy-back deleter (printnr to initfrom)
	27959	+ case 2296LLU: // copy-back deleter (printnr to initfrom)
27912	27960	{
27913	27961	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27914	27962	// copy mutable arguments back from call to printnr
27915		- label = 2266LLU; // continue to roll stack
	27963	+ label = 2270LLU; // continue to roll stack
27916	27964	break;
27917	27965	}
27918		- case 2293LLU: // return from printnr to initfrom
	27966	+ case 2297LLU: // return from printnr to initfrom
27919	27967	{
27920	27968	// copy mutable arguments back from call to printnr
27921	27969	printf("%s", "LLU; // continue unrolling stack, delete next variable");

		@@ -27923,9 +27971,9 @@
27923	27971	printf("%s", "\n }");
27924	27972	printf("%s", "\n case ");
27925	27973	// call printnr from initfrom
27926		- stack[base + 16LLU] = 2294LLU/throw to this address/;
	27974	+ stack[base + 16LLU] = 2298LLU/throw to this address/;
27927	27975	stack[base + 17LLU] = base;
27928		- stack[base + 18LLU] = 2295LLU;
	27976	+ stack[base + 18LLU] = 2299LLU;
27929	27977	// arguments for call to printnr
27930	27978	stack[base + 19LLU] = stack[base + 15]/labelskip/;
27931	27979	// set stack-base & callee-address

		@@ -27933,14 +27981,14 @@
27933	27981	label = 18446744073709551590LLU; // printnr
27934	27982	break;
27935	27983	}
27936		- case 2294LLU: // copy-back deleter (printnr to initfrom)
	27984	+ case 2298LLU: // copy-back deleter (printnr to initfrom)
27937	27985	{
27938	27986	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
27939	27987	// copy mutable arguments back from call to printnr
27940		- label = 2266LLU; // continue to roll stack
	27988	+ label = 2270LLU; // continue to roll stack
27941	27989	break;
27942	27990	}
27943		- case 2295LLU: // return from printnr to initfrom
	27991	+ case 2299LLU: // return from printnr to initfrom
27944	27992	{
27945	27993	// copy mutable arguments back from call to printnr
27946	27994	printf("%s", "LLU: // skipped deleter");

		@@ -27947,27 +27995,27 @@
27947	27995	printf("%s", "\n {");
27948	27996	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
27949	27997	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
27950		- label = 2261LLU; // case complete
	27998	+ label = 2265LLU; // case complete
27951	27999	break;
27952	28000	}
27953		- case 2263LLU: // copy-back deleter (switch)
	28001	+ case 2267LLU: // copy-back deleter (switch)
27954	28002	{
27955	28003	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 14];
27956	28004	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 13];
27957		- label = 2259LLU; // continue to unroll stack
	28005	+ label = 2263LLU; // continue to unroll stack
27958	28006	break;
27959	28007	}
27960		- case 2262LLU: // try next case
	28008	+ case 2266LLU: // try next case
27961	28009	{
27962	28010	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
27963	28011	exit(-1);
27964	28012	}
27965		- case 2261LLU: // completed switch
	28013	+ case 2265LLU: // completed switch
27966	28014	{
27967	28015	// call ParseToken from initfrom
27968		- stack[base + 13LLU] = 2296LLU/throw to this address/;
	28016	+ stack[base + 13LLU] = 2300LLU/throw to this address/;
27969	28017	stack[base + 14LLU] = base;
27970		- stack[base + 15LLU] = 2297LLU;
	28018	+ stack[base + 15LLU] = 2301LLU;
27971	28019	// arguments for call to ParseToken
27972	28020	stack[base + 18LLU] = stack[base + 6]/lookahead/;
27973	28021	// set stack-base & callee-address

		@@ -27975,15 +28023,15 @@
27975	28023	label = 3LLU; // ParseToken
27976	28024	break;
27977	28025	}
27978		- case 2296LLU: // copy-back deleter (ParseToken to initfrom)
	28026	+ case 2300LLU: // copy-back deleter (ParseToken to initfrom)
27979	28027	{
27980	28028	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
27981	28029	// copy mutable arguments back from call to ParseToken
27982	28030	stack[base + 6]/lookahead/ = stack[base + 18LLU];
27983		- label = 2259LLU; // continue to roll stack
	28031	+ label = 2263LLU; // continue to roll stack
27984	28032	break;
27985	28033	}
27986		- case 2297LLU: // return from ParseToken to initfrom
	28034	+ case 2301LLU: // return from ParseToken to initfrom
27987	28035	{
27988	28036	// copy mutable arguments back from call to ParseToken
27989	28037	stack[base + 6]/lookahead/ = stack[base + 18LLU];

		@@ -27991,9 +28039,9 @@
27991	28039	stack[base + 10] = stack[base + 16LLU];
27992	28040	stack[base + 11] = stack[base + 17LLU];
27993	28041	// call issimple from initfrom
27994		- stack[base + 14LLU] = 2298LLU/throw to this address/;
	28042	+ stack[base + 14LLU] = 2302LLU/throw to this address/;
27995	28043	stack[base + 15LLU] = base;
27996		- stack[base + 16LLU] = 2299LLU;
	28044	+ stack[base + 16LLU] = 2303LLU;
27997	28045	// arguments for call to issimple
27998	28046	stack[base + 18LLU] = stack[base + 10]/variant/;
27999	28047	stack[base + 19LLU] = stack[base + 11]/content/;

		@@ -28003,14 +28051,14 @@
28003	28051	label = 158LLU; // issimple
28004	28052	break;
28005	28053	}
28006		- case 2298LLU: // copy-back deleter (issimple to initfrom)
	28054	+ case 2302LLU: // copy-back deleter (issimple to initfrom)
28007	28055	{
28008	28056	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (issimple to initfrom)\n");
28009	28057	// copy mutable arguments back from call to issimple
28010		- label = 2259LLU; // continue to roll stack
	28058	+ label = 2263LLU; // continue to roll stack
28011	28059	break;
28012	28060	}
28013		- case 2299LLU: // return from issimple to initfrom
	28061	+ case 2303LLU: // return from issimple to initfrom
28014	28062	{
28015	28063	// copy mutable arguments back from call to issimple
28016	28064	// copy back results provided by call to issimple

		@@ -28017,7 +28065,7 @@
28017	28065	stack[base + 13] = stack[base + 17LLU];
28018	28066	if(!stack[base + 13]/forceerror/)
28019	28067	{
28020		- label = 2300LLU; // jump to alternative
	28068	+ label = 2304LLU; // jump to alternative
28021	28069	break;
28022	28070	}
28023	28071

		@@ -28024,9 +28072,9 @@
28024	28072	// consequent
28025	28073	fprintf(stderr, "%s", "in function ");
28026	28074	// call reportid from initfrom
28027		- stack[base + 14LLU] = 2302LLU/throw to this address/;
	28075	+ stack[base + 14LLU] = 2306LLU/throw to this address/;
28028	28076	stack[base + 15LLU] = base;
28029		- stack[base + 16LLU] = 2303LLU;
	28077	+ stack[base + 16LLU] = 2307LLU;
28030	28078	// arguments for call to reportid
28031	28079	stack[base + 17LLU] = stack[base + 0]/fnid/;
28032	28080	// set stack-base & callee-address

		@@ -28034,21 +28082,21 @@
28034	28082	label = 18446744073709551586LLU; // reportid
28035	28083	break;
28036	28084	}
28037		- case 2302LLU: // copy-back deleter (reportid to initfrom)
	28085	+ case 2306LLU: // copy-back deleter (reportid to initfrom)
28038	28086	{
28039	28087	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28040	28088	// copy mutable arguments back from call to reportid
28041		- label = 2259LLU; // continue to roll stack
	28089	+ label = 2263LLU; // continue to roll stack
28042	28090	break;
28043	28091	}
28044		- case 2303LLU: // return from reportid to initfrom
	28092	+ case 2307LLU: // return from reportid to initfrom
28045	28093	{
28046	28094	// copy mutable arguments back from call to reportid
28047	28095	fprintf(stderr, "%s", ": WARNING, FORCING CONSTRUCTION TO FAIL TO TEST THROW MECHANISM!\n");
28048	28096	// call ParseToken from initfrom
28049		- stack[base + 14LLU] = 2304LLU/throw to this address/;
	28097	+ stack[base + 14LLU] = 2308LLU/throw to this address/;
28050	28098	stack[base + 15LLU] = base;
28051		- stack[base + 16LLU] = 2305LLU;
	28099	+ stack[base + 16LLU] = 2309LLU;
28052	28100	// arguments for call to ParseToken
28053	28101	stack[base + 19LLU] = stack[base + 6]/lookahead/;
28054	28102	// set stack-base & callee-address

		@@ -28056,15 +28104,15 @@
28056	28104	label = 3LLU; // ParseToken
28057	28105	break;
28058	28106	}
28059		- case 2304LLU: // copy-back deleter (ParseToken to initfrom)
	28107	+ case 2308LLU: // copy-back deleter (ParseToken to initfrom)
28060	28108	{
28061	28109	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
28062	28110	// copy mutable arguments back from call to ParseToken
28063	28111	stack[base + 6]/lookahead/ = stack[base + 19LLU];
28064		- label = 2259LLU; // continue to roll stack
	28112	+ label = 2263LLU; // continue to roll stack
28065	28113	break;
28066	28114	}
28067		- case 2305LLU: // return from ParseToken to initfrom
	28115	+ case 2309LLU: // return from ParseToken to initfrom
28068	28116	{
28069	28117	// copy mutable arguments back from call to ParseToken
28070	28118	stack[base + 6]/lookahead/ = stack[base + 19LLU];

		@@ -28071,20 +28119,20 @@
28071	28119	// copy back results provided by call to ParseToken
28072	28120	stack[base + 10] = stack[base + 17LLU];
28073	28121	stack[base + 11] = stack[base + 18LLU];
28074		- label = 2301LLU; // consequent complete
	28122	+ label = 2305LLU; // consequent complete
28075	28123	break;
28076	28124	}
28077		- case 2300LLU: // alternative
	28125	+ case 2304LLU: // alternative
28078	28126	{
28079		- label = 2301LLU; // alternative complete
	28127	+ label = 2305LLU; // alternative complete
28080	28128	break;
28081	28129	}
28082		- case 2301LLU: // completed if-then-else
	28130	+ case 2305LLU: // completed if-then-else
28083	28131	{
28084	28132	// call equ from initfrom
28085		- stack[base + 14LLU] = 2306LLU/throw to this address/;
	28133	+ stack[base + 14LLU] = 2310LLU/throw to this address/;
28086	28134	stack[base + 15LLU] = base;
28087		- stack[base + 16LLU] = 2307LLU;
	28135	+ stack[base + 16LLU] = 2311LLU;
28088	28136	// arguments for call to equ
28089	28137	stack[base + 18LLU] = stack[base + 10]/variant/;
28090	28138	stack[base + 19LLU] = 4LLU;

		@@ -28093,14 +28141,14 @@
28093	28141	label = 18446744073709551600LLU; // equ
28094	28142	break;
28095	28143	}
28096		- case 2306LLU: // copy-back deleter (equ to initfrom)
	28144	+ case 2310LLU: // copy-back deleter (equ to initfrom)
28097	28145	{
28098	28146	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28099	28147	// copy mutable arguments back from call to equ
28100		- label = 2259LLU; // continue to roll stack
	28148	+ label = 2263LLU; // continue to roll stack
28101	28149	break;
28102	28150	}
28103		- case 2307LLU: // return from equ to initfrom
	28151	+ case 2311LLU: // return from equ to initfrom
28104	28152	{
28105	28153	// copy mutable arguments back from call to equ
28106	28154	// copy back results provided by call to equ

		@@ -28107,15 +28155,15 @@
28107	28155	stack[base + 9] = stack[base + 17LLU];
28108	28156	if(!stack[base + 9]/isequal/)
28109	28157	{
28110		- label = 2308LLU; // jump to alternative
	28158	+ label = 2312LLU; // jump to alternative
28111	28159	break;
28112	28160	}
28113	28161
28114	28162	// consequent
28115	28163	// call skipwscmnt from initfrom
28116		- stack[base + 14LLU] = 2310LLU/throw to this address/;
	28164	+ stack[base + 14LLU] = 2314LLU/throw to this address/;
28117	28165	stack[base + 15LLU] = base;
28118		- stack[base + 16LLU] = 2311LLU;
	28166	+ stack[base + 16LLU] = 2315LLU;
28119	28167	// arguments for call to skipwscmnt
28120	28168	stack[base + 18LLU] = stack[base + 6]/lookahead/;
28121	28169	// set stack-base & callee-address

		@@ -28123,22 +28171,22 @@
28123	28171	label = 18446744073709551580LLU; // skipwscmnt
28124	28172	break;
28125	28173	}
28126		- case 2310LLU: // copy-back deleter (skipwscmnt to initfrom)
	28174	+ case 2314LLU: // copy-back deleter (skipwscmnt to initfrom)
28127	28175	{
28128	28176	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (skipwscmnt to initfrom)\n");
28129	28177	// copy mutable arguments back from call to skipwscmnt
28130		- label = 2259LLU; // continue to roll stack
	28178	+ label = 2263LLU; // continue to roll stack
28131	28179	break;
28132	28180	}
28133		- case 2311LLU: // return from skipwscmnt to initfrom
	28181	+ case 2315LLU: // return from skipwscmnt to initfrom
28134	28182	{
28135	28183	// copy mutable arguments back from call to skipwscmnt
28136	28184	// copy back results provided by call to skipwscmnt
28137	28185	stack[base + 6] = stack[base + 17LLU];
28138	28186	// call equ from initfrom
28139		- stack[base + 15LLU] = 2312LLU/throw to this address/;
	28187	+ stack[base + 15LLU] = 2316LLU/throw to this address/;
28140	28188	stack[base + 16LLU] = base;
28141		- stack[base + 17LLU] = 2313LLU;
	28189	+ stack[base + 17LLU] = 2317LLU;
28142	28190	// arguments for call to equ
28143	28191	stack[base + 19LLU] = stack[base + 6]/lookahead/;
28144	28192	stack[base + 20LLU] = 46LLU;

		@@ -28147,14 +28195,14 @@
28147	28195	label = 18446744073709551600LLU; // equ
28148	28196	break;
28149	28197	}
28150		- case 2312LLU: // copy-back deleter (equ to initfrom)
	28198	+ case 2316LLU: // copy-back deleter (equ to initfrom)
28151	28199	{
28152	28200	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28153	28201	// copy mutable arguments back from call to equ
28154		- label = 2259LLU; // continue to roll stack
	28202	+ label = 2263LLU; // continue to roll stack
28155	28203	break;
28156	28204	}
28157		- case 2313LLU: // return from equ to initfrom
	28205	+ case 2317LLU: // return from equ to initfrom
28158	28206	{
28159	28207	// copy mutable arguments back from call to equ
28160	28208	// copy back results provided by call to equ

		@@ -28161,40 +28209,40 @@
28161	28209	stack[base + 14] = stack[base + 18LLU];
28162	28210	if(!stack[base + 14]/namespace/)
28163	28211	{
28164		- label = 2314LLU; // jump to alternative
	28212	+ label = 2318LLU; // jump to alternative
28165	28213	break;
28166	28214	}
28167	28215
28168	28216	// consequent
28169		- label = 2317LLU; // skip deleter
	28217	+ label = 2321LLU; // skip deleter
28170	28218	break;
28171	28219	}
28172		- case 2316LLU: // deleter
	28220	+ case 2320LLU: // deleter
28173	28221	{
28174	28222	// throw from initfrom
28175	28223	if(!stack[base + 15])
28176	28224	{
28177	28225	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28178		- label = 2259LLU; // skip, variable already deleted/unscoped
	28226	+ label = 2263LLU; // skip, variable already deleted/unscoped
28179	28227	break;
28180	28228	}
28181	28229	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28182		- label = 2259LLU; // continue unrolling stack, delete next variable
	28230	+ label = 2263LLU; // continue unrolling stack, delete next variable
28183	28231	break;
28184	28232	}
28185		- case 2317LLU: // skipped deleter
	28233	+ case 2321LLU: // skipped deleter
28186	28234	{
28187	28235	stack[base + 15] = stack[base + 11]/content/;
28188		- label = 2319LLU; // skip deleter
	28236	+ label = 2323LLU; // skip deleter
28189	28237	break;
28190	28238	}
28191		- case 2318LLU: // deleter
	28239	+ case 2322LLU: // deleter
28192	28240	{
28193	28241	// throw from initfrom
28194	28242	if(!stack[base + 16])
28195	28243	{
28196	28244	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable type \n");
28197		- label = 2316LLU; // skip, variable already deleted/unscoped
	28245	+ label = 2320LLU; // skip, variable already deleted/unscoped
28198	28246	break;
28199	28247	}
28200	28248	fprintf(stderr, "in function initfrom: unrolling stack, variable type \n");

		@@ -28204,7 +28252,7 @@
28204	28252	newstack[0] = (uint64_t)stack; // backup stack location
28205	28253	newstack[1] = 1234567890;
28206	28254	newstack[2] = base;
28207		- newstack[3] = 2320LLU;
	28255	+ newstack[3] = 2324LLU;
28208	28256	stack = newstack;
28209	28257	// set stack-base & callee-address
28210	28258	base = 4/deloffset/;

		@@ -28211,21 +28259,21 @@
28211	28259	label = 296LLU; // ~type
28212	28260	break;
28213	28261	}
28214		- case 2320LLU: // return from ~type to initfrom
	28262	+ case 2324LLU: // return from ~type to initfrom
28215	28263	{
28216	28264	stack = (uint64_t *)stack[0];
28217	28265	// releasing toplevel container
28218	28266	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 16] - sizeof(uint64_t) 4));
28219	28267
28220		- label = 2316LLU; // continue unrolling stack, delete next variable
	28268	+ label = 2320LLU; // continue unrolling stack, delete next variable
28221	28269	break;
28222	28270	}
28223		- case 2319LLU: // skipped deleter
	28271	+ case 2323LLU: // skipped deleter
28224	28272	{
28225	28273	// construct type.typename
28226	28274	if(!(stack[base + 16] = construct(1)))
28227	28275	{
28228		- label = 2316LLU; // throw: begin to unroll stack
	28276	+ label = 2320LLU; // throw: begin to unroll stack
28229	28277	break;
28230	28278	}
28231	28279

		@@ -28235,7 +28283,7 @@
28235	28283	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
28236	28284	if(!newstack)
28237	28285	{
28238		- label = 2318LLU; // throw: begin to unroll stack
	28286	+ label = 2322LLU; // throw: begin to unroll stack
28239	28287	break;
28240	28288	}
28241	28289

		@@ -28242,9 +28290,9 @@
28242	28290	newstack[15LLU] = 9876543210LLU; // overflow-marker
28243	28291	// call equtype from initfrom
28244	28292	newstack[0] = (uint64_t)stack; // backup stack location
28245		- newstack[1] = 2321LLU;
	28293	+ newstack[1] = 2325LLU;
28246	28294	newstack[2] = base;
28247		- newstack[3] = 2322LLU;
	28295	+ newstack[3] = 2326LLU;
28248	28296	// arguments for call to equtype
28249	28297	newstack[5LLU] = stack[base + 1]/dsttype/;
28250	28298	newstack[6LLU] = stack[base + 16]/assigntype/;

		@@ -28254,7 +28302,7 @@
28254	28302	label = 342LLU; // equtype
28255	28303	break;
28256	28304	}
28257		- case 2321LLU: // copy-back deleter (equtype to initfrom)
	28305	+ case 2325LLU: // copy-back deleter (equtype to initfrom)
28258	28306	{
28259	28307	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
28260	28308	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28266,10 +28314,10 @@
28266	28314	}
28267	28315	Free(15LLU + 1, sizeof(uint64_t), stack);
28268	28316	stack = oldstack;
28269		- label = 2318LLU; // continue to unroll stack
	28317	+ label = 2322LLU; // continue to unroll stack
28270	28318	break;
28271	28319	}
28272		- case 2322LLU: // return from equtype to initfrom
	28320	+ case 2326LLU: // return from equtype to initfrom
28273	28321	{
28274	28322	uint64_t oldstack = (uint64_t )stack[0];
28275	28323	// copy mutable arguments back from call to equtype

		@@ -28284,21 +28332,21 @@
28284	28332	stack = oldstack;
28285	28333	if(!stack[base + 9]/isequal/)
28286	28334	{
28287		- label = 2323LLU; // jump to alternative
	28335	+ label = 2327LLU; // jump to alternative
28288	28336	break;
28289	28337	}
28290	28338
28291	28339	// consequent
28292		- label = 2324LLU; // consequent complete
	28340	+ label = 2328LLU; // consequent complete
28293	28341	break;
28294	28342	}
28295		- case 2323LLU: // alternative
	28343	+ case 2327LLU: // alternative
28296	28344	{
28297	28345	fprintf(stderr, "%s", "in function ");
28298	28346	// call reportid from initfrom
28299		- stack[base + 17LLU] = 2325LLU/throw to this address/;
	28347	+ stack[base + 17LLU] = 2329LLU/throw to this address/;
28300	28348	stack[base + 18LLU] = base;
28301		- stack[base + 19LLU] = 2326LLU;
	28349	+ stack[base + 19LLU] = 2330LLU;
28302	28350	// arguments for call to reportid
28303	28351	stack[base + 20LLU] = stack[base + 0]/fnid/;
28304	28352	// set stack-base & callee-address

		@@ -28306,14 +28354,14 @@
28306	28354	label = 18446744073709551586LLU; // reportid
28307	28355	break;
28308	28356	}
28309		- case 2325LLU: // copy-back deleter (reportid to initfrom)
	28357	+ case 2329LLU: // copy-back deleter (reportid to initfrom)
28310	28358	{
28311	28359	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28312	28360	// copy mutable arguments back from call to reportid
28313		- label = 2318LLU; // continue to roll stack
	28361	+ label = 2322LLU; // continue to roll stack
28314	28362	break;
28315	28363	}
28316		- case 2326LLU: // return from reportid to initfrom
	28364	+ case 2330LLU: // return from reportid to initfrom
28317	28365	{
28318	28366	// copy mutable arguments back from call to reportid
28319	28367	fprintf(stderr, "%s", ": can't construct type ");

		@@ -28320,7 +28368,7 @@
28320	28368	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
28321	28369	if(!newstack)
28322	28370	{
28323		- label = 2318LLU; // throw: begin to unroll stack
	28371	+ label = 2322LLU; // throw: begin to unroll stack
28324	28372	break;
28325	28373	}
28326	28374

		@@ -28327,9 +28375,9 @@
28327	28375	newstack[10LLU] = 9876543210LLU; // overflow-marker
28328	28376	// call reporttype from initfrom
28329	28377	newstack[0] = (uint64_t)stack; // backup stack location
28330		- newstack[1] = 2327LLU;
	28378	+ newstack[1] = 2331LLU;
28331	28379	newstack[2] = base;
28332		- newstack[3] = 2328LLU;
	28380	+ newstack[3] = 2332LLU;
28333	28381	// arguments for call to reporttype
28334	28382	newstack[4LLU] = stack[base + 1]/dsttype/;
28335	28383	stack = newstack;

		@@ -28338,7 +28386,7 @@
28338	28386	label = 316LLU; // reporttype
28339	28387	break;
28340	28388	}
28341		- case 2327LLU: // copy-back deleter (reporttype to initfrom)
	28389	+ case 2331LLU: // copy-back deleter (reporttype to initfrom)
28342	28390	{
28343	28391	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
28344	28392	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28350,10 +28398,10 @@
28350	28398	}
28351	28399	Free(10LLU + 1, sizeof(uint64_t), stack);
28352	28400	stack = oldstack;
28353		- label = 2318LLU; // continue to unroll stack
	28401	+ label = 2322LLU; // continue to unroll stack
28354	28402	break;
28355	28403	}
28356		- case 2328LLU: // return from reporttype to initfrom
	28404	+ case 2332LLU: // return from reporttype to initfrom
28357	28405	{
28358	28406	uint64_t oldstack = (uint64_t )stack[0];
28359	28407	// copy mutable arguments back from call to reporttype

		@@ -28368,7 +28416,7 @@
28368	28416	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
28369	28417	if(!newstack)
28370	28418	{
28371		- label = 2318LLU; // throw: begin to unroll stack
	28419	+ label = 2322LLU; // throw: begin to unroll stack
28372	28420	break;
28373	28421	}
28374	28422

		@@ -28375,9 +28423,9 @@
28375	28423	newstack[10LLU] = 9876543210LLU; // overflow-marker
28376	28424	// call reporttype from initfrom
28377	28425	newstack[0] = (uint64_t)stack; // backup stack location
28378		- newstack[1] = 2329LLU;
	28426	+ newstack[1] = 2333LLU;
28379	28427	newstack[2] = base;
28380		- newstack[3] = 2330LLU;
	28428	+ newstack[3] = 2334LLU;
28381	28429	// arguments for call to reporttype
28382	28430	newstack[4LLU] = stack[base + 16]/assigntype/;
28383	28431	stack = newstack;

		@@ -28386,7 +28434,7 @@
28386	28434	label = 316LLU; // reporttype
28387	28435	break;
28388	28436	}
28389		- case 2329LLU: // copy-back deleter (reporttype to initfrom)
	28437	+ case 2333LLU: // copy-back deleter (reporttype to initfrom)
28390	28438	{
28391	28439	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttype to initfrom)\n");
28392	28440	uint64_t oldstack = (uint64_t )stack[0];

		@@ -28398,10 +28446,10 @@
28398	28446	}
28399	28447	Free(10LLU + 1, sizeof(uint64_t), stack);
28400	28448	stack = oldstack;
28401		- label = 2318LLU; // continue to unroll stack
	28449	+ label = 2322LLU; // continue to unroll stack
28402	28450	break;
28403	28451	}
28404		- case 2330LLU: // return from reporttype to initfrom
	28452	+ case 2334LLU: // return from reporttype to initfrom
28405	28453	{
28406	28454	uint64_t oldstack = (uint64_t )stack[0];
28407	28455	// copy mutable arguments back from call to reporttype

		@@ -28414,10 +28462,10 @@
28414	28462	stack = oldstack;
28415	28463	fprintf(stderr, "%s", "\n");
28416	28464	exit(-1);
28417		- label = 2324LLU; // alternative complete
	28465	+ label = 2328LLU; // alternative complete
28418	28466	break;
28419	28467	}
28420		- case 2324LLU: // completed if-then-else
	28468	+ case 2328LLU: // completed if-then-else
28421	28469	{
28422	28470
28423	28471	uint64_t newstack = (uint64_t )(stack[base + 16] - sizeof(uint64_t) * 4);

		@@ -28425,7 +28473,7 @@
28425	28473	newstack[0] = (uint64_t)stack; // backup stack location
28426	28474	newstack[1] = 1234567890;
28427	28475	newstack[2] = base;
28428		- newstack[3] = 2331LLU;
	28476	+ newstack[3] = 2335LLU;
28429	28477	stack = newstack;
28430	28478	// set stack-base & callee-address
28431	28479	base = 4/deloffset/;

		@@ -28432,7 +28480,7 @@
28432	28480	label = 296LLU; // ~type
28433	28481	break;
28434	28482	}
28435		- case 2331LLU: // return from ~type to initfrom
	28483	+ case 2335LLU: // return from ~type to initfrom
28436	28484	{
28437	28485	stack = (uint64_t *)stack[0];
28438	28486	// releasing toplevel container

		@@ -28439,9 +28487,9 @@
28439	28487	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 16] - sizeof(uint64_t) 4));
28440	28488
28441	28489	// call matchsym from initfrom
28442		- stack[base + 16LLU] = 2332LLU/throw to this address/;
	28490	+ stack[base + 16LLU] = 2336LLU/throw to this address/;
28443	28491	stack[base + 17LLU] = base;
28444		- stack[base + 18LLU] = 2333LLU;
	28492	+ stack[base + 18LLU] = 2337LLU;
28445	28493	// arguments for call to matchsym
28446	28494	stack[base + 19LLU] = stack[base + 0]/fnid/;
28447	28495	stack[base + 20LLU] = 46LLU;

		@@ -28451,22 +28499,22 @@
28451	28499	label = 212LLU; // matchsym
28452	28500	break;
28453	28501	}
28454		- case 2332LLU: // copy-back deleter (matchsym to initfrom)
	28502	+ case 2336LLU: // copy-back deleter (matchsym to initfrom)
28455	28503	{
28456	28504	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
28457	28505	// copy mutable arguments back from call to matchsym
28458	28506	stack[base + 6]/lookahead/ = stack[base + 21LLU];
28459		- label = 2316LLU; // continue to roll stack
	28507	+ label = 2320LLU; // continue to roll stack
28460	28508	break;
28461	28509	}
28462		- case 2333LLU: // return from matchsym to initfrom
	28510	+ case 2337LLU: // return from matchsym to initfrom
28463	28511	{
28464	28512	// copy mutable arguments back from call to matchsym
28465	28513	stack[base + 6]/lookahead/ = stack[base + 21LLU];
28466	28514	// call ParseToken from initfrom
28467		- stack[base + 16LLU] = 2334LLU/throw to this address/;
	28515	+ stack[base + 16LLU] = 2338LLU/throw to this address/;
28468	28516	stack[base + 17LLU] = base;
28469		- stack[base + 18LLU] = 2335LLU;
	28517	+ stack[base + 18LLU] = 2339LLU;
28470	28518	// arguments for call to ParseToken
28471	28519	stack[base + 21LLU] = stack[base + 6]/lookahead/;
28472	28520	// set stack-base & callee-address

		@@ -28474,15 +28522,15 @@
28474	28522	label = 3LLU; // ParseToken
28475	28523	break;
28476	28524	}
28477		- case 2334LLU: // copy-back deleter (ParseToken to initfrom)
	28525	+ case 2338LLU: // copy-back deleter (ParseToken to initfrom)
28478	28526	{
28479	28527	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
28480	28528	// copy mutable arguments back from call to ParseToken
28481	28529	stack[base + 6]/lookahead/ = stack[base + 21LLU];
28482		- label = 2316LLU; // continue to roll stack
	28530	+ label = 2320LLU; // continue to roll stack
28483	28531	break;
28484	28532	}
28485		- case 2335LLU: // return from ParseToken to initfrom
	28533	+ case 2339LLU: // return from ParseToken to initfrom
28486	28534	{
28487	28535	// copy mutable arguments back from call to ParseToken
28488	28536	stack[base + 6]/lookahead/ = stack[base + 21LLU];

		@@ -28490,9 +28538,9 @@
28490	28538	stack[base + 10] = stack[base + 19LLU];
28491	28539	stack[base + 11] = stack[base + 20LLU];
28492	28540	// call equ from initfrom
28493		- stack[base + 16LLU] = 2336LLU/throw to this address/;
	28541	+ stack[base + 16LLU] = 2340LLU/throw to this address/;
28494	28542	stack[base + 17LLU] = base;
28495		- stack[base + 18LLU] = 2337LLU;
	28543	+ stack[base + 18LLU] = 2341LLU;
28496	28544	// arguments for call to equ
28497	28545	stack[base + 20LLU] = stack[base + 10]/variant/;
28498	28546	stack[base + 21LLU] = 4LLU;

		@@ -28501,14 +28549,14 @@
28501	28549	label = 18446744073709551600LLU; // equ
28502	28550	break;
28503	28551	}
28504		- case 2336LLU: // copy-back deleter (equ to initfrom)
	28552	+ case 2340LLU: // copy-back deleter (equ to initfrom)
28505	28553	{
28506	28554	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
28507	28555	// copy mutable arguments back from call to equ
28508		- label = 2316LLU; // continue to roll stack
	28556	+ label = 2320LLU; // continue to roll stack
28509	28557	break;
28510	28558	}
28511		- case 2337LLU: // return from equ to initfrom
	28559	+ case 2341LLU: // return from equ to initfrom
28512	28560	{
28513	28561	// copy mutable arguments back from call to equ
28514	28562	// copy back results provided by call to equ

		@@ -28515,21 +28563,21 @@
28515	28563	stack[base + 9] = stack[base + 19LLU];
28516	28564	if(!stack[base + 9]/isequal/)
28517	28565	{
28518		- label = 2338LLU; // jump to alternative
	28566	+ label = 2342LLU; // jump to alternative
28519	28567	break;
28520	28568	}
28521	28569
28522	28570	// consequent
28523		- label = 2339LLU; // consequent complete
	28571	+ label = 2343LLU; // consequent complete
28524	28572	break;
28525	28573	}
28526		- case 2338LLU: // alternative
	28574	+ case 2342LLU: // alternative
28527	28575	{
28528	28576	fprintf(stderr, "%s", "construct requires constructor but found ");
28529	28577	// call reporttok from initfrom
28530		- stack[base + 16LLU] = 2340LLU/throw to this address/;
	28578	+ stack[base + 16LLU] = 2344LLU/throw to this address/;
28531	28579	stack[base + 17LLU] = base;
28532		- stack[base + 18LLU] = 2341LLU;
	28580	+ stack[base + 18LLU] = 2345LLU;
28533	28581	// arguments for call to reporttok
28534	28582	stack[base + 19LLU] = stack[base + 10]/variant/;
28535	28583	stack[base + 20LLU] = stack[base + 11]/content/;

		@@ -28538,40 +28586,40 @@
28538	28586	label = 18446744073709551582LLU; // reporttok
28539	28587	break;
28540	28588	}
28541		- case 2340LLU: // copy-back deleter (reporttok to initfrom)
	28589	+ case 2344LLU: // copy-back deleter (reporttok to initfrom)
28542	28590	{
28543	28591	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
28544	28592	// copy mutable arguments back from call to reporttok
28545		- label = 2316LLU; // continue to roll stack
	28593	+ label = 2320LLU; // continue to roll stack
28546	28594	break;
28547	28595	}
28548		- case 2341LLU: // return from reporttok to initfrom
	28596	+ case 2345LLU: // return from reporttok to initfrom
28549	28597	{
28550	28598	// copy mutable arguments back from call to reporttok
28551	28599	fprintf(stderr, "%s", "\n");
28552	28600	exit(-1);
28553		- label = 2339LLU; // alternative complete
	28601	+ label = 2343LLU; // alternative complete
28554	28602	break;
28555	28603	}
28556		- case 2339LLU: // completed if-then-else
	28604	+ case 2343LLU: // completed if-then-else
28557	28605	{
28558	28606	if(!stack[base + 8]/fncanthrow/)
28559	28607	{
28560		- label = 2342LLU; // jump to alternative
	28608	+ label = 2346LLU; // jump to alternative
28561	28609	break;
28562	28610	}
28563	28611
28564	28612	// consequent
28565		- label = 2343LLU; // consequent complete
	28613	+ label = 2347LLU; // consequent complete
28566	28614	break;
28567	28615	}
28568		- case 2342LLU: // alternative
	28616	+ case 2346LLU: // alternative
28569	28617	{
28570	28618	fprintf(stderr, "%s", "in function ");
28571	28619	// call reportid from initfrom
28572		- stack[base + 16LLU] = 2344LLU/throw to this address/;
	28620	+ stack[base + 16LLU] = 2348LLU/throw to this address/;
28573	28621	stack[base + 17LLU] = base;
28574		- stack[base + 18LLU] = 2345LLU;
	28622	+ stack[base + 18LLU] = 2349LLU;
28575	28623	// arguments for call to reportid
28576	28624	stack[base + 19LLU] = stack[base + 0]/fnid/;
28577	28625	// set stack-base & callee-address

		@@ -28579,21 +28627,21 @@
28579	28627	label = 18446744073709551586LLU; // reportid
28580	28628	break;
28581	28629	}
28582		- case 2344LLU: // copy-back deleter (reportid to initfrom)
	28630	+ case 2348LLU: // copy-back deleter (reportid to initfrom)
28583	28631	{
28584	28632	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28585	28633	// copy mutable arguments back from call to reportid
28586		- label = 2316LLU; // continue to roll stack
	28634	+ label = 2320LLU; // continue to roll stack
28587	28635	break;
28588	28636	}
28589		- case 2345LLU: // return from reportid to initfrom
	28637	+ case 2349LLU: // return from reportid to initfrom
28590	28638	{
28591	28639	// copy mutable arguments back from call to reportid
28592	28640	fprintf(stderr, "%s", ": construction of data ");
28593	28641	// call reportid from initfrom
28594		- stack[base + 16LLU] = 2346LLU/throw to this address/;
	28642	+ stack[base + 16LLU] = 2350LLU/throw to this address/;
28595	28643	stack[base + 17LLU] = base;
28596		- stack[base + 18LLU] = 2347LLU;
	28644	+ stack[base + 18LLU] = 2351LLU;
28597	28645	// arguments for call to reportid
28598	28646	stack[base + 19LLU] = stack[base + 15]/typename/;
28599	28647	// set stack-base & callee-address

		@@ -28601,28 +28649,28 @@
28601	28649	label = 18446744073709551586LLU; // reportid
28602	28650	break;
28603	28651	}
28604		- case 2346LLU: // copy-back deleter (reportid to initfrom)
	28652	+ case 2350LLU: // copy-back deleter (reportid to initfrom)
28605	28653	{
28606	28654	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
28607	28655	// copy mutable arguments back from call to reportid
28608		- label = 2316LLU; // continue to roll stack
	28656	+ label = 2320LLU; // continue to roll stack
28609	28657	break;
28610	28658	}
28611		- case 2347LLU: // return from reportid to initfrom
	28659	+ case 2351LLU: // return from reportid to initfrom
28612	28660	{
28613	28661	// copy mutable arguments back from call to reportid
28614	28662	fprintf(stderr, "%s", " (which may throw) in no-throw environment\n");
28615	28663	exit(-1);
28616		- label = 2343LLU; // alternative complete
	28664	+ label = 2347LLU; // alternative complete
28617	28665	break;
28618	28666	}
28619		- case 2343LLU: // completed if-then-else
	28667	+ case 2347LLU: // completed if-then-else
28620	28668	{
28621	28669	printf("%s", "\n // construct ");
28622	28670	// call printid from initfrom
28623		- stack[base + 16LLU] = 2348LLU/throw to this address/;
	28671	+ stack[base + 16LLU] = 2352LLU/throw to this address/;
28624	28672	stack[base + 17LLU] = base;
28625		- stack[base + 18LLU] = 2349LLU;
	28673	+ stack[base + 18LLU] = 2353LLU;
28626	28674	// arguments for call to printid
28627	28675	stack[base + 19LLU] = stack[base + 15]/typename/;
28628	28676	// set stack-base & callee-address

		@@ -28630,21 +28678,21 @@
28630	28678	label = 18446744073709551587LLU; // printid
28631	28679	break;
28632	28680	}
28633		- case 2348LLU: // copy-back deleter (printid to initfrom)
	28681	+ case 2352LLU: // copy-back deleter (printid to initfrom)
28634	28682	{
28635	28683	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
28636	28684	// copy mutable arguments back from call to printid
28637		- label = 2316LLU; // continue to roll stack
	28685	+ label = 2320LLU; // continue to roll stack
28638	28686	break;
28639	28687	}
28640		- case 2349LLU: // return from printid to initfrom
	28688	+ case 2353LLU: // return from printid to initfrom
28641	28689	{
28642	28690	// copy mutable arguments back from call to printid
28643	28691	printf("%s", ".");
28644	28692	// call printid from initfrom
28645		- stack[base + 16LLU] = 2350LLU/throw to this address/;
	28693	+ stack[base + 16LLU] = 2354LLU/throw to this address/;
28646	28694	stack[base + 17LLU] = base;
28647		- stack[base + 18LLU] = 2351LLU;
	28695	+ stack[base + 18LLU] = 2355LLU;
28648	28696	// arguments for call to printid
28649	28697	stack[base + 19LLU] = stack[base + 11]/content/;
28650	28698	// set stack-base & callee-address

		@@ -28652,20 +28700,20 @@
28652	28700	label = 18446744073709551587LLU; // printid
28653	28701	break;
28654	28702	}
28655		- case 2350LLU: // copy-back deleter (printid to initfrom)
	28703	+ case 2354LLU: // copy-back deleter (printid to initfrom)
28656	28704	{
28657	28705	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printid to initfrom)\n");
28658	28706	// copy mutable arguments back from call to printid
28659		- label = 2316LLU; // continue to roll stack
	28707	+ label = 2320LLU; // continue to roll stack
28660	28708	break;
28661	28709	}
28662		- case 2351LLU: // return from printid to initfrom
	28710	+ case 2355LLU: // return from printid to initfrom
28663	28711	{
28664	28712	// copy mutable arguments back from call to printid
28665	28713	// call FindData from initfrom
28666		- stack[base + 17LLU] = 2352LLU/throw to this address/;
	28714	+ stack[base + 17LLU] = 2356LLU/throw to this address/;
28667	28715	stack[base + 18LLU] = base;
28668		- stack[base + 19LLU] = 2353LLU;
	28716	+ stack[base + 19LLU] = 2357LLU;
28669	28717	// arguments for call to FindData
28670	28718	stack[base + 21LLU] = stack[base + 3]/typedefs/;
28671	28719	stack[base + 22LLU] = stack[base + 15]/typename/;

		@@ -28674,14 +28722,14 @@
28674	28722	label = 1004LLU; // FindData
28675	28723	break;
28676	28724	}
28677		- case 2352LLU: // copy-back deleter (FindData to initfrom)
	28725	+ case 2356LLU: // copy-back deleter (FindData to initfrom)
28678	28726	{
28679	28727	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (FindData to initfrom)\n");
28680	28728	// copy mutable arguments back from call to FindData
28681		- label = 2316LLU; // continue to roll stack
	28729	+ label = 2320LLU; // continue to roll stack
28682	28730	break;
28683	28731	}
28684		- case 2353LLU: // return from FindData to initfrom
	28732	+ case 2357LLU: // return from FindData to initfrom
28685	28733	{
28686	28734	// copy mutable arguments back from call to FindData
28687	28735	// copy back results provided by call to FindData

		@@ -28688,7 +28736,7 @@
28688	28736	stack[base + 16] = stack[base + 20LLU];
28689	28737	if(/datadef/0 != ((uint64_t )(stack[base + 16]/reftypedef*/))[0])
28690	28738	{
28691		- label = 2355LLU; // jump to alternative
	28739	+ label = 2359LLU; // jump to alternative
28692	28740	break;
28693	28741	}
28694	28742

		@@ -28698,9 +28746,9 @@
28698	28746
28699	28747	// case
28700	28748	// call GetVariant from initfrom
28701		- stack[base + 22LLU] = 2357LLU/throw to this address/;
	28749	+ stack[base + 22LLU] = 2361LLU/throw to this address/;
28702	28750	stack[base + 23LLU] = base;
28703		- stack[base + 24LLU] = 2358LLU;
	28751	+ stack[base + 24LLU] = 2362LLU;
28704	28752	// arguments for call to GetVariant
28705	28753	stack[base + 27LLU] = stack[base + 0]/fnid/;
28706	28754	stack[base + 28LLU] = stack[base + 18]/variants/;

		@@ -28710,14 +28758,14 @@
28710	28758	label = 907LLU; // GetVariant
28711	28759	break;
28712	28760	}
28713		- case 2357LLU: // copy-back deleter (GetVariant to initfrom)
	28761	+ case 2361LLU: // copy-back deleter (GetVariant to initfrom)
28714	28762	{
28715	28763	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (GetVariant to initfrom)\n");
28716	28764	// copy mutable arguments back from call to GetVariant
28717		- label = 2356LLU; // continue to roll stack
	28765	+ label = 2360LLU; // continue to roll stack
28718	28766	break;
28719	28767	}
28720		- case 2358LLU: // return from GetVariant to initfrom
	28768	+ case 2362LLU: // return from GetVariant to initfrom
28721	28769	{
28722	28770	// copy mutable arguments back from call to GetVariant
28723	28771	// copy back results provided by call to GetVariant

		@@ -28725,7 +28773,7 @@
28725	28773	stack[base + 21] = stack[base + 26LLU];
28726	28774	if(/variant/0 != ((uint64_t )(stack[base + 21]/constr*/))[0])
28727	28775	{
28728		- label = 2360LLU; // jump to alternative
	28776	+ label = 2364LLU; // jump to alternative
28729	28777	break;
28730	28778	}
28731	28779

		@@ -28733,29 +28781,29 @@
28733	28781	/TYPEIDS/stack[base + 23] = ((uint64_t *)(stack[base + 21]/constr/))[1][1]/elements*/;
28734	28782
28735	28783	// case
28736		- label = 2363LLU; // skip deleter
	28784	+ label = 2367LLU; // skip deleter
28737	28785	break;
28738	28786	}
28739		- case 2362LLU: // deleter
	28787	+ case 2366LLU: // deleter
28740	28788	{
28741	28789	// throw from initfrom
28742	28790	if(!stack[base + 24])
28743	28791	{
28744	28792	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28745		- label = 2361LLU; // skip, variable already deleted/unscoped
	28793	+ label = 2365LLU; // skip, variable already deleted/unscoped
28746	28794	break;
28747	28795	}
28748	28796	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28749		- label = 2361LLU; // continue unrolling stack, delete next variable
	28797	+ label = 2365LLU; // continue unrolling stack, delete next variable
28750	28798	break;
28751	28799	}
28752		- case 2363LLU: // skipped deleter
	28800	+ case 2367LLU: // skipped deleter
28753	28801	{
28754	28802	stack[base + 24] = 0;
28755	28803	stack[base + 24]/size/ = list_size(((struct listnode )(stack[base + 23]/TYPEIDS*/)));
28756	28804	if(!stack[base + 13]/forceerror/)
28757	28805	{
28758		- label = 2364LLU; // jump to alternative
	28806	+ label = 2368LLU; // jump to alternative
28759	28807	break;
28760	28808	}
28761	28809

		@@ -28762,9 +28810,9 @@
28762	28810	// consequent
28763	28811	printf("%s", "\n // if(!(");
28764	28812	// call emitvaridx from initfrom
28765		- stack[base + 25LLU] = 2366LLU/throw to this address/;
	28813	+ stack[base + 25LLU] = 2370LLU/throw to this address/;
28766	28814	stack[base + 26LLU] = base;
28767		- stack[base + 27LLU] = 2367LLU;
	28815	+ stack[base + 27LLU] = 2371LLU;
28768	28816	// arguments for call to emitvaridx
28769	28817	stack[base + 28LLU] = stack[base + 2]/dstindex/;
28770	28818	// set stack-base & callee-address

		@@ -28772,21 +28820,21 @@
28772	28820	label = 691LLU; // emitvaridx
28773	28821	break;
28774	28822	}
28775		- case 2366LLU: // copy-back deleter (emitvaridx to initfrom)
	28823	+ case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
28776	28824	{
28777	28825	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28778	28826	// copy mutable arguments back from call to emitvaridx
28779		- label = 2362LLU; // continue to roll stack
	28827	+ label = 2366LLU; // continue to roll stack
28780	28828	break;
28781	28829	}
28782		- case 2367LLU: // return from emitvaridx to initfrom
	28830	+ case 2371LLU: // return from emitvaridx to initfrom
28783	28831	{
28784	28832	// copy mutable arguments back from call to emitvaridx
28785	28833	printf("%s", " = construct(");
28786	28834	// call printnr from initfrom
28787		- stack[base + 25LLU] = 2368LLU/throw to this address/;
	28835	+ stack[base + 25LLU] = 2372LLU/throw to this address/;
28788	28836	stack[base + 26LLU] = base;
28789		- stack[base + 27LLU] = 2369LLU;
	28837	+ stack[base + 27LLU] = 2373LLU;
28790	28838	// arguments for call to printnr
28791	28839	stack[base + 28LLU] = stack[base + 24]/size/;
28792	28840	// set stack-base & callee-address

		@@ -28794,27 +28842,27 @@
28794	28842	label = 18446744073709551590LLU; // printnr
28795	28843	break;
28796	28844	}
28797		- case 2368LLU: // copy-back deleter (printnr to initfrom)
	28845	+ case 2372LLU: // copy-back deleter (printnr to initfrom)
28798	28846	{
28799	28847	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28800	28848	// copy mutable arguments back from call to printnr
28801		- label = 2362LLU; // continue to roll stack
	28849	+ label = 2366LLU; // continue to roll stack
28802	28850	break;
28803	28851	}
28804		- case 2369LLU: // return from printnr to initfrom
	28852	+ case 2373LLU: // return from printnr to initfrom
28805	28853	{
28806	28854	// copy mutable arguments back from call to printnr
28807	28855	printf("%s", "))) FORCE CONSTRUCTION TO FAIL TO VERIFY THROW MECHANISM");
28808		- label = 2365LLU; // consequent complete
	28856	+ label = 2369LLU; // consequent complete
28809	28857	break;
28810	28858	}
28811		- case 2364LLU: // alternative
	28859	+ case 2368LLU: // alternative
28812	28860	{
28813	28861	printf("%s", "\n if(!(");
28814	28862	// call emitvaridx from initfrom
28815		- stack[base + 25LLU] = 2370LLU/throw to this address/;
	28863	+ stack[base + 25LLU] = 2374LLU/throw to this address/;
28816	28864	stack[base + 26LLU] = base;
28817		- stack[base + 27LLU] = 2371LLU;
	28865	+ stack[base + 27LLU] = 2375LLU;
28818	28866	// arguments for call to emitvaridx
28819	28867	stack[base + 28LLU] = stack[base + 2]/dstindex/;
28820	28868	// set stack-base & callee-address

		@@ -28822,21 +28870,21 @@
28822	28870	label = 691LLU; // emitvaridx
28823	28871	break;
28824	28872	}
28825		- case 2370LLU: // copy-back deleter (emitvaridx to initfrom)
	28873	+ case 2374LLU: // copy-back deleter (emitvaridx to initfrom)
28826	28874	{
28827	28875	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28828	28876	// copy mutable arguments back from call to emitvaridx
28829		- label = 2362LLU; // continue to roll stack
	28877	+ label = 2366LLU; // continue to roll stack
28830	28878	break;
28831	28879	}
28832		- case 2371LLU: // return from emitvaridx to initfrom
	28880	+ case 2375LLU: // return from emitvaridx to initfrom
28833	28881	{
28834	28882	// copy mutable arguments back from call to emitvaridx
28835	28883	printf("%s", " = construct(");
28836	28884	// call printnr from initfrom
28837		- stack[base + 25LLU] = 2372LLU/throw to this address/;
	28885	+ stack[base + 25LLU] = 2376LLU/throw to this address/;
28838	28886	stack[base + 26LLU] = base;
28839		- stack[base + 27LLU] = 2373LLU;
	28887	+ stack[base + 27LLU] = 2377LLU;
28840	28888	// arguments for call to printnr
28841	28889	stack[base + 28LLU] = stack[base + 24]/size/;
28842	28890	// set stack-base & callee-address

		@@ -28844,26 +28892,26 @@
28844	28892	label = 18446744073709551590LLU; // printnr
28845	28893	break;
28846	28894	}
28847		- case 2372LLU: // copy-back deleter (printnr to initfrom)
	28895	+ case 2376LLU: // copy-back deleter (printnr to initfrom)
28848	28896	{
28849	28897	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28850	28898	// copy mutable arguments back from call to printnr
28851		- label = 2362LLU; // continue to roll stack
	28899	+ label = 2366LLU; // continue to roll stack
28852	28900	break;
28853	28901	}
28854		- case 2373LLU: // return from printnr to initfrom
	28902	+ case 2377LLU: // return from printnr to initfrom
28855	28903	{
28856	28904	// copy mutable arguments back from call to printnr
28857	28905	printf("%s", ")))");
28858		- label = 2365LLU; // alternative complete
	28906	+ label = 2369LLU; // alternative complete
28859	28907	break;
28860	28908	}
28861		- case 2365LLU: // completed if-then-else
	28909	+ case 2369LLU: // completed if-then-else
28862	28910	{
28863	28911	// call emitthrow from initfrom
28864		- stack[base + 25LLU] = 2374LLU/throw to this address/;
	28912	+ stack[base + 25LLU] = 2378LLU/throw to this address/;
28865	28913	stack[base + 26LLU] = base;
28866		- stack[base + 27LLU] = 2375LLU;
	28914	+ stack[base + 27LLU] = 2379LLU;
28867	28915	// arguments for call to emitthrow
28868	28916	stack[base + 28LLU] = stack[base + 5]/scope/;
28869	28917	// set stack-base & callee-address

		@@ -28871,22 +28919,22 @@
28871	28919	label = 1559LLU; // emitthrow
28872	28920	break;
28873	28921	}
28874		- case 2374LLU: // copy-back deleter (emitthrow to initfrom)
	28922	+ case 2378LLU: // copy-back deleter (emitthrow to initfrom)
28875	28923	{
28876	28924	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitthrow to initfrom)\n");
28877	28925	// copy mutable arguments back from call to emitthrow
28878		- label = 2362LLU; // continue to roll stack
	28926	+ label = 2366LLU; // continue to roll stack
28879	28927	break;
28880	28928	}
28881		- case 2375LLU: // return from emitthrow to initfrom
	28929	+ case 2379LLU: // return from emitthrow to initfrom
28882	28930	{
28883	28931	// copy mutable arguments back from call to emitthrow
28884	28932	printf("%s", "\n // consequent");
28885	28933	printf("%s", "\n ((uint64_t *)");
28886	28934	// call emitvaridx from initfrom
28887		- stack[base + 25LLU] = 2376LLU/throw to this address/;
	28935	+ stack[base + 25LLU] = 2380LLU/throw to this address/;
28888	28936	stack[base + 26LLU] = base;
28889		- stack[base + 27LLU] = 2377LLU;
	28937	+ stack[base + 27LLU] = 2381LLU;
28890	28938	// arguments for call to emitvaridx
28891	28939	stack[base + 28LLU] = stack[base + 2]/dstindex/;
28892	28940	// set stack-base & callee-address

		@@ -28894,21 +28942,21 @@
28894	28942	label = 691LLU; // emitvaridx
28895	28943	break;
28896	28944	}
28897		- case 2376LLU: // copy-back deleter (emitvaridx to initfrom)
	28945	+ case 2380LLU: // copy-back deleter (emitvaridx to initfrom)
28898	28946	{
28899	28947	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
28900	28948	// copy mutable arguments back from call to emitvaridx
28901		- label = 2362LLU; // continue to roll stack
	28949	+ label = 2366LLU; // continue to roll stack
28902	28950	break;
28903	28951	}
28904		- case 2377LLU: // return from emitvaridx to initfrom
	28952	+ case 2381LLU: // return from emitvaridx to initfrom
28905	28953	{
28906	28954	// copy mutable arguments back from call to emitvaridx
28907	28955	printf("%s", ")[0] = ");
28908	28956	// call printnr from initfrom
28909		- stack[base + 25LLU] = 2378LLU/throw to this address/;
	28957	+ stack[base + 25LLU] = 2382LLU/throw to this address/;
28910	28958	stack[base + 26LLU] = base;
28911		- stack[base + 27LLU] = 2379LLU;
	28959	+ stack[base + 27LLU] = 2383LLU;
28912	28960	// arguments for call to printnr
28913	28961	stack[base + 28LLU] = stack[base + 20]/varnr/;
28914	28962	// set stack-base & callee-address

		@@ -28916,21 +28964,21 @@
28916	28964	label = 18446744073709551590LLU; // printnr
28917	28965	break;
28918	28966	}
28919		- case 2378LLU: // copy-back deleter (printnr to initfrom)
	28967	+ case 2382LLU: // copy-back deleter (printnr to initfrom)
28920	28968	{
28921	28969	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
28922	28970	// copy mutable arguments back from call to printnr
28923		- label = 2362LLU; // continue to roll stack
	28971	+ label = 2366LLU; // continue to roll stack
28924	28972	break;
28925	28973	}
28926		- case 2379LLU: // return from printnr to initfrom
	28974	+ case 2383LLU: // return from printnr to initfrom
28927	28975	{
28928	28976	// copy mutable arguments back from call to printnr
28929	28977	printf("%s", ";");
28930	28978	// call matchsym from initfrom
28931		- stack[base + 25LLU] = 2380LLU/throw to this address/;
	28979	+ stack[base + 25LLU] = 2384LLU/throw to this address/;
28932	28980	stack[base + 26LLU] = base;
28933		- stack[base + 27LLU] = 2381LLU;
	28981	+ stack[base + 27LLU] = 2385LLU;
28934	28982	// arguments for call to matchsym
28935	28983	stack[base + 28LLU] = stack[base + 0]/fnid/;
28936	28984	stack[base + 29LLU] = 40LLU;

		@@ -28940,46 +28988,46 @@
28940	28988	label = 212LLU; // matchsym
28941	28989	break;
28942	28990	}
28943		- case 2380LLU: // copy-back deleter (matchsym to initfrom)
	28991	+ case 2384LLU: // copy-back deleter (matchsym to initfrom)
28944	28992	{
28945	28993	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
28946	28994	// copy mutable arguments back from call to matchsym
28947	28995	stack[base + 6]/lookahead/ = stack[base + 30LLU];
28948		- label = 2362LLU; // continue to roll stack
	28996	+ label = 2366LLU; // continue to roll stack
28949	28997	break;
28950	28998	}
28951		- case 2381LLU: // return from matchsym to initfrom
	28999	+ case 2385LLU: // return from matchsym to initfrom
28952	29000	{
28953	29001	// copy mutable arguments back from call to matchsym
28954	29002	stack[base + 6]/lookahead/ = stack[base + 30LLU];
28955		- label = 2383LLU; // skip deleter
	29003	+ label = 2387LLU; // skip deleter
28956	29004	break;
28957	29005	}
28958		- case 2382LLU: // deleter
	29006	+ case 2386LLU: // deleter
28959	29007	{
28960	29008	// throw from initfrom
28961	29009	if(!stack[base + 25])
28962	29010	{
28963	29011	fprintf(stderr, "in function initfrom: unrolling stack, skipping already deleted/unscoped variable u64 \n");
28964		- label = 2362LLU; // skip, variable already deleted/unscoped
	29012	+ label = 2366LLU; // skip, variable already deleted/unscoped
28965	29013	break;
28966	29014	}
28967	29015	fprintf(stderr, "in function initfrom: unrolling stack, variable u64 \n");
28968		- label = 2362LLU; // continue unrolling stack, delete next variable
	29016	+ label = 2366LLU; // continue unrolling stack, delete next variable
28969	29017	break;
28970	29018	}
28971		- case 2383LLU: // skipped deleter
	29019	+ case 2387LLU: // skipped deleter
28972	29020	{
28973	29021	stack[base + 25] = 0;
28974	29022	flippedassign(stack[base + 23]/TYPEIDS/, &stack[base + 26]);
28975		- label = 2384LLU; // start to repeat
	29023	+ label = 2388LLU; // start to repeat
28976	29024	break;
28977	29025	}
28978		- case 2384LLU: // repeat from here
	29026	+ case 2388LLU: // repeat from here
28979	29027	{
28980	29028	if(!stack[base + 26])
28981	29029	{
28982		- label = 2385LLU; // break loop
	29030	+ label = 2389LLU; // break loop
28983	29031	break;
28984	29032	}
28985	29033

		@@ -28989,7 +29037,7 @@
28989	29037	stack[base + 26] = (uint64_t)(((const struct listnode *)(stack[base + 26]))->next);
28990	29038	if(/typeid/0 != ((uint64_t )(stack[base + 27]/typeid*/))[0])
28991	29039	{
28992		- label = 2388LLU; // jump to alternative
	29040	+ label = 2392LLU; // jump to alternative
28993	29041	break;
28994	29042	}
28995	29043

		@@ -28999,15 +29047,15 @@
28999	29047	// case
29000	29048	if(!stack[base + 25]/elemindex/)
29001	29049	{
29002		- label = 2390LLU; // jump to alternative
	29050	+ label = 2394LLU; // jump to alternative
29003	29051	break;
29004	29052	}
29005	29053
29006	29054	// consequent
29007	29055	// call matchsym from initfrom
29008		- stack[base + 31LLU] = 2392LLU/throw to this address/;
	29056	+ stack[base + 31LLU] = 2396LLU/throw to this address/;
29009	29057	stack[base + 32LLU] = base;
29010		- stack[base + 33LLU] = 2393LLU;
	29058	+ stack[base + 33LLU] = 2397LLU;
29011	29059	// arguments for call to matchsym
29012	29060	stack[base + 34LLU] = stack[base + 0]/fnid/;
29013	29061	stack[base + 35LLU] = 44LLU;

		@@ -29017,32 +29065,32 @@
29017	29065	label = 212LLU; // matchsym
29018	29066	break;
29019	29067	}
29020		- case 2392LLU: // copy-back deleter (matchsym to initfrom)
	29068	+ case 2396LLU: // copy-back deleter (matchsym to initfrom)
29021	29069	{
29022	29070	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (matchsym to initfrom)\n");
29023	29071	// copy mutable arguments back from call to matchsym
29024	29072	stack[base + 6]/lookahead/ = stack[base + 36LLU];
29025		- label = 2389LLU; // continue to roll stack
	29073	+ label = 2393LLU; // continue to roll stack
29026	29074	break;
29027	29075	}
29028		- case 2393LLU: // return from matchsym to initfrom
	29076	+ case 2397LLU: // return from matchsym to initfrom
29029	29077	{
29030	29078	// copy mutable arguments back from call to matchsym
29031	29079	stack[base + 6]/lookahead/ = stack[base + 36LLU];
29032		- label = 2391LLU; // consequent complete
	29080	+ label = 2395LLU; // consequent complete
29033	29081	break;
29034	29082	}
29035		- case 2390LLU: // alternative
	29083	+ case 2394LLU: // alternative
29036	29084	{
29037		- label = 2391LLU; // alternative complete
	29085	+ label = 2395LLU; // alternative complete
29038	29086	break;
29039	29087	}
29040		- case 2391LLU: // completed if-then-else
	29088	+ case 2395LLU: // completed if-then-else
29041	29089	{
29042	29090	// call ParseToken from initfrom
29043		- stack[base + 31LLU] = 2394LLU/throw to this address/;
	29091	+ stack[base + 31LLU] = 2398LLU/throw to this address/;
29044	29092	stack[base + 32LLU] = base;
29045		- stack[base + 33LLU] = 2395LLU;
	29093	+ stack[base + 33LLU] = 2399LLU;
29046	29094	// arguments for call to ParseToken
29047	29095	stack[base + 36LLU] = stack[base + 6]/lookahead/;
29048	29096	// set stack-base & callee-address

		@@ -29050,15 +29098,15 @@
29050	29098	label = 3LLU; // ParseToken
29051	29099	break;
29052	29100	}
29053		- case 2394LLU: // copy-back deleter (ParseToken to initfrom)
	29101	+ case 2398LLU: // copy-back deleter (ParseToken to initfrom)
29054	29102	{
29055	29103	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (ParseToken to initfrom)\n");
29056	29104	// copy mutable arguments back from call to ParseToken
29057	29105	stack[base + 6]/lookahead/ = stack[base + 36LLU];
29058		- label = 2389LLU; // continue to roll stack
	29106	+ label = 2393LLU; // continue to roll stack
29059	29107	break;
29060	29108	}
29061		- case 2395LLU: // return from ParseToken to initfrom
	29109	+ case 2399LLU: // return from ParseToken to initfrom
29062	29110	{
29063	29111	// copy mutable arguments back from call to ParseToken
29064	29112	stack[base + 6]/lookahead/ = stack[base + 36LLU];

		@@ -29066,9 +29114,9 @@
29066	29114	stack[base + 10] = stack[base + 34LLU];
29067	29115	stack[base + 11] = stack[base + 35LLU];
29068	29116	// call equ from initfrom
29069		- stack[base + 31LLU] = 2396LLU/throw to this address/;
	29117	+ stack[base + 31LLU] = 2400LLU/throw to this address/;
29070	29118	stack[base + 32LLU] = base;
29071		- stack[base + 33LLU] = 2397LLU;
	29119	+ stack[base + 33LLU] = 2401LLU;
29072	29120	// arguments for call to equ
29073	29121	stack[base + 35LLU] = stack[base + 10]/variant/;
29074	29122	stack[base + 36LLU] = 4LLU;

		@@ -29077,14 +29125,14 @@
29077	29125	label = 18446744073709551600LLU; // equ
29078	29126	break;
29079	29127	}
29080		- case 2396LLU: // copy-back deleter (equ to initfrom)
	29128	+ case 2400LLU: // copy-back deleter (equ to initfrom)
29081	29129	{
29082	29130	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
29083	29131	// copy mutable arguments back from call to equ
29084		- label = 2389LLU; // continue to roll stack
	29132	+ label = 2393LLU; // continue to roll stack
29085	29133	break;
29086	29134	}
29087		- case 2397LLU: // return from equ to initfrom
	29135	+ case 2401LLU: // return from equ to initfrom
29088	29136	{
29089	29137	// copy mutable arguments back from call to equ
29090	29138	// copy back results provided by call to equ

		@@ -29091,21 +29139,21 @@
29091	29139	stack[base + 9] = stack[base + 34LLU];
29092	29140	if(!stack[base + 9]/isequal/)
29093	29141	{
29094		- label = 2398LLU; // jump to alternative
	29142	+ label = 2402LLU; // jump to alternative
29095	29143	break;
29096	29144	}
29097	29145
29098	29146	// consequent
29099		- label = 2399LLU; // consequent complete
	29147	+ label = 2403LLU; // consequent complete
29100	29148	break;
29101	29149	}
29102		- case 2398LLU: // alternative
	29150	+ case 2402LLU: // alternative
29103	29151	{
29104	29152	fprintf(stderr, "%s", "constructor requires variables but found ");
29105	29153	// call reporttok from initfrom
29106		- stack[base + 31LLU] = 2400LLU/throw to this address/;
	29154	+ stack[base + 31LLU] = 2404LLU/throw to this address/;
29107	29155	stack[base + 32LLU] = base;
29108		- stack[base + 33LLU] = 2401LLU;
	29156	+ stack[base + 33LLU] = 2405LLU;
29109	29157	// arguments for call to reporttok
29110	29158	stack[base + 34LLU] = stack[base + 10]/variant/;
29111	29159	stack[base + 35LLU] = stack[base + 11]/content/;

		@@ -29114,27 +29162,27 @@
29114	29162	label = 18446744073709551582LLU; // reporttok
29115	29163	break;
29116	29164	}
29117		- case 2400LLU: // copy-back deleter (reporttok to initfrom)
	29165	+ case 2404LLU: // copy-back deleter (reporttok to initfrom)
29118	29166	{
29119	29167	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reporttok to initfrom)\n");
29120	29168	// copy mutable arguments back from call to reporttok
29121		- label = 2389LLU; // continue to roll stack
	29169	+ label = 2393LLU; // continue to roll stack
29122	29170	break;
29123	29171	}
29124		- case 2401LLU: // return from reporttok to initfrom
	29172	+ case 2405LLU: // return from reporttok to initfrom
29125	29173	{
29126	29174	// copy mutable arguments back from call to reporttok
29127	29175	fprintf(stderr, "%s", "\n");
29128	29176	exit(-1);
29129		- label = 2399LLU; // alternative complete
	29177	+ label = 2403LLU; // alternative complete
29130	29178	break;
29131	29179	}
29132		- case 2399LLU: // completed if-then-else
	29180	+ case 2403LLU: // completed if-then-else
29133	29181	{
29134	29182	// call getlettype from initfrom
29135		- stack[base + 32LLU] = 2402LLU/throw to this address/;
	29183	+ stack[base + 32LLU] = 2406LLU/throw to this address/;
29136	29184	stack[base + 33LLU] = base;
29137		- stack[base + 34LLU] = 2403LLU;
	29185	+ stack[base + 34LLU] = 2407LLU;
29138	29186	// arguments for call to getlettype
29139	29187	stack[base + 36LLU] = stack[base + 0]/fnid/;
29140	29188	stack[base + 37LLU] = stack[base + 11]/content/;

		@@ -29145,14 +29193,14 @@
29145	29193	label = 651LLU; // getlettype
29146	29194	break;
29147	29195	}
29148		- case 2402LLU: // copy-back deleter (getlettype to initfrom)
	29196	+ case 2406LLU: // copy-back deleter (getlettype to initfrom)
29149	29197	{
29150	29198	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (getlettype to initfrom)\n");
29151	29199	// copy mutable arguments back from call to getlettype
29152		- label = 2389LLU; // continue to roll stack
	29200	+ label = 2393LLU; // continue to roll stack
29153	29201	break;
29154	29202	}
29155		- case 2403LLU: // return from getlettype to initfrom
	29203	+ case 2407LLU: // return from getlettype to initfrom
29156	29204	{
29157	29205	// copy mutable arguments back from call to getlettype
29158	29206	// copy back results provided by call to getlettype

		@@ -29160,7 +29208,7 @@
29160	29208	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
29161	29209	if(!newstack)
29162	29210	{
29163		- label = 2389LLU; // throw: begin to unroll stack
	29211	+ label = 2393LLU; // throw: begin to unroll stack
29164	29212	break;
29165	29213	}
29166	29214

		@@ -29167,9 +29215,9 @@
29167	29215	newstack[15LLU] = 9876543210LLU; // overflow-marker
29168	29216	// call equtype from initfrom
29169	29217	newstack[0] = (uint64_t)stack; // backup stack location
29170		- newstack[1] = 2404LLU;
	29218	+ newstack[1] = 2408LLU;
29171	29219	newstack[2] = base;
29172		- newstack[3] = 2405LLU;
	29220	+ newstack[3] = 2409LLU;
29173	29221	// arguments for call to equtype
29174	29222	newstack[5LLU] = stack[base + 29]/dsttype/;
29175	29223	newstack[6LLU] = stack[base + 31]/srctype/;

		@@ -29179,7 +29227,7 @@
29179	29227	label = 342LLU; // equtype
29180	29228	break;
29181	29229	}
29182		- case 2404LLU: // copy-back deleter (equtype to initfrom)
	29230	+ case 2408LLU: // copy-back deleter (equtype to initfrom)
29183	29231	{
29184	29232	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equtype to initfrom)\n");
29185	29233	uint64_t oldstack = (uint64_t )stack[0];

		@@ -29191,10 +29239,10 @@
29191	29239	}
29192	29240	Free(15LLU + 1, sizeof(uint64_t), stack);
29193	29241	stack = oldstack;
29194		- label = 2389LLU; // continue to unroll stack
	29242	+ label = 2393LLU; // continue to unroll stack
29195	29243	break;
29196	29244	}
29197		- case 2405LLU: // return from equtype to initfrom
	29245	+ case 2409LLU: // return from equtype to initfrom
29198	29246	{
29199	29247	uint64_t oldstack = (uint64_t )stack[0];
29200	29248	// copy mutable arguments back from call to equtype

		@@ -29209,7 +29257,7 @@
29209	29257	stack = oldstack;
29210	29258	if(!stack[base + 9]/isequal/)
29211	29259	{
29212		- label = 2406LLU; // jump to alternative
	29260	+ label = 2410LLU; // jump to alternative
29213	29261	break;
29214	29262	}
29215	29263

		@@ -29216,7 +29264,7 @@
29216	29264	// consequent
29217	29265	if(/typename/0 != ((uint64_t )(stack[base + 29]/dsttype*/))[0])
29218	29266	{
29219		- label = 2409LLU; // jump to alternative
	29267	+ label = 2413LLU; // jump to alternative
29220	29268	break;
29221	29269	}
29222	29270

		@@ -29224,9 +29272,9 @@
29224	29272
29225	29273	// case
29226	29274	// call equ from initfrom
29227		- stack[base + 33LLU] = 2411LLU/throw to this address/;
	29275	+ stack[base + 33LLU] = 2415LLU/throw to this address/;
29228	29276	stack[base + 34LLU] = base;
29229		- stack[base + 35LLU] = 2412LLU;
	29277	+ stack[base + 35LLU] = 2416LLU;
29230	29278	// arguments for call to equ
29231	29279	stack[base + 37LLU] = 881834713755418624LLU;
29232	29280	stack[base + 38LLU] = stack[base + 32]/name/;

		@@ -29235,14 +29283,14 @@
29235	29283	label = 18446744073709551600LLU; // equ
29236	29284	break;
29237	29285	}
29238		- case 2411LLU: // copy-back deleter (equ to initfrom)
	29286	+ case 2415LLU: // copy-back deleter (equ to initfrom)
29239	29287	{
29240	29288	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (equ to initfrom)\n");
29241	29289	// copy mutable arguments back from call to equ
29242		- label = 2410LLU; // continue to roll stack
	29290	+ label = 2414LLU; // continue to roll stack
29243	29291	break;
29244	29292	}
29245		- case 2412LLU: // return from equ to initfrom
	29293	+ case 2416LLU: // return from equ to initfrom
29246	29294	{
29247	29295	// copy mutable arguments back from call to equ
29248	29296	// copy back results provided by call to equ

		@@ -29249,7 +29297,7 @@
29249	29297	stack[base + 9] = stack[base + 36LLU];
29250	29298	if(!stack[base + 9]/isequal/)
29251	29299	{
29252		- label = 2413LLU; // jump to alternative
	29300	+ label = 2417LLU; // jump to alternative
29253	29301	break;
29254	29302	}
29255	29303

		@@ -29256,9 +29304,9 @@
29256	29304	// consequent
29257	29305	printf("%s", "\n (((uint64_t **)(");
29258	29306	// call emitvaridx from initfrom
29259		- stack[base + 33LLU] = 2415LLU/throw to this address/;
	29307	+ stack[base + 33LLU] = 2419LLU/throw to this address/;
29260	29308	stack[base + 34LLU] = base;
29261		- stack[base + 35LLU] = 2416LLU;
	29309	+ stack[base + 35LLU] = 2420LLU;
29262	29310	// arguments for call to emitvaridx
29263	29311	stack[base + 36LLU] = stack[base + 2]/dstindex/;
29264	29312	// set stack-base & callee-address

		@@ -29266,21 +29314,21 @@
29266	29314	label = 691LLU; // emitvaridx
29267	29315	break;
29268	29316	}
29269		- case 2415LLU: // copy-back deleter (emitvaridx to initfrom)
	29317	+ case 2419LLU: // copy-back deleter (emitvaridx to initfrom)
29270	29318	{
29271	29319	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29272	29320	// copy mutable arguments back from call to emitvaridx
29273		- label = 2410LLU; // continue to roll stack
	29321	+ label = 2414LLU; // continue to roll stack
29274	29322	break;
29275	29323	}
29276		- case 2416LLU: // return from emitvaridx to initfrom
	29324	+ case 2420LLU: // return from emitvaridx to initfrom
29277	29325	{
29278	29326	// copy mutable arguments back from call to emitvaridx
29279	29327	printf("%s", "))[1][");
29280	29328	// call printnr from initfrom
29281		- stack[base + 33LLU] = 2417LLU/throw to this address/;
	29329	+ stack[base + 33LLU] = 2421LLU/throw to this address/;
29282	29330	stack[base + 34LLU] = base;
29283		- stack[base + 35LLU] = 2418LLU;
	29331	+ stack[base + 35LLU] = 2422LLU;
29284	29332	// arguments for call to printnr
29285	29333	stack[base + 36LLU] = stack[base + 25]/elemindex/;
29286	29334	// set stack-base & callee-address

		@@ -29288,21 +29336,21 @@
29288	29336	label = 18446744073709551590LLU; // printnr
29289	29337	break;
29290	29338	}
29291		- case 2417LLU: // copy-back deleter (printnr to initfrom)
	29339	+ case 2421LLU: // copy-back deleter (printnr to initfrom)
29292	29340	{
29293	29341	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29294	29342	// copy mutable arguments back from call to printnr
29295		- label = 2410LLU; // continue to roll stack
	29343	+ label = 2414LLU; // continue to roll stack
29296	29344	break;
29297	29345	}
29298		- case 2418LLU: // return from printnr to initfrom
	29346	+ case 2422LLU: // return from printnr to initfrom
29299	29347	{
29300	29348	// copy mutable arguments back from call to printnr
29301	29349	printf("%s", "]) = ");
29302	29350	// call emitvar from initfrom
29303		- stack[base + 33LLU] = 2419LLU/throw to this address/;
	29351	+ stack[base + 33LLU] = 2423LLU/throw to this address/;
29304	29352	stack[base + 34LLU] = base;
29305		- stack[base + 35LLU] = 2420LLU;
	29353	+ stack[base + 35LLU] = 2424LLU;
29306	29354	// arguments for call to emitvar
29307	29355	stack[base + 36LLU] = stack[base + 0]/fnid/;
29308	29356	stack[base + 37LLU] = stack[base + 11]/content/;

		@@ -29313,27 +29361,27 @@
29313	29361	label = 695LLU; // emitvar
29314	29362	break;
29315	29363	}
29316		- case 2419LLU: // copy-back deleter (emitvar to initfrom)
	29364	+ case 2423LLU: // copy-back deleter (emitvar to initfrom)
29317	29365	{
29318	29366	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29319	29367	// copy mutable arguments back from call to emitvar
29320		- label = 2410LLU; // continue to roll stack
	29368	+ label = 2414LLU; // continue to roll stack
29321	29369	break;
29322	29370	}
29323		- case 2420LLU: // return from emitvar to initfrom
	29371	+ case 2424LLU: // return from emitvar to initfrom
29324	29372	{
29325	29373	// copy mutable arguments back from call to emitvar
29326	29374	printf("%s", ";");
29327		- label = 2414LLU; // consequent complete
	29375	+ label = 2418LLU; // consequent complete
29328	29376	break;
29329	29377	}
29330		- case 2413LLU: // alternative
	29378	+ case 2417LLU: // alternative
29331	29379	{
29332	29380	printf("%s", "\n INIT(&(((uint64_t **)(");
29333	29381	// call emitvaridx from initfrom
29334		- stack[base + 33LLU] = 2421LLU/throw to this address/;
	29382	+ stack[base + 33LLU] = 2425LLU/throw to this address/;
29335	29383	stack[base + 34LLU] = base;
29336		- stack[base + 35LLU] = 2422LLU;
	29384	+ stack[base + 35LLU] = 2426LLU;
29337	29385	// arguments for call to emitvaridx
29338	29386	stack[base + 36LLU] = stack[base + 2]/dstindex/;
29339	29387	// set stack-base & callee-address

		@@ -29341,21 +29389,21 @@
29341	29389	label = 691LLU; // emitvaridx
29342	29390	break;
29343	29391	}
29344		- case 2421LLU: // copy-back deleter (emitvaridx to initfrom)
	29392	+ case 2425LLU: // copy-back deleter (emitvaridx to initfrom)
29345	29393	{
29346	29394	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29347	29395	// copy mutable arguments back from call to emitvaridx
29348		- label = 2410LLU; // continue to roll stack
	29396	+ label = 2414LLU; // continue to roll stack
29349	29397	break;
29350	29398	}
29351		- case 2422LLU: // return from emitvaridx to initfrom
	29399	+ case 2426LLU: // return from emitvaridx to initfrom
29352	29400	{
29353	29401	// copy mutable arguments back from call to emitvaridx
29354	29402	printf("%s", "))[1][");
29355	29403	// call printnr from initfrom
29356		- stack[base + 33LLU] = 2423LLU/throw to this address/;
	29404	+ stack[base + 33LLU] = 2427LLU/throw to this address/;
29357	29405	stack[base + 34LLU] = base;
29358		- stack[base + 35LLU] = 2424LLU;
	29406	+ stack[base + 35LLU] = 2428LLU;
29359	29407	// arguments for call to printnr
29360	29408	stack[base + 36LLU] = stack[base + 25]/elemindex/;
29361	29409	// set stack-base & callee-address

		@@ -29363,21 +29411,21 @@
29363	29411	label = 18446744073709551590LLU; // printnr
29364	29412	break;
29365	29413	}
29366		- case 2423LLU: // copy-back deleter (printnr to initfrom)
	29414	+ case 2427LLU: // copy-back deleter (printnr to initfrom)
29367	29415	{
29368	29416	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29369	29417	// copy mutable arguments back from call to printnr
29370		- label = 2410LLU; // continue to roll stack
	29418	+ label = 2414LLU; // continue to roll stack
29371	29419	break;
29372	29420	}
29373		- case 2424LLU: // return from printnr to initfrom
	29421	+ case 2428LLU: // return from printnr to initfrom
29374	29422	{
29375	29423	// copy mutable arguments back from call to printnr
29376	29424	printf("%s", "]), &");
29377	29425	// call emitvar from initfrom
29378		- stack[base + 33LLU] = 2425LLU/throw to this address/;
	29426	+ stack[base + 33LLU] = 2429LLU/throw to this address/;
29379	29427	stack[base + 34LLU] = base;
29380		- stack[base + 35LLU] = 2426LLU;
	29428	+ stack[base + 35LLU] = 2430LLU;
29381	29429	// arguments for call to emitvar
29382	29430	stack[base + 36LLU] = stack[base + 0]/fnid/;
29383	29431	stack[base + 37LLU] = stack[base + 11]/content/;

		@@ -29388,21 +29436,21 @@
29388	29436	label = 695LLU; // emitvar
29389	29437	break;
29390	29438	}
29391		- case 2425LLU: // copy-back deleter (emitvar to initfrom)
	29439	+ case 2429LLU: // copy-back deleter (emitvar to initfrom)
29392	29440	{
29393	29441	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29394	29442	// copy mutable arguments back from call to emitvar
29395		- label = 2410LLU; // continue to roll stack
	29443	+ label = 2414LLU; // continue to roll stack
29396	29444	break;
29397	29445	}
29398		- case 2426LLU: // return from emitvar to initfrom
	29446	+ case 2430LLU: // return from emitvar to initfrom
29399	29447	{
29400	29448	// copy mutable arguments back from call to emitvar
29401	29449	printf("%s", ");");
29402	29450	// call unscopelet from initfrom
29403		- stack[base + 33LLU] = 2427LLU/throw to this address/;
	29451	+ stack[base + 33LLU] = 2431LLU/throw to this address/;
29404	29452	stack[base + 34LLU] = base;
29405		- stack[base + 35LLU] = 2428LLU;
	29453	+ stack[base + 35LLU] = 2432LLU;
29406	29454	// arguments for call to unscopelet
29407	29455	stack[base + 36LLU] = stack[base + 0]/fnid/;
29408	29456	stack[base + 37LLU] = stack[base + 5]/scope/;

		@@ -29412,41 +29460,41 @@
29412	29460	label = 761LLU; // unscopelet
29413	29461	break;
29414	29462	}
29415		- case 2427LLU: // copy-back deleter (unscopelet to initfrom)
	29463	+ case 2431LLU: // copy-back deleter (unscopelet to initfrom)
29416	29464	{
29417	29465	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
29418	29466	// copy mutable arguments back from call to unscopelet
29419	29467	stack[base + 5]/scope/ = stack[base + 37LLU];
29420		- label = 2410LLU; // continue to roll stack
	29468	+ label = 2414LLU; // continue to roll stack
29421	29469	break;
29422	29470	}
29423		- case 2428LLU: // return from unscopelet to initfrom
	29471	+ case 2432LLU: // return from unscopelet to initfrom
29424	29472	{
29425	29473	// copy mutable arguments back from call to unscopelet
29426	29474	stack[base + 5]/scope/ = stack[base + 37LLU];
29427		- label = 2414LLU; // alternative complete
	29475	+ label = 2418LLU; // alternative complete
29428	29476	break;
29429	29477	}
29430		- case 2414LLU: // completed if-then-else
	29478	+ case 2418LLU: // completed if-then-else
29431	29479	{
29432	29480	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29433		- label = 2408LLU; // case complete
	29481	+ label = 2412LLU; // case complete
29434	29482	break;
29435	29483	}
29436		- case 2410LLU: // copy-back deleter (switch)
	29484	+ case 2414LLU: // copy-back deleter (switch)
29437	29485	{
29438	29486	((uint64_t **)(stack[base + 29]))[1][0] = stack[base + 32];
29439		- label = 2389LLU; // continue to unroll stack
	29487	+ label = 2393LLU; // continue to unroll stack
29440	29488	break;
29441	29489	}
29442		- case 2409LLU: // try next case
	29490	+ case 2413LLU: // try next case
29443	29491	{
29444	29492	// default
29445	29493	printf("%s", "\n INIT(&(((uint64_t **)(");
29446	29494	// call emitvaridx from initfrom
29447		- stack[base + 32LLU] = 2429LLU/throw to this address/;
	29495	+ stack[base + 32LLU] = 2433LLU/throw to this address/;
29448	29496	stack[base + 33LLU] = base;
29449		- stack[base + 34LLU] = 2430LLU;
	29497	+ stack[base + 34LLU] = 2434LLU;
29450	29498	// arguments for call to emitvaridx
29451	29499	stack[base + 35LLU] = stack[base + 2]/dstindex/;
29452	29500	// set stack-base & callee-address

		@@ -29454,21 +29502,21 @@
29454	29502	label = 691LLU; // emitvaridx
29455	29503	break;
29456	29504	}
29457		- case 2429LLU: // copy-back deleter (emitvaridx to initfrom)
	29505	+ case 2433LLU: // copy-back deleter (emitvaridx to initfrom)
29458	29506	{
29459	29507	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvaridx to initfrom)\n");
29460	29508	// copy mutable arguments back from call to emitvaridx
29461		- label = 2389LLU; // continue to roll stack
	29509	+ label = 2393LLU; // continue to roll stack
29462	29510	break;
29463	29511	}
29464		- case 2430LLU: // return from emitvaridx to initfrom
	29512	+ case 2434LLU: // return from emitvaridx to initfrom
29465	29513	{
29466	29514	// copy mutable arguments back from call to emitvaridx
29467	29515	printf("%s", "))[1][");
29468	29516	// call printnr from initfrom
29469		- stack[base + 32LLU] = 2431LLU/throw to this address/;
	29517	+ stack[base + 32LLU] = 2435LLU/throw to this address/;
29470	29518	stack[base + 33LLU] = base;
29471		- stack[base + 34LLU] = 2432LLU;
	29519	+ stack[base + 34LLU] = 2436LLU;
29472	29520	// arguments for call to printnr
29473	29521	stack[base + 35LLU] = stack[base + 25]/elemindex/;
29474	29522	// set stack-base & callee-address

		@@ -29476,21 +29524,21 @@
29476	29524	label = 18446744073709551590LLU; // printnr
29477	29525	break;
29478	29526	}
29479		- case 2431LLU: // copy-back deleter (printnr to initfrom)
	29527	+ case 2435LLU: // copy-back deleter (printnr to initfrom)
29480	29528	{
29481	29529	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (printnr to initfrom)\n");
29482	29530	// copy mutable arguments back from call to printnr
29483		- label = 2389LLU; // continue to roll stack
	29531	+ label = 2393LLU; // continue to roll stack
29484	29532	break;
29485	29533	}
29486		- case 2432LLU: // return from printnr to initfrom
	29534	+ case 2436LLU: // return from printnr to initfrom
29487	29535	{
29488	29536	// copy mutable arguments back from call to printnr
29489	29537	printf("%s", "]), &");
29490	29538	// call emitvar from initfrom
29491		- stack[base + 32LLU] = 2433LLU/throw to this address/;
	29539	+ stack[base + 32LLU] = 2437LLU/throw to this address/;
29492	29540	stack[base + 33LLU] = base;
29493		- stack[base + 34LLU] = 2434LLU;
	29541	+ stack[base + 34LLU] = 2438LLU;
29494	29542	// arguments for call to emitvar
29495	29543	stack[base + 35LLU] = stack[base + 0]/fnid/;
29496	29544	stack[base + 36LLU] = stack[base + 11]/content/;

		@@ -29501,21 +29549,21 @@
29501	29549	label = 695LLU; // emitvar
29502	29550	break;
29503	29551	}
29504		- case 2433LLU: // copy-back deleter (emitvar to initfrom)
	29552	+ case 2437LLU: // copy-back deleter (emitvar to initfrom)
29505	29553	{
29506	29554	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (emitvar to initfrom)\n");
29507	29555	// copy mutable arguments back from call to emitvar
29508		- label = 2389LLU; // continue to roll stack
	29556	+ label = 2393LLU; // continue to roll stack
29509	29557	break;
29510	29558	}
29511		- case 2434LLU: // return from emitvar to initfrom
	29559	+ case 2438LLU: // return from emitvar to initfrom
29512	29560	{
29513	29561	// copy mutable arguments back from call to emitvar
29514	29562	printf("%s", ");");
29515	29563	// call unscopelet from initfrom
29516		- stack[base + 32LLU] = 2435LLU/throw to this address/;
	29564	+ stack[base + 32LLU] = 2439LLU/throw to this address/;
29517	29565	stack[base + 33LLU] = base;
29518		- stack[base + 34LLU] = 2436LLU;
	29566	+ stack[base + 34LLU] = 2440LLU;
29519	29567	// arguments for call to unscopelet
29520	29568	stack[base + 35LLU] = stack[base + 0]/fnid/;
29521	29569	stack[base + 36LLU] = stack[base + 5]/scope/;

		@@ -29525,33 +29573,33 @@
29525	29573	label = 761LLU; // unscopelet
29526	29574	break;
29527	29575	}
29528		- case 2435LLU: // copy-back deleter (unscopelet to initfrom)
	29576	+ case 2439LLU: // copy-back deleter (unscopelet to initfrom)
29529	29577	{
29530	29578	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (unscopelet to initfrom)\n");
29531	29579	// copy mutable arguments back from call to unscopelet
29532	29580	stack[base + 5]/scope/ = stack[base + 36LLU];
29533		- label = 2389LLU; // continue to roll stack
	29581	+ label = 2393LLU; // continue to roll stack
29534	29582	break;
29535	29583	}
29536		- case 2436LLU: // return from unscopelet to initfrom
	29584	+ case 2440LLU: // return from unscopelet to initfrom
29537	29585	{
29538	29586	// copy mutable arguments back from call to unscopelet
29539	29587	stack[base + 5]/scope/ = stack[base + 36LLU];
29540		- label = 2408LLU; // default complete
	29588	+ label = 2412LLU; // default complete
29541	29589	break;
29542	29590	}
29543		- case 2408LLU: // completed switch
	29591	+ case 2412LLU: // completed switch
29544	29592	{
29545		- label = 2407LLU; // consequent complete
	29593	+ label = 2411LLU; // consequent complete
29546	29594	break;
29547	29595	}
29548		- case 2406LLU: // alternative
	29596	+ case 2410LLU: // alternative
29549	29597	{
29550	29598	fprintf(stderr, "%s", "in function ");
29551	29599	// call reportid from initfrom
29552		- stack[base + 32LLU] = 2437LLU/throw to this address/;
	29600	+ stack[base + 32LLU] = 2441LLU/throw to this address/;
29553	29601	stack[base + 33LLU] = base;
29554		- stack[base + 34LLU] = 2438LLU;
	29602	+ stack[base + 34LLU] = 2442LLU;
29555	29603	// arguments for call to reportid
29556	29604	stack[base + 35LLU] = stack[base + 0]/fnid/;
29557	29605	// set stack-base & callee-address

		@@ -29559,14 +29607,14 @@
29559	29607	label = 18446744073709551586LLU; // reportid
29560	29608	break;
29561	29609	}
29562		- case 2437LLU: // copy-back deleter (reportid to initfrom)
	29610	+ case 2441LLU: // copy-back deleter (reportid to initfrom)
29563	29611	{
29564	29612	fprintf(stderr, "in function initfrom: unrolling stack, copy-back (reportid to initfrom)\n");
29565	29613	// copy mutable arguments back from call to reportid
29566		- label = 2389LLU; // continue to roll stack
	29614	+ label = 2393LLU; // continue to roll stack
29567	29615	break;
29568	29616	}
29569		- case 2438LLU: // return from reportid to initfrom
	29617	+ case 2442LLU: // return from reportid to initfrom
29570	29618	{
29571	29619	// copy mutable arguments back from call to reportid
29572	29620	fprintf(stderr, "%s", ": constructor of type ");

		@@ -29573,7 +29621,7 @@
29573	29621	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
29574	29622	if(!newstack)
29575	29623	{
29576		- label = 2389LLU; // throw: begin to unroll stack
	29624	+ label = 2393LLU; // throw: begin to unroll stack
29577	29625	break;
29578	29626	}
29579	29627

		@@ -29580,9 +29628,9 @@
29580	29628	newstack[10LLU] = 9876543210LLU; // overflow-marker
29581	29629	// call reporttype from initfrom
29582	29630	newstack[0] = (uint64_t)stack; // backup stack location
29583		- newstack[1] = 2439LLU;
	29631	+ newstack[1] = 2443LLU;
29584	29632	newstack[2] = base;
29585		- newstack[3] = 2440LLU;
	29633	+ newstack[3] = 2444LLU;
29586	29634	// arguments for call to reporttype
29587	29635	newstack[4LLU] = stack[base + 29]/dsttype/;
29588	29636	stack = newstack;

		@@ -29591,7 +29639,7 @@
29591	29639	label = 316LLU; // reporttype
29592	29640	break;
29593