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

JPL

R/O
SSH
HTTPS

jpl: Commit

Commit MetaInfo

Revisión	1167 (tree)
Tiempo	2021-02-24 03:51:26
Autor	jakobthomsen

Log Message

fix copy-back on exception in switch

Cambiar Resumen

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

Diferencia incremental

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

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

		@@ -4232,9 +4232,9 @@
4232	4232
4233	4233	// case
4234	4234	// call printid from printtype
4235		- stack[base + 2LLU] = 308LLU/throw to this address/;
	4235	+ stack[base + 2LLU] = 309LLU/throw to this address/;
4236	4236	stack[base + 3LLU] = base;
4237		- stack[base + 4LLU] = 309LLU;
	4237	+ stack[base + 4LLU] = 310LLU;
4238	4238	// arguments for call to printid
4239	4239	stack[base + 5LLU] = stack[base + 1]/name/;
4240	4240	// set stack-base & callee-address

		@@ -4242,14 +4242,14 @@
4242	4242	label = 18446744073709551587LLU; // printid
4243	4243	break;
4244	4244	}
4245		- case 308LLU: // copy-back deleter (printid to printtype)
	4245	+ case 309LLU: // copy-back deleter (printid to printtype)
4246	4246	{
4247	4247	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
4248	4248	// copy mutable arguments back from call to printid
4249		- label = 305LLU; // continue to roll stack
	4249	+ label = 308LLU; // continue to roll stack
4250	4250	break;
4251	4251	}
4252		- case 309LLU: // return from printid to printtype
	4252	+ case 310LLU: // return from printid to printtype
4253	4253	{
4254	4254	// copy mutable arguments back from call to printid
4255	4255	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];

		@@ -4256,11 +4256,17 @@
4256	4256	label = 306LLU; // case complete
4257	4257	break;
4258	4258	}
	4259	+ case 308LLU: // copy-back deleter (switch)
	4260	+ {
	4261	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	4262	+ label = 305LLU; // continue to unroll stack
	4263	+ break;
	4264	+ }
4259	4265	case 307LLU: // try next case
4260	4266	{
4261	4267	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4262	4268	{
4263		- label = 310LLU; // jump to alternative
	4269	+ label = 311LLU; // jump to alternative
4264	4270	break;
4265	4271	}
4266	4272

		@@ -4271,7 +4277,7 @@
4271	4277	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4272	4278	if(!newstack)
4273	4279	{
4274		- label = 305LLU; // throw: begin to unroll stack
	4280	+ label = 312LLU; // throw: begin to unroll stack
4275	4281	break;
4276	4282	}
4277	4283

		@@ -4278,9 +4284,9 @@
4278	4284	newstack[10LLU] = 9876543210LLU; // overflow-marker
4279	4285	// call printtype from printtype
4280	4286	newstack[0] = (uint64_t)stack; // backup stack location
4281		- newstack[1] = 311LLU;
	4287	+ newstack[1] = 313LLU;
4282	4288	newstack[2] = base;
4283		- newstack[3] = 312LLU;
	4289	+ newstack[3] = 314LLU;
4284	4290	// arguments for call to printtype
4285	4291	newstack[4LLU] = stack[base + 1]/subtype/;
4286	4292	stack = newstack;

		@@ -4289,7 +4295,7 @@
4289	4295	label = 304LLU; // printtype
4290	4296	break;
4291	4297	}
4292		- case 311LLU: // copy-back deleter (printtype to printtype)
	4298	+ case 313LLU: // copy-back deleter (printtype to printtype)
4293	4299	{
4294	4300	fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
4295	4301	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4301,10 +4307,10 @@
4301	4307	}
4302	4308	Free(10LLU + 1, sizeof(uint64_t), stack);
4303	4309	stack = oldstack;
4304		- label = 305LLU; // continue to unroll stack
	4310	+ label = 312LLU; // continue to unroll stack
4305	4311	break;
4306	4312	}
4307		- case 312LLU: // return from printtype to printtype
	4313	+ case 314LLU: // return from printtype to printtype
4308	4314	{
4309	4315	uint64_t oldstack = (uint64_t )stack[0];
4310	4316	// copy mutable arguments back from call to printtype

		@@ -4320,8 +4326,14 @@
4320	4326	label = 306LLU; // case complete
4321	4327	break;
4322	4328	}
4323		- case 310LLU: // try next case
	4329	+ case 312LLU: // copy-back deleter (switch)
4324	4330	{
	4331	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	4332	+ label = 305LLU; // continue to unroll stack
	4333	+ break;
	4334	+ }
	4335	+ case 311LLU: // try next case
	4336	+ {
4325	4337	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4326	4338	exit(-1);
4327	4339	}

		@@ -4332,7 +4344,7 @@
4332	4344	base = stack[base - 2];
4333	4345	break;
4334	4346	}
4335		- case 314LLU: // function reporttype failed
	4347	+ case 316LLU: // function reporttype failed
4336	4348	{
4337	4349	fprintf(stderr, "function reporttype failed\n");
4338	4350	label = stack[base - 3];

		@@ -4339,12 +4351,12 @@
4339	4351	base = stack[base - 2];
4340	4352	break;
4341	4353	}
4342		- case 313LLU: // reporttype
	4354	+ case 315LLU: // reporttype
4343	4355	{
4344	4356	//#define arg0 0
4345	4357	if(/typename/0 != ((uint64_t )(stack[base + 0]/type*/))[0])
4346	4358	{
4347		- label = 316LLU; // jump to alternative
	4359	+ label = 318LLU; // jump to alternative
4348	4360	break;
4349	4361	}
4350	4362

		@@ -4352,9 +4364,9 @@
4352	4364
4353	4365	// case
4354	4366	// call reportid from reporttype
4355		- stack[base + 2LLU] = 317LLU/throw to this address/;
	4367	+ stack[base + 2LLU] = 320LLU/throw to this address/;
4356	4368	stack[base + 3LLU] = base;
4357		- stack[base + 4LLU] = 318LLU;
	4369	+ stack[base + 4LLU] = 321LLU;
4358	4370	// arguments for call to reportid
4359	4371	stack[base + 5LLU] = stack[base + 1]/name/;
4360	4372	// set stack-base & callee-address

		@@ -4362,25 +4374,31 @@
4362	4374	label = 18446744073709551586LLU; // reportid
4363	4375	break;
4364	4376	}
4365		- case 317LLU: // copy-back deleter (reportid to reporttype)
	4377	+ case 320LLU: // copy-back deleter (reportid to reporttype)
4366	4378	{
4367	4379	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
4368	4380	// copy mutable arguments back from call to reportid
4369		- label = 314LLU; // continue to roll stack
	4381	+ label = 319LLU; // continue to roll stack
4370	4382	break;
4371	4383	}
4372		- case 318LLU: // return from reportid to reporttype
	4384	+ case 321LLU: // return from reportid to reporttype
4373	4385	{
4374	4386	// copy mutable arguments back from call to reportid
4375	4387	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4376		- label = 315LLU; // case complete
	4388	+ label = 317LLU; // case complete
4377	4389	break;
4378	4390	}
4379		- case 316LLU: // try next case
	4391	+ case 319LLU: // copy-back deleter (switch)
4380	4392	{
	4393	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	4394	+ label = 316LLU; // continue to unroll stack
	4395	+ break;
	4396	+ }
	4397	+ case 318LLU: // try next case
	4398	+ {
4381	4399	if(/typelist/1 != ((uint64_t )(stack[base + 0]/type*/))[0])
4382	4400	{
4383		- label = 319LLU; // jump to alternative
	4401	+ label = 322LLU; // jump to alternative
4384	4402	break;
4385	4403	}
4386	4404

		@@ -4391,7 +4409,7 @@
4391	4409	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
4392	4410	if(!newstack)
4393	4411	{
4394		- label = 314LLU; // throw: begin to unroll stack
	4412	+ label = 323LLU; // throw: begin to unroll stack
4395	4413	break;
4396	4414	}
4397	4415

		@@ -4398,18 +4416,18 @@
4398	4416	newstack[10LLU] = 9876543210LLU; // overflow-marker
4399	4417	// call reporttype from reporttype
4400	4418	newstack[0] = (uint64_t)stack; // backup stack location
4401		- newstack[1] = 320LLU;
	4419	+ newstack[1] = 324LLU;
4402	4420	newstack[2] = base;
4403		- newstack[3] = 321LLU;
	4421	+ newstack[3] = 325LLU;
4404	4422	// arguments for call to reporttype
4405	4423	newstack[4LLU] = stack[base + 1]/subtype/;
4406	4424	stack = newstack;
4407	4425	// set stack-base & callee-address
4408	4426	base = 4/deloffset/;
4409		- label = 313LLU; // reporttype
	4427	+ label = 315LLU; // reporttype
4410	4428	break;
4411	4429	}
4412		- case 320LLU: // copy-back deleter (reporttype to reporttype)
	4430	+ case 324LLU: // copy-back deleter (reporttype to reporttype)
4413	4431	{
4414	4432	fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
4415	4433	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4421,10 +4439,10 @@
4421	4439	}
4422	4440	Free(10LLU + 1, sizeof(uint64_t), stack);
4423	4441	stack = oldstack;
4424		- label = 314LLU; // continue to unroll stack
	4442	+ label = 323LLU; // continue to unroll stack
4425	4443	break;
4426	4444	}
4427		- case 321LLU: // return from reporttype to reporttype
	4445	+ case 325LLU: // return from reporttype to reporttype
4428	4446	{
4429	4447	uint64_t oldstack = (uint64_t )stack[0];
4430	4448	// copy mutable arguments back from call to reporttype

		@@ -4437,15 +4455,21 @@
4437	4455	stack = oldstack;
4438	4456	fprintf(stderr, "%s", "]");
4439	4457	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4440		- label = 315LLU; // case complete
	4458	+ label = 317LLU; // case complete
4441	4459	break;
4442	4460	}
4443		- case 319LLU: // try next case
	4461	+ case 323LLU: // copy-back deleter (switch)
4444	4462	{
	4463	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	4464	+ label = 316LLU; // continue to unroll stack
	4465	+ break;
	4466	+ }
	4467	+ case 322LLU: // try next case
	4468	+ {
4445	4469	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4446	4470	exit(-1);
4447	4471	}
4448		- case 315LLU: // completed switch
	4472	+ case 317LLU: // completed switch
4449	4473	{
4450	4474	// return from reporttype
4451	4475	label = stack[base - 1];

		@@ -4452,7 +4476,7 @@
4452	4476	base = stack[base - 2];
4453	4477	break;
4454	4478	}
4455		- case 323LLU: // function copytype failed
	4479	+ case 327LLU: // function copytype failed
4456	4480	{
4457	4481	fprintf(stderr, "function copytype failed\n");
4458	4482	label = stack[base - 3];

		@@ -4459,13 +4483,13 @@
4459	4483	base = stack[base - 2];
4460	4484	break;
4461	4485	}
4462		- case 322LLU: // copytype
	4486	+ case 326LLU: // copytype
4463	4487	{
4464	4488	//#define res0 0
4465	4489	//#define arg0 1
4466	4490	if(/typename/0 != ((uint64_t )(stack[base + 1]/type*/))[0])
4467	4491	{
4468		- label = 325LLU; // jump to alternative
	4492	+ label = 329LLU; // jump to alternative
4469	4493	break;
4470	4494	}
4471	4495

		@@ -4472,16 +4496,16 @@
4472	4496	/name/stack[base + 2] = ((uint64_t *)(stack[base + 1]/type/))[1][0]/name*/;
4473	4497
4474	4498	// case
4475		- label = 327LLU; // skip deleter
	4499	+ label = 332LLU; // skip deleter
4476	4500	break;
4477	4501	}
4478		- case 326LLU: // deleter
	4502	+ case 331LLU: // deleter
4479	4503	{
4480	4504	// throw from copytype
4481	4505	if(!stack[base + 0])
4482	4506	{
4483	4507	fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4484		- label = 323LLU; // skip, variable already deleted/unscoped
	4508	+ label = 330LLU; // skip, variable already deleted/unscoped
4485	4509	break;
4486	4510	}
4487	4511	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4491,7 +4515,7 @@
4491	4515	newstack[0] = (uint64_t)stack; // backup stack location
4492	4516	newstack[1] = 1234567890;
4493	4517	newstack[2] = base;
4494		- newstack[3] = 328LLU;
	4518	+ newstack[3] = 333LLU;
4495	4519	stack = newstack;
4496	4520	// set stack-base & callee-address
4497	4521	base = 4/deloffset/;

		@@ -4498,21 +4522,21 @@
4498	4522	label = 295LLU; // ~type
4499	4523	break;
4500	4524	}
4501		- case 328LLU: // return from ~type to copytype
	4525	+ case 333LLU: // return from ~type to copytype
4502	4526	{
4503	4527	stack = (uint64_t *)stack[0];
4504	4528	// releasing toplevel container
4505	4529	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4506	4530
4507		- label = 323LLU; // continue unrolling stack, delete next variable
	4531	+ label = 330LLU; // continue unrolling stack, delete next variable
4508	4532	break;
4509	4533	}
4510		- case 327LLU: // skipped deleter
	4534	+ case 332LLU: // skipped deleter
4511	4535	{
4512	4536	// construct type.typename
4513	4537	if(!(stack[base + 0] = construct(1)))
4514	4538	{
4515		- label = 323LLU; // throw: begin to unroll stack
	4539	+ label = 330LLU; // throw: begin to unroll stack
4516	4540	break;
4517	4541	}
4518	4542

		@@ -4520,14 +4544,20 @@
4520	4544	((uint64_t *)stack[base + 0])[0] = 0;
4521	4545	(((uint64_t *)(stack[base + 0]))[1][0]) = stack[base + 2]/name*/;
4522	4546	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4523		- label = 324LLU; // case complete
	4547	+ label = 328LLU; // case complete
4524	4548	break;
4525	4549	}
4526		- case 325LLU: // try next case
	4550	+ case 330LLU: // copy-back deleter (switch)
4527	4551	{
	4552	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	4553	+ label = 327LLU; // continue to unroll stack
	4554	+ break;
	4555	+ }
	4556	+ case 329LLU: // try next case
	4557	+ {
4528	4558	if(/typelist/1 != ((uint64_t )(stack[base + 1]/type*/))[0])
4529	4559	{
4530		- label = 329LLU; // jump to alternative
	4560	+ label = 334LLU; // jump to alternative
4531	4561	break;
4532	4562	}
4533	4563

		@@ -4537,7 +4567,7 @@
4537	4567	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4538	4568	if(!newstack)
4539	4569	{
4540		- label = 323LLU; // throw: begin to unroll stack
	4570	+ label = 335LLU; // throw: begin to unroll stack
4541	4571	break;
4542	4572	}
4543	4573

		@@ -4544,18 +4574,18 @@
4544	4574	newstack[15LLU] = 9876543210LLU; // overflow-marker
4545	4575	// call copytype from copytype
4546	4576	newstack[0] = (uint64_t)stack; // backup stack location
4547		- newstack[1] = 330LLU;
	4577	+ newstack[1] = 336LLU;
4548	4578	newstack[2] = base;
4549		- newstack[3] = 331LLU;
	4579	+ newstack[3] = 337LLU;
4550	4580	// arguments for call to copytype
4551	4581	newstack[5LLU] = stack[base + 2]/original/;
4552	4582	stack = newstack;
4553	4583	// set stack-base & callee-address
4554	4584	base = 4/deloffset/;
4555		- label = 322LLU; // copytype
	4585	+ label = 326LLU; // copytype
4556	4586	break;
4557	4587	}
4558		- case 330LLU: // copy-back deleter (copytype to copytype)
	4588	+ case 336LLU: // copy-back deleter (copytype to copytype)
4559	4589	{
4560	4590	fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
4561	4591	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4567,10 +4597,10 @@
4567	4597	}
4568	4598	Free(15LLU + 1, sizeof(uint64_t), stack);
4569	4599	stack = oldstack;
4570		- label = 323LLU; // continue to unroll stack
	4600	+ label = 335LLU; // continue to unroll stack
4571	4601	break;
4572	4602	}
4573		- case 331LLU: // return from copytype to copytype
	4603	+ case 337LLU: // return from copytype to copytype
4574	4604	{
4575	4605	uint64_t oldstack = (uint64_t )stack[0];
4576	4606	// copy mutable arguments back from call to copytype

		@@ -4583,16 +4613,16 @@
4583	4613	}
4584	4614	Free(15LLU + 1, sizeof(uint64_t), stack);
4585	4615	stack = oldstack;
4586		- label = 333LLU; // skip deleter
	4616	+ label = 339LLU; // skip deleter
4587	4617	break;
4588	4618	}
4589		- case 332LLU: // deleter
	4619	+ case 338LLU: // deleter
4590	4620	{
4591	4621	// throw from copytype
4592	4622	if(!stack[base + 0])
4593	4623	{
4594	4624	fprintf(stderr, "in function copytype: unrolling stack, skipping already deleted/unscoped variable type \n");
4595		- label = 323LLU; // skip, variable already deleted/unscoped
	4625	+ label = 335LLU; // skip, variable already deleted/unscoped
4596	4626	break;
4597	4627	}
4598	4628	fprintf(stderr, "in function copytype: unrolling stack, variable type \n");

		@@ -4602,7 +4632,7 @@
4602	4632	newstack[0] = (uint64_t)stack; // backup stack location
4603	4633	newstack[1] = 1234567890;
4604	4634	newstack[2] = base;
4605		- newstack[3] = 334LLU;
	4635	+ newstack[3] = 340LLU;
4606	4636	stack = newstack;
4607	4637	// set stack-base & callee-address
4608	4638	base = 4/deloffset/;

		@@ -4609,21 +4639,21 @@
4609	4639	label = 295LLU; // ~type
4610	4640	break;
4611	4641	}
4612		- case 334LLU: // return from ~type to copytype
	4642	+ case 340LLU: // return from ~type to copytype
4613	4643	{
4614	4644	stack = (uint64_t *)stack[0];
4615	4645	// releasing toplevel container
4616	4646	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4617	4647
4618		- label = 323LLU; // continue unrolling stack, delete next variable
	4648	+ label = 335LLU; // continue unrolling stack, delete next variable
4619	4649	break;
4620	4650	}
4621		- case 333LLU: // skipped deleter
	4651	+ case 339LLU: // skipped deleter
4622	4652	{
4623	4653	// construct type.typelist
4624	4654	if(!(stack[base + 0] = construct(1)))
4625	4655	{
4626		- label = 323LLU; // throw: begin to unroll stack
	4656	+ label = 335LLU; // throw: begin to unroll stack
4627	4657	break;
4628	4658	}
4629	4659

		@@ -4631,15 +4661,21 @@
4631	4661	((uint64_t *)stack[base + 0])[0] = 1;
4632	4662	INIT(&(((uint64_t *)(stack[base + 0]))[1][0]), &stack[base + 3]/copy*/);
4633	4663	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4634		- label = 324LLU; // case complete
	4664	+ label = 328LLU; // case complete
4635	4665	break;
4636	4666	}
4637		- case 329LLU: // try next case
	4667	+ case 335LLU: // copy-back deleter (switch)
4638	4668	{
	4669	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	4670	+ label = 327LLU; // continue to unroll stack
	4671	+ break;
	4672	+ }
	4673	+ case 334LLU: // try next case
	4674	+ {
4639	4675	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4640	4676	exit(-1);
4641	4677	}
4642		- case 324LLU: // completed switch
	4678	+ case 328LLU: // completed switch
4643	4679	{
4644	4680	// return from copytype
4645	4681	label = stack[base - 1];

		@@ -4646,7 +4682,7 @@
4646	4682	base = stack[base - 2];
4647	4683	break;
4648	4684	}
4649		- case 336LLU: // function equtype failed
	4685	+ case 342LLU: // function equtype failed
4650	4686	{
4651	4687	fprintf(stderr, "function equtype failed\n");
4652	4688	label = stack[base - 3];

		@@ -4653,7 +4689,7 @@
4653	4689	base = stack[base - 2];
4654	4690	break;
4655	4691	}
4656		- case 335LLU: // equtype
	4692	+ case 341LLU: // equtype
4657	4693	{
4658	4694	//#define res0 0
4659	4695	//#define arg0 1

		@@ -4660,7 +4696,7 @@
4660	4696	//#define arg1 2
4661	4697	if(/typename/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
4662	4698	{
4663		- label = 338LLU; // jump to alternative
	4699	+ label = 344LLU; // jump to alternative
4664	4700	break;
4665	4701	}
4666	4702

		@@ -4668,7 +4704,7 @@
4668	4704
4669	4705	if(/typename/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
4670	4706	{
4671		- label = 338LLU; // jump to alternative
	4707	+ label = 344LLU; // jump to alternative
4672	4708	break;
4673	4709	}
4674	4710

		@@ -4676,9 +4712,9 @@
4676	4712
4677	4713	// case
4678	4714	// call equ from equtype
4679		- stack[base + 5LLU] = 339LLU/throw to this address/;
	4715	+ stack[base + 5LLU] = 346LLU/throw to this address/;
4680	4716	stack[base + 6LLU] = base;
4681		- stack[base + 7LLU] = 340LLU;
	4717	+ stack[base + 7LLU] = 347LLU;
4682	4718	// arguments for call to equ
4683	4719	stack[base + 9LLU] = stack[base + 3]/xname/;
4684	4720	stack[base + 10LLU] = stack[base + 4]/yname/;

		@@ -4687,14 +4723,14 @@
4687	4723	label = 18446744073709551600LLU; // equ
4688	4724	break;
4689	4725	}
4690		- case 339LLU: // copy-back deleter (equ to equtype)
	4726	+ case 346LLU: // copy-back deleter (equ to equtype)
4691	4727	{
4692	4728	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
4693	4729	// copy mutable arguments back from call to equ
4694		- label = 336LLU; // continue to roll stack
	4730	+ label = 345LLU; // continue to roll stack
4695	4731	break;
4696	4732	}
4697		- case 340LLU: // return from equ to equtype
	4733	+ case 347LLU: // return from equ to equtype
4698	4734	{
4699	4735	// copy mutable arguments back from call to equ
4700	4736	// copy back results provided by call to equ

		@@ -4701,14 +4737,21 @@
4701	4737	stack[base + 0] = stack[base + 8LLU];
4702	4738	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4703	4739	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4704		- label = 337LLU; // case complete
	4740	+ label = 343LLU; // case complete
4705	4741	break;
4706	4742	}
4707		- case 338LLU: // try next case
	4743	+ case 345LLU: // copy-back deleter (switch)
4708	4744	{
	4745	+ ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
	4746	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
	4747	+ label = 342LLU; // continue to unroll stack
	4748	+ break;
	4749	+ }
	4750	+ case 344LLU: // try next case
	4751	+ {
4709	4752	if(/typelist/1 != ((uint64_t )(stack[base + 1]/x*/))[0])
4710	4753	{
4711		- label = 341LLU; // jump to alternative
	4754	+ label = 348LLU; // jump to alternative
4712	4755	break;
4713	4756	}
4714	4757

		@@ -4716,7 +4759,7 @@
4716	4759
4717	4760	if(/typelist/1 != ((uint64_t )(stack[base + 2]/y*/))[0])
4718	4761	{
4719		- label = 341LLU; // jump to alternative
	4762	+ label = 348LLU; // jump to alternative
4720	4763	break;
4721	4764	}
4722	4765

		@@ -4726,7 +4769,7 @@
4726	4769	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4727	4770	if(!newstack)
4728	4771	{
4729		- label = 336LLU; // throw: begin to unroll stack
	4772	+ label = 349LLU; // throw: begin to unroll stack
4730	4773	break;
4731	4774	}
4732	4775

		@@ -4733,9 +4776,9 @@
4733	4776	newstack[15LLU] = 9876543210LLU; // overflow-marker
4734	4777	// call equtype from equtype
4735	4778	newstack[0] = (uint64_t)stack; // backup stack location
4736		- newstack[1] = 342LLU;
	4779	+ newstack[1] = 350LLU;
4737	4780	newstack[2] = base;
4738		- newstack[3] = 343LLU;
	4781	+ newstack[3] = 351LLU;
4739	4782	// arguments for call to equtype
4740	4783	newstack[5LLU] = stack[base + 3]/xsubtype/;
4741	4784	newstack[6LLU] = stack[base + 4]/ysubtype/;

		@@ -4742,10 +4785,10 @@
4742	4785	stack = newstack;
4743	4786	// set stack-base & callee-address
4744	4787	base = 4/deloffset/;
4745		- label = 335LLU; // equtype
	4788	+ label = 341LLU; // equtype
4746	4789	break;
4747	4790	}
4748		- case 342LLU: // copy-back deleter (equtype to equtype)
	4791	+ case 350LLU: // copy-back deleter (equtype to equtype)
4749	4792	{
4750	4793	fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
4751	4794	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4757,10 +4800,10 @@
4757	4800	}
4758	4801	Free(15LLU + 1, sizeof(uint64_t), stack);
4759	4802	stack = oldstack;
4760		- label = 336LLU; // continue to unroll stack
	4803	+ label = 349LLU; // continue to unroll stack
4761	4804	break;
4762	4805	}
4763		- case 343LLU: // return from equtype to equtype
	4806	+ case 351LLU: // return from equtype to equtype
4764	4807	{
4765	4808	uint64_t oldstack = (uint64_t )stack[0];
4766	4809	// copy mutable arguments back from call to equtype

		@@ -4775,35 +4818,42 @@
4775	4818	stack = oldstack;
4776	4819	((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
4777	4820	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4778		- label = 337LLU; // case complete
	4821	+ label = 343LLU; // case complete
4779	4822	break;
4780	4823	}
4781		- case 341LLU: // try next case
	4824	+ case 349LLU: // copy-back deleter (switch)
4782	4825	{
	4826	+ ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
	4827	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
	4828	+ label = 342LLU; // continue to unroll stack
	4829	+ break;
	4830	+ }
	4831	+ case 348LLU: // try next case
	4832	+ {
4783	4833	// default
4784		- label = 345LLU; // skip deleter
	4834	+ label = 353LLU; // skip deleter
4785	4835	break;
4786	4836	}
4787		- case 344LLU: // deleter
	4837	+ case 352LLU: // deleter
4788	4838	{
4789	4839	// throw from equtype
4790	4840	if(!stack[base + 0])
4791	4841	{
4792	4842	fprintf(stderr, "in function equtype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4793		- label = 336LLU; // skip, variable already deleted/unscoped
	4843	+ label = 342LLU; // skip, variable already deleted/unscoped
4794	4844	break;
4795	4845	}
4796	4846	fprintf(stderr, "in function equtype: unrolling stack, variable u64 \n");
4797		- label = 336LLU; // continue unrolling stack, delete next variable
	4847	+ label = 342LLU; // continue unrolling stack, delete next variable
4798	4848	break;
4799	4849	}
4800		- case 345LLU: // skipped deleter
	4850	+ case 353LLU: // skipped deleter
4801	4851	{
4802	4852	stack[base + 0] = 0;
4803		- label = 337LLU; // default complete
	4853	+ label = 343LLU; // default complete
4804	4854	break;
4805	4855	}
4806		- case 337LLU: // completed switch
	4856	+ case 343LLU: // completed switch
4807	4857	{
4808	4858	// return from equtype
4809	4859	label = stack[base - 1];

		@@ -4810,7 +4860,7 @@
4810	4860	base = stack[base - 2];
4811	4861	break;
4812	4862	}
4813		- case 346LLU: // ~typeid
	4863	+ case 354LLU: // ~typeid
4814	4864	{
4815	4865	if(stack[base + 0]/variant-nr/ >= 1)
4816	4866	{

		@@ -4817,10 +4867,10 @@
4817	4867	fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
4818	4868	exit(-1);
4819	4869	}
4820		- label = 346LLU + 1LLU + stack[base + 0]/variant-nr/;
	4870	+ label = 354LLU + 1LLU + stack[base + 0]/variant-nr/;
4821	4871	break;
4822	4872	}
4823		- case 346LLU + 1LLU + 0LLU: // ~typeid.typeid
	4873	+ case 354LLU + 1LLU + 0LLU: // ~typeid.typeid
4824	4874	{
4825	4875	// release element type
4826	4876	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -4830,7 +4880,7 @@
4830	4880	newstack[0] = (uint64_t)stack; // backup stack location
4831	4881	newstack[1] = 1234567890;
4832	4882	newstack[2] = base;
4833		- newstack[3] = 348LLU;
	4883	+ newstack[3] = 356LLU;
4834	4884	stack = newstack;
4835	4885	// set stack-base & callee-address
4836	4886	base = 4/deloffset/;

		@@ -4837,7 +4887,7 @@
4837	4887	label = 295LLU; // ~type
4838	4888	break;
4839	4889	}
4840		- case 348LLU: // return from ~type to typeid
	4890	+ case 356LLU: // return from ~type to typeid
4841	4891	{
4842	4892	stack = (uint64_t *)stack[0];
4843	4893	// releasing toplevel container

		@@ -4850,7 +4900,7 @@
4850	4900	base = stack[base - 2];
4851	4901	break;
4852	4902	}
4853		- case 350LLU: // function copytypeid failed
	4903	+ case 358LLU: // function copytypeid failed
4854	4904	{
4855	4905	fprintf(stderr, "function copytypeid failed\n");
4856	4906	label = stack[base - 3];

		@@ -4857,13 +4907,13 @@
4857	4907	base = stack[base - 2];
4858	4908	break;
4859	4909	}
4860		- case 349LLU: // copytypeid
	4910	+ case 357LLU: // copytypeid
4861	4911	{
4862	4912	//#define res0 0
4863	4913	//#define arg0 1
4864	4914	if(/typeid/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
4865	4915	{
4866		- label = 352LLU; // jump to alternative
	4916	+ label = 360LLU; // jump to alternative
4867	4917	break;
4868	4918	}
4869	4919

		@@ -4874,7 +4924,7 @@
4874	4924	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
4875	4925	if(!newstack)
4876	4926	{
4877		- label = 350LLU; // throw: begin to unroll stack
	4927	+ label = 361LLU; // throw: begin to unroll stack
4878	4928	break;
4879	4929	}
4880	4930

		@@ -4881,18 +4931,18 @@
4881	4931	newstack[15LLU] = 9876543210LLU; // overflow-marker
4882	4932	// call copytype from copytypeid
4883	4933	newstack[0] = (uint64_t)stack; // backup stack location
4884		- newstack[1] = 353LLU;
	4934	+ newstack[1] = 362LLU;
4885	4935	newstack[2] = base;
4886		- newstack[3] = 354LLU;
	4936	+ newstack[3] = 363LLU;
4887	4937	// arguments for call to copytype
4888	4938	newstack[5LLU] = stack[base + 2]/origtype/;
4889	4939	stack = newstack;
4890	4940	// set stack-base & callee-address
4891	4941	base = 4/deloffset/;
4892		- label = 322LLU; // copytype
	4942	+ label = 326LLU; // copytype
4893	4943	break;
4894	4944	}
4895		- case 353LLU: // copy-back deleter (copytype to copytypeid)
	4945	+ case 362LLU: // copy-back deleter (copytype to copytypeid)
4896	4946	{
4897	4947	fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
4898	4948	uint64_t oldstack = (uint64_t )stack[0];

		@@ -4904,10 +4954,10 @@
4904	4954	}
4905	4955	Free(15LLU + 1, sizeof(uint64_t), stack);
4906	4956	stack = oldstack;
4907		- label = 350LLU; // continue to unroll stack
	4957	+ label = 361LLU; // continue to unroll stack
4908	4958	break;
4909	4959	}
4910		- case 354LLU: // return from copytype to copytypeid
	4960	+ case 363LLU: // return from copytype to copytypeid
4911	4961	{
4912	4962	uint64_t oldstack = (uint64_t )stack[0];
4913	4963	// copy mutable arguments back from call to copytype

		@@ -4920,35 +4970,35 @@
4920	4970	}
4921	4971	Free(15LLU + 1, sizeof(uint64_t), stack);
4922	4972	stack = oldstack;
4923		- label = 356LLU; // skip deleter
	4973	+ label = 365LLU; // skip deleter
4924	4974	break;
4925	4975	}
4926		- case 355LLU: // deleter
	4976	+ case 364LLU: // deleter
4927	4977	{
4928	4978	// throw from copytypeid
4929	4979	if(!stack[base + 5])
4930	4980	{
4931	4981	fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable u64 \n");
4932		- label = 350LLU; // skip, variable already deleted/unscoped
	4982	+ label = 361LLU; // skip, variable already deleted/unscoped
4933	4983	break;
4934	4984	}
4935	4985	fprintf(stderr, "in function copytypeid: unrolling stack, variable u64 \n");
4936		- label = 350LLU; // continue unrolling stack, delete next variable
	4986	+ label = 361LLU; // continue unrolling stack, delete next variable
4937	4987	break;
4938	4988	}
4939		- case 356LLU: // skipped deleter
	4989	+ case 365LLU: // skipped deleter
4940	4990	{
4941	4991	stack[base + 5] = stack[base + 3]/origid/;
4942		- label = 358LLU; // skip deleter
	4992	+ label = 367LLU; // skip deleter
4943	4993	break;
4944	4994	}
4945		- case 357LLU: // deleter
	4995	+ case 366LLU: // deleter
4946	4996	{
4947	4997	// throw from copytypeid
4948	4998	if(!stack[base + 0])
4949	4999	{
4950	5000	fprintf(stderr, "in function copytypeid: unrolling stack, skipping already deleted/unscoped variable typeid \n");
4951		- label = 355LLU; // skip, variable already deleted/unscoped
	5001	+ label = 364LLU; // skip, variable already deleted/unscoped
4952	5002	break;
4953	5003	}
4954	5004	fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");

		@@ -4958,28 +5008,28 @@
4958	5008	newstack[0] = (uint64_t)stack; // backup stack location
4959	5009	newstack[1] = 1234567890;
4960	5010	newstack[2] = base;
4961		- newstack[3] = 359LLU;
	5011	+ newstack[3] = 368LLU;
4962	5012	stack = newstack;
4963	5013	// set stack-base & callee-address
4964	5014	base = 4/deloffset/;
4965		- label = 346LLU; // ~typeid
	5015	+ label = 354LLU; // ~typeid
4966	5016	break;
4967	5017	}
4968		- case 359LLU: // return from ~typeid to copytypeid
	5018	+ case 368LLU: // return from ~typeid to copytypeid
4969	5019	{
4970	5020	stack = (uint64_t *)stack[0];
4971	5021	// releasing toplevel container
4972	5022	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
4973	5023
4974		- label = 355LLU; // continue unrolling stack, delete next variable
	5024	+ label = 364LLU; // continue unrolling stack, delete next variable
4975	5025	break;
4976	5026	}
4977		- case 358LLU: // skipped deleter
	5027	+ case 367LLU: // skipped deleter
4978	5028	{
4979	5029	// construct typeid.typeid
4980	5030	if(!(stack[base + 0] = construct(2)))
4981	5031	{
4982		- label = 355LLU; // throw: begin to unroll stack
	5032	+ label = 364LLU; // throw: begin to unroll stack
4983	5033	break;
4984	5034	}
4985	5035

		@@ -4989,15 +5039,22 @@
4989	5039	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copyid*/;
4990	5040	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
4991	5041	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4992		- label = 351LLU; // case complete
	5042	+ label = 359LLU; // case complete
4993	5043	break;
4994	5044	}
4995		- case 352LLU: // try next case
	5045	+ case 361LLU: // copy-back deleter (switch)
4996	5046	{
	5047	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	5048	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	5049	+ label = 358LLU; // continue to unroll stack
	5050	+ break;
	5051	+ }
	5052	+ case 360LLU: // try next case
	5053	+ {
4997	5054	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
4998	5055	exit(-1);
4999	5056	}
5000		- case 351LLU: // completed switch
	5057	+ case 359LLU: // completed switch
5001	5058	{
5002	5059	// return from copytypeid
5003	5060	label = stack[base - 1];

		@@ -5004,7 +5061,7 @@
5004	5061	base = stack[base - 2];
5005	5062	break;
5006	5063	}
5007		- case 361LLU: // function reportti failed
	5064	+ case 370LLU: // function reportti failed
5008	5065	{
5009	5066	fprintf(stderr, "function reportti failed\n");
5010	5067	label = stack[base - 3];

		@@ -5011,12 +5068,12 @@
5011	5068	base = stack[base - 2];
5012	5069	break;
5013	5070	}
5014		- case 360LLU: // reportti
	5071	+ case 369LLU: // reportti
5015	5072	{
5016	5073	//#define arg0 0
5017	5074	if(/typeid/0 != ((uint64_t )(stack[base + 0]/typeid*/))[0])
5018	5075	{
5019		- label = 363LLU; // jump to alternative
	5076	+ label = 372LLU; // jump to alternative
5020	5077	break;
5021	5078	}
5022	5079

		@@ -5027,7 +5084,7 @@
5027	5084	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5028	5085	if(!newstack)
5029	5086	{
5030		- label = 361LLU; // throw: begin to unroll stack
	5087	+ label = 373LLU; // throw: begin to unroll stack
5031	5088	break;
5032	5089	}
5033	5090

		@@ -5034,18 +5091,18 @@
5034	5091	newstack[10LLU] = 9876543210LLU; // overflow-marker
5035	5092	// call reporttype from reportti
5036	5093	newstack[0] = (uint64_t)stack; // backup stack location
5037		- newstack[1] = 364LLU;
	5094	+ newstack[1] = 374LLU;
5038	5095	newstack[2] = base;
5039		- newstack[3] = 365LLU;
	5096	+ newstack[3] = 375LLU;
5040	5097	// arguments for call to reporttype
5041	5098	newstack[4LLU] = stack[base + 1]/type/;
5042	5099	stack = newstack;
5043	5100	// set stack-base & callee-address
5044	5101	base = 4/deloffset/;
5045		- label = 313LLU; // reporttype
	5102	+ label = 315LLU; // reporttype
5046	5103	break;
5047	5104	}
5048		- case 364LLU: // copy-back deleter (reporttype to reportti)
	5105	+ case 374LLU: // copy-back deleter (reporttype to reportti)
5049	5106	{
5050	5107	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
5051	5108	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5057,10 +5114,10 @@
5057	5114	}
5058	5115	Free(10LLU + 1, sizeof(uint64_t), stack);
5059	5116	stack = oldstack;
5060		- label = 361LLU; // continue to unroll stack
	5117	+ label = 373LLU; // continue to unroll stack
5061	5118	break;
5062	5119	}
5063		- case 365LLU: // return from reporttype to reportti
	5120	+ case 375LLU: // return from reporttype to reportti
5064	5121	{
5065	5122	uint64_t oldstack = (uint64_t )stack[0];
5066	5123	// copy mutable arguments back from call to reporttype

		@@ -5073,9 +5130,9 @@
5073	5130	stack = oldstack;
5074	5131	fprintf(stderr, "%s", " ");
5075	5132	// call reportid from reportti
5076		- stack[base + 3LLU] = 366LLU/throw to this address/;
	5133	+ stack[base + 3LLU] = 376LLU/throw to this address/;
5077	5134	stack[base + 4LLU] = base;
5078		- stack[base + 5LLU] = 367LLU;
	5135	+ stack[base + 5LLU] = 377LLU;
5079	5136	// arguments for call to reportid
5080	5137	stack[base + 6LLU] = stack[base + 2]/id/;
5081	5138	// set stack-base & callee-address

		@@ -5083,27 +5140,34 @@
5083	5140	label = 18446744073709551586LLU; // reportid
5084	5141	break;
5085	5142	}
5086		- case 366LLU: // copy-back deleter (reportid to reportti)
	5143	+ case 376LLU: // copy-back deleter (reportid to reportti)
5087	5144	{
5088	5145	fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
5089	5146	// copy mutable arguments back from call to reportid
5090		- label = 361LLU; // continue to roll stack
	5147	+ label = 373LLU; // continue to roll stack
5091	5148	break;
5092	5149	}
5093		- case 367LLU: // return from reportid to reportti
	5150	+ case 377LLU: // return from reportid to reportti
5094	5151	{
5095	5152	// copy mutable arguments back from call to reportid
5096	5153	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5097	5154	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5098		- label = 362LLU; // case complete
	5155	+ label = 371LLU; // case complete
5099	5156	break;
5100	5157	}
5101		- case 363LLU: // try next case
	5158	+ case 373LLU: // copy-back deleter (switch)
5102	5159	{
	5160	+ ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
	5161	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	5162	+ label = 370LLU; // continue to unroll stack
	5163	+ break;
	5164	+ }
	5165	+ case 372LLU: // try next case
	5166	+ {
5103	5167	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5104	5168	exit(-1);
5105	5169	}
5106		- case 362LLU: // completed switch
	5170	+ case 371LLU: // completed switch
5107	5171	{
5108	5172	// return from reportti
5109	5173	label = stack[base - 1];

		@@ -5110,7 +5174,7 @@
5110	5174	base = stack[base - 2];
5111	5175	break;
5112	5176	}
5113		- case 368LLU: // ~typeidx
	5177	+ case 378LLU: // ~typeidx
5114	5178	{
5115	5179	if(stack[base + 0]/variant-nr/ >= 1)
5116	5180	{

		@@ -5117,10 +5181,10 @@
5117	5181	fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5118	5182	exit(-1);
5119	5183	}
5120		- label = 368LLU + 1LLU + stack[base + 0]/variant-nr/;
	5184	+ label = 378LLU + 1LLU + stack[base + 0]/variant-nr/;
5121	5185	break;
5122	5186	}
5123		- case 368LLU + 1LLU + 0LLU: // ~typeidx.typeidx
	5187	+ case 378LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5124	5188	{
5125	5189	// release element type
5126	5190	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5130,7 +5194,7 @@
5130	5194	newstack[0] = (uint64_t)stack; // backup stack location
5131	5195	newstack[1] = 1234567890;
5132	5196	newstack[2] = base;
5133		- newstack[3] = 370LLU;
	5197	+ newstack[3] = 380LLU;
5134	5198	stack = newstack;
5135	5199	// set stack-base & callee-address
5136	5200	base = 4/deloffset/;

		@@ -5137,7 +5201,7 @@
5137	5201	label = 295LLU; // ~type
5138	5202	break;
5139	5203	}
5140		- case 370LLU: // return from ~type to typeidx
	5204	+ case 380LLU: // return from ~type to typeidx
5141	5205	{
5142	5206	stack = (uint64_t *)stack[0];
5143	5207	// releasing toplevel container

		@@ -5150,7 +5214,7 @@
5150	5214	base = stack[base - 2];
5151	5215	break;
5152	5216	}
5153		- case 372LLU: // function cptypeidx failed
	5217	+ case 382LLU: // function cptypeidx failed
5154	5218	{
5155	5219	fprintf(stderr, "function cptypeidx failed\n");
5156	5220	label = stack[base - 3];

		@@ -5157,13 +5221,13 @@
5157	5221	base = stack[base - 2];
5158	5222	break;
5159	5223	}
5160		- case 371LLU: // cptypeidx
	5224	+ case 381LLU: // cptypeidx
5161	5225	{
5162	5226	//#define res0 0
5163	5227	//#define arg0 1
5164	5228	if(/typeidx/0 != ((uint64_t )(stack[base + 1]/orig*/))[0])
5165	5229	{
5166		- label = 374LLU; // jump to alternative
	5230	+ label = 384LLU; // jump to alternative
5167	5231	break;
5168	5232	}
5169	5233

		@@ -5174,7 +5238,7 @@
5174	5238	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5175	5239	if(!newstack)
5176	5240	{
5177		- label = 372LLU; // throw: begin to unroll stack
	5241	+ label = 385LLU; // throw: begin to unroll stack
5178	5242	break;
5179	5243	}
5180	5244

		@@ -5181,18 +5245,18 @@
5181	5245	newstack[15LLU] = 9876543210LLU; // overflow-marker
5182	5246	// call copytype from cptypeidx
5183	5247	newstack[0] = (uint64_t)stack; // backup stack location
5184		- newstack[1] = 375LLU;
	5248	+ newstack[1] = 386LLU;
5185	5249	newstack[2] = base;
5186		- newstack[3] = 376LLU;
	5250	+ newstack[3] = 387LLU;
5187	5251	// arguments for call to copytype
5188	5252	newstack[5LLU] = stack[base + 2]/otype/;
5189	5253	stack = newstack;
5190	5254	// set stack-base & callee-address
5191	5255	base = 4/deloffset/;
5192		- label = 322LLU; // copytype
	5256	+ label = 326LLU; // copytype
5193	5257	break;
5194	5258	}
5195		- case 375LLU: // copy-back deleter (copytype to cptypeidx)
	5259	+ case 386LLU: // copy-back deleter (copytype to cptypeidx)
5196	5260	{
5197	5261	fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
5198	5262	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5204,10 +5268,10 @@
5204	5268	}
5205	5269	Free(15LLU + 1, sizeof(uint64_t), stack);
5206	5270	stack = oldstack;
5207		- label = 372LLU; // continue to unroll stack
	5271	+ label = 385LLU; // continue to unroll stack
5208	5272	break;
5209	5273	}
5210		- case 376LLU: // return from copytype to cptypeidx
	5274	+ case 387LLU: // return from copytype to cptypeidx
5211	5275	{
5212	5276	uint64_t oldstack = (uint64_t )stack[0];
5213	5277	// copy mutable arguments back from call to copytype

		@@ -5220,35 +5284,35 @@
5220	5284	}
5221	5285	Free(15LLU + 1, sizeof(uint64_t), stack);
5222	5286	stack = oldstack;
5223		- label = 378LLU; // skip deleter
	5287	+ label = 389LLU; // skip deleter
5224	5288	break;
5225	5289	}
5226		- case 377LLU: // deleter
	5290	+ case 388LLU: // deleter
5227	5291	{
5228	5292	// throw from cptypeidx
5229	5293	if(!stack[base + 5])
5230	5294	{
5231	5295	fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5232		- label = 372LLU; // skip, variable already deleted/unscoped
	5296	+ label = 385LLU; // skip, variable already deleted/unscoped
5233	5297	break;
5234	5298	}
5235	5299	fprintf(stderr, "in function cptypeidx: unrolling stack, variable u64 \n");
5236		- label = 372LLU; // continue unrolling stack, delete next variable
	5300	+ label = 385LLU; // continue unrolling stack, delete next variable
5237	5301	break;
5238	5302	}
5239		- case 378LLU: // skipped deleter
	5303	+ case 389LLU: // skipped deleter
5240	5304	{
5241	5305	stack[base + 5] = stack[base + 3]/oidx/;
5242		- label = 380LLU; // skip deleter
	5306	+ label = 391LLU; // skip deleter
5243	5307	break;
5244	5308	}
5245		- case 379LLU: // deleter
	5309	+ case 390LLU: // deleter
5246	5310	{
5247	5311	// throw from cptypeidx
5248	5312	if(!stack[base + 0])
5249	5313	{
5250	5314	fprintf(stderr, "in function cptypeidx: unrolling stack, skipping already deleted/unscoped variable typeidx \n");
5251		- label = 377LLU; // skip, variable already deleted/unscoped
	5315	+ label = 388LLU; // skip, variable already deleted/unscoped
5252	5316	break;
5253	5317	}
5254	5318	fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");

		@@ -5258,28 +5322,28 @@
5258	5322	newstack[0] = (uint64_t)stack; // backup stack location
5259	5323	newstack[1] = 1234567890;
5260	5324	newstack[2] = base;
5261		- newstack[3] = 381LLU;
	5325	+ newstack[3] = 392LLU;
5262	5326	stack = newstack;
5263	5327	// set stack-base & callee-address
5264	5328	base = 4/deloffset/;
5265		- label = 368LLU; // ~typeidx
	5329	+ label = 378LLU; // ~typeidx
5266	5330	break;
5267	5331	}
5268		- case 381LLU: // return from ~typeidx to cptypeidx
	5332	+ case 392LLU: // return from ~typeidx to cptypeidx
5269	5333	{
5270	5334	stack = (uint64_t *)stack[0];
5271	5335	// releasing toplevel container
5272	5336	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5273	5337
5274		- label = 377LLU; // continue unrolling stack, delete next variable
	5338	+ label = 388LLU; // continue unrolling stack, delete next variable
5275	5339	break;
5276	5340	}
5277		- case 380LLU: // skipped deleter
	5341	+ case 391LLU: // skipped deleter
5278	5342	{
5279	5343	// construct typeidx.typeidx
5280	5344	if(!(stack[base + 0] = construct(2)))
5281	5345	{
5282		- label = 377LLU; // throw: begin to unroll stack
	5346	+ label = 388LLU; // throw: begin to unroll stack
5283	5347	break;
5284	5348	}
5285	5349

		@@ -5289,15 +5353,22 @@
5289	5353	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/cidx*/;
5290	5354	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5291	5355	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5292		- label = 373LLU; // case complete
	5356	+ label = 383LLU; // case complete
5293	5357	break;
5294	5358	}
5295		- case 374LLU: // try next case
	5359	+ case 385LLU: // copy-back deleter (switch)
5296	5360	{
	5361	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	5362	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	5363	+ label = 382LLU; // continue to unroll stack
	5364	+ break;
	5365	+ }
	5366	+ case 384LLU: // try next case
	5367	+ {
5297	5368	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5298	5369	exit(-1);
5299	5370	}
5300		- case 373LLU: // completed switch
	5371	+ case 383LLU: // completed switch
5301	5372	{
5302	5373	// return from cptypeidx
5303	5374	label = stack[base - 1];

		@@ -5304,7 +5375,7 @@
5304	5375	base = stack[base - 2];
5305	5376	break;
5306	5377	}
5307		- case 382LLU: // ~result
	5378	+ case 393LLU: // ~result
5308	5379	{
5309	5380	if(stack[base + 0]/variant-nr/ >= 1)
5310	5381	{

		@@ -5311,10 +5382,10 @@
5311	5382	fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5312	5383	exit(-1);
5313	5384	}
5314		- label = 382LLU + 1LLU + stack[base + 0]/variant-nr/;
	5385	+ label = 393LLU + 1LLU + stack[base + 0]/variant-nr/;
5315	5386	break;
5316	5387	}
5317		- case 382LLU + 1LLU + 0LLU: // ~result.result
	5388	+ case 393LLU + 1LLU + 0LLU: // ~result.result
5318	5389	{
5319	5390	// release element type
5320	5391	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5324,7 +5395,7 @@
5324	5395	newstack[0] = (uint64_t)stack; // backup stack location
5325	5396	newstack[1] = 1234567890;
5326	5397	newstack[2] = base;
5327		- newstack[3] = 384LLU;
	5398	+ newstack[3] = 395LLU;
5328	5399	stack = newstack;
5329	5400	// set stack-base & callee-address
5330	5401	base = 4/deloffset/;

		@@ -5331,7 +5402,7 @@
5331	5402	label = 295LLU; // ~type
5332	5403	break;
5333	5404	}
5334		- case 384LLU: // return from ~type to result
	5405	+ case 395LLU: // return from ~type to result
5335	5406	{
5336	5407	stack = (uint64_t *)stack[0];
5337	5408	// releasing toplevel container

		@@ -5344,7 +5415,7 @@
5344	5415	base = stack[base - 2];
5345	5416	break;
5346	5417	}
5347		- case 386LLU: // function copyresult failed
	5418	+ case 397LLU: // function copyresult failed
5348	5419	{
5349	5420	fprintf(stderr, "function copyresult failed\n");
5350	5421	label = stack[base - 3];

		@@ -5351,13 +5422,13 @@
5351	5422	base = stack[base - 2];
5352	5423	break;
5353	5424	}
5354		- case 385LLU: // copyresult
	5425	+ case 396LLU: // copyresult
5355	5426	{
5356	5427	//#define res0 0
5357	5428	//#define arg0 1
5358	5429	if(/result/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5359	5430	{
5360		- label = 388LLU; // jump to alternative
	5431	+ label = 399LLU; // jump to alternative
5361	5432	break;
5362	5433	}
5363	5434

		@@ -5368,7 +5439,7 @@
5368	5439	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
5369	5440	if(!newstack)
5370	5441	{
5371		- label = 386LLU; // throw: begin to unroll stack
	5442	+ label = 400LLU; // throw: begin to unroll stack
5372	5443	break;
5373	5444	}
5374	5445

		@@ -5375,18 +5446,18 @@
5375	5446	newstack[15LLU] = 9876543210LLU; // overflow-marker
5376	5447	// call copytype from copyresult
5377	5448	newstack[0] = (uint64_t)stack; // backup stack location
5378		- newstack[1] = 389LLU;
	5449	+ newstack[1] = 401LLU;
5379	5450	newstack[2] = base;
5380		- newstack[3] = 390LLU;
	5451	+ newstack[3] = 402LLU;
5381	5452	// arguments for call to copytype
5382	5453	newstack[5LLU] = stack[base + 2]/origtype/;
5383	5454	stack = newstack;
5384	5455	// set stack-base & callee-address
5385	5456	base = 4/deloffset/;
5386		- label = 322LLU; // copytype
	5457	+ label = 326LLU; // copytype
5387	5458	break;
5388	5459	}
5389		- case 389LLU: // copy-back deleter (copytype to copyresult)
	5460	+ case 401LLU: // copy-back deleter (copytype to copyresult)
5390	5461	{
5391	5462	fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
5392	5463	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5398,10 +5469,10 @@
5398	5469	}
5399	5470	Free(15LLU + 1, sizeof(uint64_t), stack);
5400	5471	stack = oldstack;
5401		- label = 386LLU; // continue to unroll stack
	5472	+ label = 400LLU; // continue to unroll stack
5402	5473	break;
5403	5474	}
5404		- case 390LLU: // return from copytype to copyresult
	5475	+ case 402LLU: // return from copytype to copyresult
5405	5476	{
5406	5477	uint64_t oldstack = (uint64_t )stack[0];
5407	5478	// copy mutable arguments back from call to copytype

		@@ -5414,16 +5485,16 @@
5414	5485	}
5415	5486	Free(15LLU + 1, sizeof(uint64_t), stack);
5416	5487	stack = oldstack;
5417		- label = 392LLU; // skip deleter
	5488	+ label = 404LLU; // skip deleter
5418	5489	break;
5419	5490	}
5420		- case 391LLU: // deleter
	5491	+ case 403LLU: // deleter
5421	5492	{
5422	5493	// throw from copyresult
5423	5494	if(!stack[base + 0])
5424	5495	{
5425	5496	fprintf(stderr, "in function copyresult: unrolling stack, skipping already deleted/unscoped variable result \n");
5426		- label = 386LLU; // skip, variable already deleted/unscoped
	5497	+ label = 400LLU; // skip, variable already deleted/unscoped
5427	5498	break;
5428	5499	}
5429	5500	fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");

		@@ -5433,28 +5504,28 @@
5433	5504	newstack[0] = (uint64_t)stack; // backup stack location
5434	5505	newstack[1] = 1234567890;
5435	5506	newstack[2] = base;
5436		- newstack[3] = 393LLU;
	5507	+ newstack[3] = 405LLU;
5437	5508	stack = newstack;
5438	5509	// set stack-base & callee-address
5439	5510	base = 4/deloffset/;
5440		- label = 382LLU; // ~result
	5511	+ label = 393LLU; // ~result
5441	5512	break;
5442	5513	}
5443		- case 393LLU: // return from ~result to copyresult
	5514	+ case 405LLU: // return from ~result to copyresult
5444	5515	{
5445	5516	stack = (uint64_t *)stack[0];
5446	5517	// releasing toplevel container
5447	5518	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5448	5519
5449		- label = 386LLU; // continue unrolling stack, delete next variable
	5520	+ label = 400LLU; // continue unrolling stack, delete next variable
5450	5521	break;
5451	5522	}
5452		- case 392LLU: // skipped deleter
	5523	+ case 404LLU: // skipped deleter
5453	5524	{
5454	5525	// construct result.result
5455	5526	if(!(stack[base + 0] = construct(2)))
5456	5527	{
5457		- label = 386LLU; // throw: begin to unroll stack
	5528	+ label = 400LLU; // throw: begin to unroll stack
5458	5529	break;
5459	5530	}
5460	5531

		@@ -5464,15 +5535,22 @@
5464	5535	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 3]/RESERVED*/;
5465	5536	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5466	5537	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5467		- label = 387LLU; // case complete
	5538	+ label = 398LLU; // case complete
5468	5539	break;
5469	5540	}
5470		- case 388LLU: // try next case
	5541	+ case 400LLU: // copy-back deleter (switch)
5471	5542	{
	5543	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	5544	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	5545	+ label = 397LLU; // continue to unroll stack
	5546	+ break;
	5547	+ }
	5548	+ case 399LLU: // try next case
	5549	+ {
5472	5550	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5473	5551	exit(-1);
5474	5552	}
5475		- case 387LLU: // completed switch
	5553	+ case 398LLU: // completed switch
5476	5554	{
5477	5555	// return from copyresult
5478	5556	label = stack[base - 1];

		@@ -5479,7 +5557,7 @@
5479	5557	base = stack[base - 2];
5480	5558	break;
5481	5559	}
5482		- case 395LLU: // function represult failed
	5560	+ case 407LLU: // function represult failed
5483	5561	{
5484	5562	fprintf(stderr, "function represult failed\n");
5485	5563	label = stack[base - 3];

		@@ -5486,12 +5564,12 @@
5486	5564	base = stack[base - 2];
5487	5565	break;
5488	5566	}
5489		- case 394LLU: // represult
	5567	+ case 406LLU: // represult
5490	5568	{
5491	5569	//#define arg0 0
5492	5570	if(/result/0 != ((uint64_t )(stack[base + 0]/result*/))[0])
5493	5571	{
5494		- label = 397LLU; // jump to alternative
	5572	+ label = 409LLU; // jump to alternative
5495	5573	break;
5496	5574	}
5497	5575

		@@ -5502,7 +5580,7 @@
5502	5580	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
5503	5581	if(!newstack)
5504	5582	{
5505		- label = 395LLU; // throw: begin to unroll stack
	5583	+ label = 410LLU; // throw: begin to unroll stack
5506	5584	break;
5507	5585	}
5508	5586

		@@ -5509,18 +5587,18 @@
5509	5587	newstack[10LLU] = 9876543210LLU; // overflow-marker
5510	5588	// call reporttype from represult
5511	5589	newstack[0] = (uint64_t)stack; // backup stack location
5512		- newstack[1] = 398LLU;
	5590	+ newstack[1] = 411LLU;
5513	5591	newstack[2] = base;
5514		- newstack[3] = 399LLU;
	5592	+ newstack[3] = 412LLU;
5515	5593	// arguments for call to reporttype
5516	5594	newstack[4LLU] = stack[base + 1]/type/;
5517	5595	stack = newstack;
5518	5596	// set stack-base & callee-address
5519	5597	base = 4/deloffset/;
5520		- label = 313LLU; // reporttype
	5598	+ label = 315LLU; // reporttype
5521	5599	break;
5522	5600	}
5523		- case 398LLU: // copy-back deleter (reporttype to represult)
	5601	+ case 411LLU: // copy-back deleter (reporttype to represult)
5524	5602	{
5525	5603	fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
5526	5604	uint64_t oldstack = (uint64_t )stack[0];

		@@ -5532,10 +5610,10 @@
5532	5610	}
5533	5611	Free(10LLU + 1, sizeof(uint64_t), stack);
5534	5612	stack = oldstack;
5535		- label = 395LLU; // continue to unroll stack
	5613	+ label = 410LLU; // continue to unroll stack
5536	5614	break;
5537	5615	}
5538		- case 399LLU: // return from reporttype to represult
	5616	+ case 412LLU: // return from reporttype to represult
5539	5617	{
5540	5618	uint64_t oldstack = (uint64_t )stack[0];
5541	5619	// copy mutable arguments back from call to reporttype

		@@ -5548,15 +5626,22 @@
5548	5626	stack = oldstack;
5549	5627	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5550	5628	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5551		- label = 396LLU; // case complete
	5629	+ label = 408LLU; // case complete
5552	5630	break;
5553	5631	}
5554		- case 397LLU: // try next case
	5632	+ case 410LLU: // copy-back deleter (switch)
5555	5633	{
	5634	+ ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
	5635	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	5636	+ label = 407LLU; // continue to unroll stack
	5637	+ break;
	5638	+ }
	5639	+ case 409LLU: // try next case
	5640	+ {
5556	5641	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5557	5642	exit(-1);
5558	5643	}
5559		- case 396LLU: // completed switch
	5644	+ case 408LLU: // completed switch
5560	5645	{
5561	5646	// return from represult
5562	5647	label = stack[base - 1];

		@@ -5563,7 +5648,7 @@
5563	5648	base = stack[base - 2];
5564	5649	break;
5565	5650	}
5566		- case 400LLU: // ~param
	5651	+ case 413LLU: // ~param
5567	5652	{
5568	5653	if(stack[base + 0]/variant-nr/ >= 1)
5569	5654	{

		@@ -5570,10 +5655,10 @@
5570	5655	fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5571	5656	exit(-1);
5572	5657	}
5573		- label = 400LLU + 1LLU + stack[base + 0]/variant-nr/;
	5658	+ label = 413LLU + 1LLU + stack[base + 0]/variant-nr/;
5574	5659	break;
5575	5660	}
5576		- case 400LLU + 1LLU + 0LLU: // ~param.param
	5661	+ case 413LLU + 1LLU + 0LLU: // ~param.param
5577	5662	{
5578	5663	// release element typeid
5579	5664	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5583,14 +5668,14 @@
5583	5668	newstack[0] = (uint64_t)stack; // backup stack location
5584	5669	newstack[1] = 1234567890;
5585	5670	newstack[2] = base;
5586		- newstack[3] = 402LLU;
	5671	+ newstack[3] = 415LLU;
5587	5672	stack = newstack;
5588	5673	// set stack-base & callee-address
5589	5674	base = 4/deloffset/;
5590		- label = 346LLU; // ~typeid
	5675	+ label = 354LLU; // ~typeid
5591	5676	break;
5592	5677	}
5593		- case 402LLU: // return from ~typeid to param
	5678	+ case 415LLU: // return from ~typeid to param
5594	5679	{
5595	5680	stack = (uint64_t *)stack[0];
5596	5681	// releasing toplevel container

		@@ -5603,7 +5688,7 @@
5603	5688	base = stack[base - 2];
5604	5689	break;
5605	5690	}
5606		- case 404LLU: // function copyparam failed
	5691	+ case 417LLU: // function copyparam failed
5607	5692	{
5608	5693	fprintf(stderr, "function copyparam failed\n");
5609	5694	label = stack[base - 3];

		@@ -5610,13 +5695,13 @@
5610	5695	base = stack[base - 2];
5611	5696	break;
5612	5697	}
5613		- case 403LLU: // copyparam
	5698	+ case 416LLU: // copyparam
5614	5699	{
5615	5700	//#define res0 0
5616	5701	//#define arg0 1
5617	5702	if(/param/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
5618	5703	{
5619		- label = 406LLU; // jump to alternative
	5704	+ label = 419LLU; // jump to alternative
5620	5705	break;
5621	5706	}
5622	5707

		@@ -5625,57 +5710,57 @@
5625	5710
5626	5711	// case
5627	5712	// call copytypeid from copyparam
5628		- stack[base + 5LLU] = 407LLU/throw to this address/;
	5713	+ stack[base + 5LLU] = 421LLU/throw to this address/;
5629	5714	stack[base + 6LLU] = base;
5630		- stack[base + 7LLU] = 408LLU;
	5715	+ stack[base + 7LLU] = 422LLU;
5631	5716	// arguments for call to copytypeid
5632	5717	stack[base + 9LLU] = stack[base + 2]/origtypeid/;
5633	5718	// set stack-base & callee-address
5634	5719	base += 8LLU;
5635		- label = 349LLU; // copytypeid
	5720	+ label = 357LLU; // copytypeid
5636	5721	break;
5637	5722	}
5638		- case 407LLU: // copy-back deleter (copytypeid to copyparam)
	5723	+ case 421LLU: // copy-back deleter (copytypeid to copyparam)
5639	5724	{
5640	5725	fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
5641	5726	// copy mutable arguments back from call to copytypeid
5642		- label = 404LLU; // continue to roll stack
	5727	+ label = 420LLU; // continue to roll stack
5643	5728	break;
5644	5729	}
5645		- case 408LLU: // return from copytypeid to copyparam
	5730	+ case 422LLU: // return from copytypeid to copyparam
5646	5731	{
5647	5732	// copy mutable arguments back from call to copytypeid
5648	5733	// copy back results provided by call to copytypeid
5649	5734	stack[base + 4] = stack[base + 8LLU];
5650		- label = 410LLU; // skip deleter
	5735	+ label = 424LLU; // skip deleter
5651	5736	break;
5652	5737	}
5653		- case 409LLU: // deleter
	5738	+ case 423LLU: // deleter
5654	5739	{
5655	5740	// throw from copyparam
5656	5741	if(!stack[base + 5])
5657	5742	{
5658	5743	fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5659		- label = 404LLU; // skip, variable already deleted/unscoped
	5744	+ label = 420LLU; // skip, variable already deleted/unscoped
5660	5745	break;
5661	5746	}
5662	5747	fprintf(stderr, "in function copyparam: unrolling stack, variable u64 \n");
5663		- label = 404LLU; // continue unrolling stack, delete next variable
	5748	+ label = 420LLU; // continue unrolling stack, delete next variable
5664	5749	break;
5665	5750	}
5666		- case 410LLU: // skipped deleter
	5751	+ case 424LLU: // skipped deleter
5667	5752	{
5668	5753	stack[base + 5] = stack[base + 3]/origmut/;
5669		- label = 412LLU; // skip deleter
	5754	+ label = 426LLU; // skip deleter
5670	5755	break;
5671	5756	}
5672		- case 411LLU: // deleter
	5757	+ case 425LLU: // deleter
5673	5758	{
5674	5759	// throw from copyparam
5675	5760	if(!stack[base + 0])
5676	5761	{
5677	5762	fprintf(stderr, "in function copyparam: unrolling stack, skipping already deleted/unscoped variable param \n");
5678		- label = 409LLU; // skip, variable already deleted/unscoped
	5763	+ label = 423LLU; // skip, variable already deleted/unscoped
5679	5764	break;
5680	5765	}
5681	5766	fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");

		@@ -5685,28 +5770,28 @@
5685	5770	newstack[0] = (uint64_t)stack; // backup stack location
5686	5771	newstack[1] = 1234567890;
5687	5772	newstack[2] = base;
5688		- newstack[3] = 413LLU;
	5773	+ newstack[3] = 427LLU;
5689	5774	stack = newstack;
5690	5775	// set stack-base & callee-address
5691	5776	base = 4/deloffset/;
5692		- label = 400LLU; // ~param
	5777	+ label = 413LLU; // ~param
5693	5778	break;
5694	5779	}
5695		- case 413LLU: // return from ~param to copyparam
	5780	+ case 427LLU: // return from ~param to copyparam
5696	5781	{
5697	5782	stack = (uint64_t *)stack[0];
5698	5783	// releasing toplevel container
5699	5784	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
5700	5785
5701		- label = 409LLU; // continue unrolling stack, delete next variable
	5786	+ label = 423LLU; // continue unrolling stack, delete next variable
5702	5787	break;
5703	5788	}
5704		- case 412LLU: // skipped deleter
	5789	+ case 426LLU: // skipped deleter
5705	5790	{
5706	5791	// construct param.param
5707	5792	if(!(stack[base + 0] = construct(2)))
5708	5793	{
5709		- label = 409LLU; // throw: begin to unroll stack
	5794	+ label = 423LLU; // throw: begin to unroll stack
5710	5795	break;
5711	5796	}
5712	5797

		@@ -5716,15 +5801,22 @@
5716	5801	(((uint64_t *)(stack[base + 0]))[1][1]) = stack[base + 5]/copymut*/;
5717	5802	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
5718	5803	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5719		- label = 405LLU; // case complete
	5804	+ label = 418LLU; // case complete
5720	5805	break;
5721	5806	}
5722		- case 406LLU: // try next case
	5807	+ case 420LLU: // copy-back deleter (switch)
5723	5808	{
	5809	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	5810	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	5811	+ label = 417LLU; // continue to unroll stack
	5812	+ break;
	5813	+ }
	5814	+ case 419LLU: // try next case
	5815	+ {
5724	5816	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5725	5817	exit(-1);
5726	5818	}
5727		- case 405LLU: // completed switch
	5819	+ case 418LLU: // completed switch
5728	5820	{
5729	5821	// return from copyparam
5730	5822	label = stack[base - 1];

		@@ -5731,7 +5823,7 @@
5731	5823	base = stack[base - 2];
5732	5824	break;
5733	5825	}
5734		- case 415LLU: // function repparam failed
	5826	+ case 429LLU: // function repparam failed
5735	5827	{
5736	5828	fprintf(stderr, "function repparam failed\n");
5737	5829	label = stack[base - 3];

		@@ -5738,12 +5830,12 @@
5738	5830	base = stack[base - 2];
5739	5831	break;
5740	5832	}
5741		- case 414LLU: // repparam
	5833	+ case 428LLU: // repparam
5742	5834	{
5743	5835	//#define arg0 0
5744	5836	if(/param/0 != ((uint64_t )(stack[base + 0]/param*/))[0])
5745	5837	{
5746		- label = 417LLU; // jump to alternative
	5838	+ label = 431LLU; // jump to alternative
5747	5839	break;
5748	5840	}
5749	5841

		@@ -5753,54 +5845,61 @@
5753	5845	// case
5754	5846	if(!stack[base + 2]/mutable/)
5755	5847	{
5756		- label = 418LLU; // jump to alternative
	5848	+ label = 433LLU; // jump to alternative
5757	5849	break;
5758	5850	}
5759	5851
5760	5852	// consequent
5761	5853	fprintf(stderr, "%s", "mut ");
5762		- label = 419LLU; // consequent complete
	5854	+ label = 434LLU; // consequent complete
5763	5855	break;
5764	5856	}
5765		- case 418LLU: // alternative
	5857	+ case 433LLU: // alternative
5766	5858	{
5767		- label = 419LLU; // alternative complete
	5859	+ label = 434LLU; // alternative complete
5768	5860	break;
5769	5861	}
5770		- case 419LLU: // completed if-then-else
	5862	+ case 434LLU: // completed if-then-else
5771	5863	{
5772	5864	// call reportti from repparam
5773		- stack[base + 3LLU] = 420LLU/throw to this address/;
	5865	+ stack[base + 3LLU] = 435LLU/throw to this address/;
5774	5866	stack[base + 4LLU] = base;
5775		- stack[base + 5LLU] = 421LLU;
	5867	+ stack[base + 5LLU] = 436LLU;
5776	5868	// arguments for call to reportti
5777	5869	stack[base + 6LLU] = stack[base + 1]/typeid/;
5778	5870	// set stack-base & callee-address
5779	5871	base += 6LLU;
5780		- label = 360LLU; // reportti
	5872	+ label = 369LLU; // reportti
5781	5873	break;
5782	5874	}
5783		- case 420LLU: // copy-back deleter (reportti to repparam)
	5875	+ case 435LLU: // copy-back deleter (reportti to repparam)
5784	5876	{
5785	5877	fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
5786	5878	// copy mutable arguments back from call to reportti
5787		- label = 415LLU; // continue to roll stack
	5879	+ label = 432LLU; // continue to roll stack
5788	5880	break;
5789	5881	}
5790		- case 421LLU: // return from reportti to repparam
	5882	+ case 436LLU: // return from reportti to repparam
5791	5883	{
5792	5884	// copy mutable arguments back from call to reportti
5793	5885	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
5794	5886	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5795		- label = 416LLU; // case complete
	5887	+ label = 430LLU; // case complete
5796	5888	break;
5797	5889	}
5798		- case 417LLU: // try next case
	5890	+ case 432LLU: // copy-back deleter (switch)
5799	5891	{
	5892	+ ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
	5893	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	5894	+ label = 429LLU; // continue to unroll stack
	5895	+ break;
	5896	+ }
	5897	+ case 431LLU: // try next case
	5898	+ {
5800	5899	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5801	5900	exit(-1);
5802	5901	}
5803		- case 416LLU: // completed switch
	5902	+ case 430LLU: // completed switch
5804	5903	{
5805	5904	// return from repparam
5806	5905	label = stack[base - 1];

		@@ -5807,7 +5906,7 @@
5807	5906	base = stack[base - 2];
5808	5907	break;
5809	5908	}
5810		- case 423LLU: // function lookparam failed
	5909	+ case 438LLU: // function lookparam failed
5811	5910	{
5812	5911	fprintf(stderr, "function lookparam failed\n");
5813	5912	label = stack[base - 3];

		@@ -5814,39 +5913,39 @@
5814	5913	base = stack[base - 2];
5815	5914	break;
5816	5915	}
5817		- case 422LLU: // lookparam
	5916	+ case 437LLU: // lookparam
5818	5917	{
5819	5918	//#define res0 0
5820	5919	//#define arg0 1
5821	5920	//#define arg1 2
5822		- label = 425LLU; // skip deleter
	5921	+ label = 440LLU; // skip deleter
5823	5922	break;
5824	5923	}
5825		- case 424LLU: // deleter
	5924	+ case 439LLU: // deleter
5826	5925	{
5827	5926	// throw from lookparam
5828	5927	if(!stack[base + 3])
5829	5928	{
5830	5929	fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5831		- label = 423LLU; // skip, variable already deleted/unscoped
	5930	+ label = 438LLU; // skip, variable already deleted/unscoped
5832	5931	break;
5833	5932	}
5834	5933	fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
5835		- label = 423LLU; // continue unrolling stack, delete next variable
	5934	+ label = 438LLU; // continue unrolling stack, delete next variable
5836	5935	break;
5837	5936	}
5838		- case 425LLU: // skipped deleter
	5937	+ case 440LLU: // skipped deleter
5839	5938	{
5840	5939	stack[base + 3] = 0;
5841	5940	flippedassign(stack[base + 1]/params/, &stack[base + 4]);
5842		- label = 426LLU; // start to repeat
	5941	+ label = 441LLU; // start to repeat
5843	5942	break;
5844	5943	}
5845		- case 426LLU: // repeat from here
	5944	+ case 441LLU: // repeat from here
5846	5945	{
5847	5946	if(!stack[base + 4])
5848	5947	{
5849		- label = 427LLU; // break loop
	5948	+ label = 442LLU; // break loop
5850	5949	break;
5851	5950	}
5852	5951

		@@ -5856,19 +5955,19 @@
5856	5955	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
5857	5956	if(!stack[base + 3]/found/)
5858	5957	{
5859		- label = 428LLU; // jump to alternative
	5958	+ label = 443LLU; // jump to alternative
5860	5959	break;
5861	5960	}
5862	5961
5863	5962	// consequent
5864		- label = 429LLU; // consequent complete
	5963	+ label = 444LLU; // consequent complete
5865	5964	break;
5866	5965	}
5867		- case 428LLU: // alternative
	5966	+ case 443LLU: // alternative
5868	5967	{
5869	5968	if(/param/0 != ((uint64_t )(stack[base + 5]/param*/))[0])
5870	5969	{
5871		- label = 431LLU; // jump to alternative
	5970	+ label = 446LLU; // jump to alternative
5872	5971	break;
5873	5972	}
5874	5973

		@@ -5878,7 +5977,7 @@
5878	5977	// case
5879	5978	if(/typeid/0 != ((uint64_t )(stack[base + 7]/typeid*/))[0])
5880	5979	{
5881		- label = 433LLU; // jump to alternative
	5980	+ label = 449LLU; // jump to alternative
5882	5981	break;
5883	5982	}
5884	5983

		@@ -5887,9 +5986,9 @@
5887	5986
5888	5987	// case
5889	5988	// call equ from lookparam
5890		- stack[base + 11LLU] = 434LLU/throw to this address/;
	5989	+ stack[base + 11LLU] = 451LLU/throw to this address/;
5891	5990	stack[base + 12LLU] = base;
5892		- stack[base + 13LLU] = 435LLU;
	5991	+ stack[base + 13LLU] = 452LLU;
5893	5992	// arguments for call to equ
5894	5993	stack[base + 15LLU] = stack[base + 10]/id/;
5895	5994	stack[base + 16LLU] = stack[base + 2]/wanted/;

		@@ -5898,14 +5997,14 @@
5898	5997	label = 18446744073709551600LLU; // equ
5899	5998	break;
5900	5999	}
5901		- case 434LLU: // copy-back deleter (equ to lookparam)
	6000	+ case 451LLU: // copy-back deleter (equ to lookparam)
5902	6001	{
5903	6002	fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
5904	6003	// copy mutable arguments back from call to equ
5905		- label = 424LLU; // continue to roll stack
	6004	+ label = 450LLU; // continue to roll stack
5906	6005	break;
5907	6006	}
5908		- case 435LLU: // return from equ to lookparam
	6007	+ case 452LLU: // return from equ to lookparam
5909	6008	{
5910	6009	// copy mutable arguments back from call to equ
5911	6010	// copy back results provided by call to equ

		@@ -5912,56 +6011,70 @@
5912	6011	stack[base + 3] = stack[base + 14LLU];
5913	6012	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
5914	6013	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
5915		- label = 432LLU; // case complete
	6014	+ label = 448LLU; // case complete
5916	6015	break;
5917	6016	}
5918		- case 433LLU: // try next case
	6017	+ case 450LLU: // copy-back deleter (switch)
5919	6018	{
	6019	+ ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
	6020	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
	6021	+ label = 447LLU; // continue to unroll stack
	6022	+ break;
	6023	+ }
	6024	+ case 449LLU: // try next case
	6025	+ {
5920	6026	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5921	6027	exit(-1);
5922	6028	}
5923		- case 432LLU: // completed switch
	6029	+ case 448LLU: // completed switch
5924	6030	{
5925	6031	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
5926	6032	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
5927		- label = 430LLU; // case complete
	6033	+ label = 445LLU; // case complete
5928	6034	break;
5929	6035	}
5930		- case 431LLU: // try next case
	6036	+ case 447LLU: // copy-back deleter (switch)
5931	6037	{
	6038	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
	6039	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
	6040	+ label = 439LLU; // continue to unroll stack
	6041	+ break;
	6042	+ }
	6043	+ case 446LLU: // try next case
	6044	+ {
5932	6045	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
5933	6046	exit(-1);
5934	6047	}
5935		- case 430LLU: // completed switch
	6048	+ case 445LLU: // completed switch
5936	6049	{
5937		- label = 429LLU; // alternative complete
	6050	+ label = 444LLU; // alternative complete
5938	6051	break;
5939	6052	}
5940		- case 429LLU: // completed if-then-else
	6053	+ case 444LLU: // completed if-then-else
5941	6054	{
5942	6055	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
5943		- label = 426LLU; // repeat
	6056	+ label = 441LLU; // repeat
5944	6057	break;
5945	6058	}
5946		- case 427LLU: // loop finished
	6059	+ case 442LLU: // loop finished
5947	6060	{
5948		- label = 437LLU; // skip deleter
	6061	+ label = 454LLU; // skip deleter
5949	6062	break;
5950	6063	}
5951		- case 436LLU: // deleter
	6064	+ case 453LLU: // deleter
5952	6065	{
5953	6066	// throw from lookparam
5954	6067	if(!stack[base + 0])
5955	6068	{
5956	6069	fprintf(stderr, "in function lookparam: unrolling stack, skipping already deleted/unscoped variable u64 \n");
5957		- label = 424LLU; // skip, variable already deleted/unscoped
	6070	+ label = 439LLU; // skip, variable already deleted/unscoped
5958	6071	break;
5959	6072	}
5960	6073	fprintf(stderr, "in function lookparam: unrolling stack, variable u64 \n");
5961		- label = 424LLU; // continue unrolling stack, delete next variable
	6074	+ label = 439LLU; // continue unrolling stack, delete next variable
5962	6075	break;
5963	6076	}
5964		- case 437LLU: // skipped deleter
	6077	+ case 454LLU: // skipped deleter
5965	6078	{
5966	6079	stack[base + 0] = stack[base + 3]/found/;
5967	6080	// return from lookparam

		@@ -5969,7 +6082,7 @@
5969	6082	base = stack[base - 2];
5970	6083	break;
5971	6084	}
5972		- case 438LLU: // ~letdef
	6085	+ case 455LLU: // ~letdef
5973	6086	{
5974	6087	if(stack[base + 0]/variant-nr/ >= 1)
5975	6088	{

		@@ -5976,10 +6089,10 @@
5976	6089	fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
5977	6090	exit(-1);
5978	6091	}
5979		- label = 438LLU + 1LLU + stack[base + 0]/variant-nr/;
	6092	+ label = 455LLU + 1LLU + stack[base + 0]/variant-nr/;
5980	6093	break;
5981	6094	}
5982		- case 438LLU + 1LLU + 0LLU: // ~letdef.letdef
	6095	+ case 455LLU + 1LLU + 0LLU: // ~letdef.letdef
5983	6096	{
5984	6097	// release element type
5985	6098	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[0/element-nr*/];

		@@ -5989,7 +6102,7 @@
5989	6102	newstack[0] = (uint64_t)stack; // backup stack location
5990	6103	newstack[1] = 1234567890;
5991	6104	newstack[2] = base;
5992		- newstack[3] = 440LLU;
	6105	+ newstack[3] = 457LLU;
5993	6106	stack = newstack;
5994	6107	// set stack-base & callee-address
5995	6108	base = 4/deloffset/;

		@@ -5996,7 +6109,7 @@
5996	6109	label = 295LLU; // ~type
5997	6110	break;
5998	6111	}
5999		- case 440LLU: // return from ~type to letdef
	6112	+ case 457LLU: // return from ~type to letdef
6000	6113	{
6001	6114	stack = (uint64_t *)stack[0];
6002	6115	// releasing toplevel container

		@@ -6012,7 +6125,7 @@
6012	6125	base = stack[base - 2];
6013	6126	break;
6014	6127	}
6015		- case 442LLU: // function mkletdummy failed
	6128	+ case 459LLU: // function mkletdummy failed
6016	6129	{
6017	6130	fprintf(stderr, "function mkletdummy failed\n");
6018	6131	label = stack[base - 3];

		@@ -6019,38 +6132,38 @@
6019	6132	base = stack[base - 2];
6020	6133	break;
6021	6134	}
6022		- case 441LLU: // mkletdummy
	6135	+ case 458LLU: // mkletdummy
6023	6136	{
6024	6137	//#define res0 0
6025		- label = 444LLU; // skip deleter
	6138	+ label = 461LLU; // skip deleter
6026	6139	break;
6027	6140	}
6028		- case 443LLU: // deleter
	6141	+ case 460LLU: // deleter
6029	6142	{
6030	6143	// throw from mkletdummy
6031	6144	if(!stack[base + 1])
6032	6145	{
6033	6146	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6034		- label = 442LLU; // skip, variable already deleted/unscoped
	6147	+ label = 459LLU; // skip, variable already deleted/unscoped
6035	6148	break;
6036	6149	}
6037	6150	fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6038		- label = 442LLU; // continue unrolling stack, delete next variable
	6151	+ label = 459LLU; // continue unrolling stack, delete next variable
6039	6152	break;
6040	6153	}
6041		- case 444LLU: // skipped deleter
	6154	+ case 461LLU: // skipped deleter
6042	6155	{
6043	6156	stack[base + 1] = 78026663350239232;
6044		- label = 446LLU; // skip deleter
	6157	+ label = 463LLU; // skip deleter
6045	6158	break;
6046	6159	}
6047		- case 445LLU: // deleter
	6160	+ case 462LLU: // deleter
6048	6161	{
6049	6162	// throw from mkletdummy
6050	6163	if(!stack[base + 2])
6051	6164	{
6052	6165	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable type \n");
6053		- label = 443LLU; // skip, variable already deleted/unscoped
	6166	+ label = 460LLU; // skip, variable already deleted/unscoped
6054	6167	break;
6055	6168	}
6056	6169	fprintf(stderr, "in function mkletdummy: unrolling stack, variable type \n");

		@@ -6060,7 +6173,7 @@
6060	6173	newstack[0] = (uint64_t)stack; // backup stack location
6061	6174	newstack[1] = 1234567890;
6062	6175	newstack[2] = base;
6063		- newstack[3] = 447LLU;
	6176	+ newstack[3] = 464LLU;
6064	6177	stack = newstack;
6065	6178	// set stack-base & callee-address
6066	6179	base = 4/deloffset/;

		@@ -6067,21 +6180,21 @@
6067	6180	label = 295LLU; // ~type
6068	6181	break;
6069	6182	}
6070		- case 447LLU: // return from ~type to mkletdummy
	6183	+ case 464LLU: // return from ~type to mkletdummy
6071	6184	{
6072	6185	stack = (uint64_t *)stack[0];
6073	6186	// releasing toplevel container
6074	6187	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 2] - sizeof(uint64_t) 4));
6075	6188
6076		- label = 443LLU; // continue unrolling stack, delete next variable
	6189	+ label = 460LLU; // continue unrolling stack, delete next variable
6077	6190	break;
6078	6191	}
6079		- case 446LLU: // skipped deleter
	6192	+ case 463LLU: // skipped deleter
6080	6193	{
6081	6194	// construct type.typename
6082	6195	if(!(stack[base + 2] = construct(1)))
6083	6196	{
6084		- label = 443LLU; // throw: begin to unroll stack
	6197	+ label = 460LLU; // throw: begin to unroll stack
6085	6198	break;
6086	6199	}
6087	6200

		@@ -6088,73 +6201,73 @@
6088	6201	// consequent
6089	6202	((uint64_t *)stack[base + 2])[0] = 0;
6090	6203	(((uint64_t *)(stack[base + 2]))[1][0]) = stack[base + 1]/newid*/;
6091		- label = 449LLU; // skip deleter
	6204	+ label = 466LLU; // skip deleter
6092	6205	break;
6093	6206	}
6094		- case 448LLU: // deleter
	6207	+ case 465LLU: // deleter
6095	6208	{
6096	6209	// throw from mkletdummy
6097	6210	if(!stack[base + 3])
6098	6211	{
6099	6212	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6100		- label = 445LLU; // skip, variable already deleted/unscoped
	6213	+ label = 462LLU; // skip, variable already deleted/unscoped
6101	6214	break;
6102	6215	}
6103	6216	fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6104		- label = 445LLU; // continue unrolling stack, delete next variable
	6217	+ label = 462LLU; // continue unrolling stack, delete next variable
6105	6218	break;
6106	6219	}
6107		- case 449LLU: // skipped deleter
	6220	+ case 466LLU: // skipped deleter
6108	6221	{
6109	6222	stack[base + 3] = 0;
6110		- label = 451LLU; // skip deleter
	6223	+ label = 468LLU; // skip deleter
6111	6224	break;
6112	6225	}
6113		- case 450LLU: // deleter
	6226	+ case 467LLU: // deleter
6114	6227	{
6115	6228	// throw from mkletdummy
6116	6229	if(!stack[base + 4])
6117	6230	{
6118	6231	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6119		- label = 448LLU; // skip, variable already deleted/unscoped
	6232	+ label = 465LLU; // skip, variable already deleted/unscoped
6120	6233	break;
6121	6234	}
6122	6235	fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6123		- label = 448LLU; // continue unrolling stack, delete next variable
	6236	+ label = 465LLU; // continue unrolling stack, delete next variable
6124	6237	break;
6125	6238	}
6126		- case 451LLU: // skipped deleter
	6239	+ case 468LLU: // skipped deleter
6127	6240	{
6128	6241	stack[base + 4] = 0;
6129		- label = 453LLU; // skip deleter
	6242	+ label = 470LLU; // skip deleter
6130	6243	break;
6131	6244	}
6132		- case 452LLU: // deleter
	6245	+ case 469LLU: // deleter
6133	6246	{
6134	6247	// throw from mkletdummy
6135	6248	if(!stack[base + 5])
6136	6249	{
6137	6250	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6138		- label = 450LLU; // skip, variable already deleted/unscoped
	6251	+ label = 467LLU; // skip, variable already deleted/unscoped
6139	6252	break;
6140	6253	}
6141	6254	fprintf(stderr, "in function mkletdummy: unrolling stack, variable u64 \n");
6142		- label = 450LLU; // continue unrolling stack, delete next variable
	6255	+ label = 467LLU; // continue unrolling stack, delete next variable
6143	6256	break;
6144	6257	}
6145		- case 453LLU: // skipped deleter
	6258	+ case 470LLU: // skipped deleter
6146	6259	{
6147	6260	stack[base + 5] = 0;
6148		- label = 455LLU; // skip deleter
	6261	+ label = 472LLU; // skip deleter
6149	6262	break;
6150	6263	}
6151		- case 454LLU: // deleter
	6264	+ case 471LLU: // deleter
6152	6265	{
6153	6266	// throw from mkletdummy
6154	6267	if(!stack[base + 0])
6155	6268	{
6156	6269	fprintf(stderr, "in function mkletdummy: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6157		- label = 452LLU; // skip, variable already deleted/unscoped
	6270	+ label = 469LLU; // skip, variable already deleted/unscoped
6158	6271	break;
6159	6272	}
6160	6273	fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");

		@@ -6164,28 +6277,28 @@
6164	6277	newstack[0] = (uint64_t)stack; // backup stack location
6165	6278	newstack[1] = 1234567890;
6166	6279	newstack[2] = base;
6167		- newstack[3] = 456LLU;
	6280	+ newstack[3] = 473LLU;
6168	6281	stack = newstack;
6169	6282	// set stack-base & callee-address
6170	6283	base = 4/deloffset/;
6171		- label = 438LLU; // ~letdef
	6284	+ label = 455LLU; // ~letdef
6172	6285	break;
6173	6286	}
6174		- case 456LLU: // return from ~letdef to mkletdummy
	6287	+ case 473LLU: // return from ~letdef to mkletdummy
6175	6288	{
6176	6289	stack = (uint64_t *)stack[0];
6177	6290	// releasing toplevel container
6178	6291	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6179	6292
6180		- label = 452LLU; // continue unrolling stack, delete next variable
	6293	+ label = 469LLU; // continue unrolling stack, delete next variable
6181	6294	break;
6182	6295	}
6183		- case 455LLU: // skipped deleter
	6296	+ case 472LLU: // skipped deleter
6184	6297	{
6185	6298	// construct letdef.letdef
6186	6299	if(!(stack[base + 0] = construct(5)))
6187	6300	{
6188		- label = 452LLU; // throw: begin to unroll stack
	6301	+ label = 469LLU; // throw: begin to unroll stack
6189	6302	break;
6190	6303	}
6191	6304

		@@ -6201,7 +6314,7 @@
6201	6314	base = stack[base - 2];
6202	6315	break;
6203	6316	}
6204		- case 458LLU: // function reportlet failed
	6317	+ case 475LLU: // function reportlet failed
6205	6318	{
6206	6319	fprintf(stderr, "function reportlet failed\n");
6207	6320	label = stack[base - 3];

		@@ -6208,12 +6321,12 @@
6208	6321	base = stack[base - 2];
6209	6322	break;
6210	6323	}
6211		- case 457LLU: // reportlet
	6324	+ case 474LLU: // reportlet
6212	6325	{
6213	6326	//#define arg0 0
6214	6327	if(/letdef/0 != ((uint64_t )(stack[base + 0]/letdef*/))[0])
6215	6328	{
6216		- label = 460LLU; // jump to alternative
	6329	+ label = 477LLU; // jump to alternative
6217	6330	break;
6218	6331	}
6219	6332

		@@ -6226,26 +6339,26 @@
6226	6339	// case
6227	6340	if(!stack[base + 4]/mutable/)
6228	6341	{
6229		- label = 461LLU; // jump to alternative
	6342	+ label = 479LLU; // jump to alternative
6230	6343	break;
6231	6344	}
6232	6345
6233	6346	// consequent
6234	6347	fprintf(stderr, "%s", "mut ");
6235		- label = 462LLU; // consequent complete
	6348	+ label = 480LLU; // consequent complete
6236	6349	break;
6237	6350	}
6238		- case 461LLU: // alternative
	6351	+ case 479LLU: // alternative
6239	6352	{
6240		- label = 462LLU; // alternative complete
	6353	+ label = 480LLU; // alternative complete
6241	6354	break;
6242	6355	}
6243		- case 462LLU: // completed if-then-else
	6356	+ case 480LLU: // completed if-then-else
6244	6357	{
6245	6358	uint64_t newstack = (uint64_t )Calloc(10LLU + 1, sizeof(uint64_t));
6246	6359	if(!newstack)
6247	6360	{
6248		- label = 458LLU; // throw: begin to unroll stack
	6361	+ label = 478LLU; // throw: begin to unroll stack
6249	6362	break;
6250	6363	}
6251	6364

		@@ -6252,18 +6365,18 @@
6252	6365	newstack[10LLU] = 9876543210LLU; // overflow-marker
6253	6366	// call reporttype from reportlet
6254	6367	newstack[0] = (uint64_t)stack; // backup stack location
6255		- newstack[1] = 463LLU;
	6368	+ newstack[1] = 481LLU;
6256	6369	newstack[2] = base;
6257		- newstack[3] = 464LLU;
	6370	+ newstack[3] = 482LLU;
6258	6371	// arguments for call to reporttype
6259	6372	newstack[4LLU] = stack[base + 1]/type/;
6260	6373	stack = newstack;
6261	6374	// set stack-base & callee-address
6262	6375	base = 4/deloffset/;
6263		- label = 313LLU; // reporttype
	6376	+ label = 315LLU; // reporttype
6264	6377	break;
6265	6378	}
6266		- case 463LLU: // copy-back deleter (reporttype to reportlet)
	6379	+ case 481LLU: // copy-back deleter (reporttype to reportlet)
6267	6380	{
6268	6381	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
6269	6382	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6275,10 +6388,10 @@
6275	6388	}
6276	6389	Free(10LLU + 1, sizeof(uint64_t), stack);
6277	6390	stack = oldstack;
6278		- label = 458LLU; // continue to unroll stack
	6391	+ label = 478LLU; // continue to unroll stack
6279	6392	break;
6280	6393	}
6281		- case 464LLU: // return from reporttype to reportlet
	6394	+ case 482LLU: // return from reporttype to reportlet
6282	6395	{
6283	6396	uint64_t oldstack = (uint64_t )stack[0];
6284	6397	// copy mutable arguments back from call to reporttype

		@@ -6291,9 +6404,9 @@
6291	6404	stack = oldstack;
6292	6405	fprintf(stderr, "%s", " ");
6293	6406	// call reportid from reportlet
6294		- stack[base + 6LLU] = 465LLU/throw to this address/;
	6407	+ stack[base + 6LLU] = 483LLU/throw to this address/;
6295	6408	stack[base + 7LLU] = base;
6296		- stack[base + 8LLU] = 466LLU;
	6409	+ stack[base + 8LLU] = 484LLU;
6297	6410	// arguments for call to reportid
6298	6411	stack[base + 9LLU] = stack[base + 2]/id/;
6299	6412	// set stack-base & callee-address

		@@ -6301,21 +6414,21 @@
6301	6414	label = 18446744073709551586LLU; // reportid
6302	6415	break;
6303	6416	}
6304		- case 465LLU: // copy-back deleter (reportid to reportlet)
	6417	+ case 483LLU: // copy-back deleter (reportid to reportlet)
6305	6418	{
6306	6419	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
6307	6420	// copy mutable arguments back from call to reportid
6308		- label = 458LLU; // continue to roll stack
	6421	+ label = 478LLU; // continue to roll stack
6309	6422	break;
6310	6423	}
6311		- case 466LLU: // return from reportid to reportlet
	6424	+ case 484LLU: // return from reportid to reportlet
6312	6425	{
6313	6426	// copy mutable arguments back from call to reportid
6314	6427	fprintf(stderr, "%s", " ");
6315	6428	// call reportnr from reportlet
6316		- stack[base + 6LLU] = 467LLU/throw to this address/;
	6429	+ stack[base + 6LLU] = 485LLU/throw to this address/;
6317	6430	stack[base + 7LLU] = base;
6318		- stack[base + 8LLU] = 468LLU;
	6431	+ stack[base + 8LLU] = 486LLU;
6319	6432	// arguments for call to reportnr
6320	6433	stack[base + 9LLU] = stack[base + 3]/index/;
6321	6434	// set stack-base & callee-address

		@@ -6323,14 +6436,14 @@
6323	6436	label = 18446744073709551589LLU; // reportnr
6324	6437	break;
6325	6438	}
6326		- case 467LLU: // copy-back deleter (reportnr to reportlet)
	6439	+ case 485LLU: // copy-back deleter (reportnr to reportlet)
6327	6440	{
6328	6441	fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
6329	6442	// copy mutable arguments back from call to reportnr
6330		- label = 458LLU; // continue to roll stack
	6443	+ label = 478LLU; // continue to roll stack
6331	6444	break;
6332	6445	}
6333		- case 468LLU: // return from reportnr to reportlet
	6446	+ case 486LLU: // return from reportnr to reportlet
6334	6447	{
6335	6448	// copy mutable arguments back from call to reportnr
6336	6449	((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];

		@@ -6338,15 +6451,25 @@
6338	6451	((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
6339	6452	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
6340	6453	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6341		- label = 459LLU; // case complete
	6454	+ label = 476LLU; // case complete
6342	6455	break;
6343	6456	}
6344		- case 460LLU: // try next case
	6457	+ case 478LLU: // copy-back deleter (switch)
6345	6458	{
	6459	+ ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
	6460	+ ((uint64_t **)(stack[base + 0]))[1][3] = stack[base + 4];
	6461	+ ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
	6462	+ ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
	6463	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	6464	+ label = 475LLU; // continue to unroll stack
	6465	+ break;
	6466	+ }
	6467	+ case 477LLU: // try next case
	6468	+ {
6346	6469	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6347	6470	exit(-1);
6348	6471	}
6349		- case 459LLU: // completed switch
	6472	+ case 476LLU: // completed switch
6350	6473	{
6351	6474	// return from reportlet
6352	6475	label = stack[base - 1];

		@@ -6353,7 +6476,7 @@
6353	6476	base = stack[base - 2];
6354	6477	break;
6355	6478	}
6356		- case 470LLU: // function equletdef failed
	6479	+ case 488LLU: // function equletdef failed
6357	6480	{
6358	6481	fprintf(stderr, "function equletdef failed\n");
6359	6482	label = stack[base - 3];

		@@ -6360,7 +6483,7 @@
6360	6483	base = stack[base - 2];
6361	6484	break;
6362	6485	}
6363		- case 469LLU: // equletdef
	6486	+ case 487LLU: // equletdef
6364	6487	{
6365	6488	//#define res0 0
6366	6489	//#define arg0 1

		@@ -6367,7 +6490,7 @@
6367	6490	//#define arg1 2
6368	6491	if(/letdef/0 != ((uint64_t )(stack[base + 1]/x*/))[0])
6369	6492	{
6370		- label = 472LLU; // jump to alternative
	6493	+ label = 490LLU; // jump to alternative
6371	6494	break;
6372	6495	}
6373	6496

		@@ -6379,7 +6502,7 @@
6379	6502
6380	6503	if(/letdef/0 != ((uint64_t )(stack[base + 2]/y*/))[0])
6381	6504	{
6382		- label = 472LLU; // jump to alternative
	6505	+ label = 490LLU; // jump to alternative
6383	6506	break;
6384	6507	}
6385	6508

		@@ -6390,48 +6513,48 @@
6390	6513	/ysubstruct/stack[base + 12] = ((uint64_t *)(stack[base + 2]/y/))[1][4]/substruct*/;
6391	6514
6392	6515	// case
6393		- label = 474LLU; // skip deleter
	6516	+ label = 493LLU; // skip deleter
6394	6517	break;
6395	6518	}
6396		- case 473LLU: // deleter
	6519	+ case 492LLU: // deleter
6397	6520	{
6398	6521	// throw from equletdef
6399	6522	if(!stack[base + 13])
6400	6523	{
6401	6524	fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6402		- label = 470LLU; // skip, variable already deleted/unscoped
	6525	+ label = 491LLU; // skip, variable already deleted/unscoped
6403	6526	break;
6404	6527	}
6405	6528	fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6406		- label = 470LLU; // continue unrolling stack, delete next variable
	6529	+ label = 491LLU; // continue unrolling stack, delete next variable
6407	6530	break;
6408	6531	}
6409		- case 474LLU: // skipped deleter
	6532	+ case 493LLU: // skipped deleter
6410	6533	{
6411	6534	stack[base + 13] = 1;
6412		- label = 476LLU; // skip deleter
	6535	+ label = 495LLU; // skip deleter
6413	6536	break;
6414	6537	}
6415		- case 475LLU: // deleter
	6538	+ case 494LLU: // deleter
6416	6539	{
6417	6540	// throw from equletdef
6418	6541	if(!stack[base + 14])
6419	6542	{
6420	6543	fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6421		- label = 473LLU; // skip, variable already deleted/unscoped
	6544	+ label = 492LLU; // skip, variable already deleted/unscoped
6422	6545	break;
6423	6546	}
6424	6547	fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6425		- label = 473LLU; // continue unrolling stack, delete next variable
	6548	+ label = 492LLU; // continue unrolling stack, delete next variable
6426	6549	break;
6427	6550	}
6428		- case 476LLU: // skipped deleter
	6551	+ case 495LLU: // skipped deleter
6429	6552	{
6430	6553	stack[base + 14] = 0;
6431	6554	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6432	6555	if(!newstack)
6433	6556	{
6434		- label = 475LLU; // throw: begin to unroll stack
	6557	+ label = 494LLU; // throw: begin to unroll stack
6435	6558	break;
6436	6559	}
6437	6560

		@@ -6438,9 +6561,9 @@
6438	6561	newstack[15LLU] = 9876543210LLU; // overflow-marker
6439	6562	// call equtype from equletdef
6440	6563	newstack[0] = (uint64_t)stack; // backup stack location
6441		- newstack[1] = 477LLU;
	6564	+ newstack[1] = 496LLU;
6442	6565	newstack[2] = base;
6443		- newstack[3] = 478LLU;
	6566	+ newstack[3] = 497LLU;
6444	6567	// arguments for call to equtype
6445	6568	newstack[5LLU] = stack[base + 3]/xtype/;
6446	6569	newstack[6LLU] = stack[base + 8]/ytype/;

		@@ -6447,10 +6570,10 @@
6447	6570	stack = newstack;
6448	6571	// set stack-base & callee-address
6449	6572	base = 4/deloffset/;
6450		- label = 335LLU; // equtype
	6573	+ label = 341LLU; // equtype
6451	6574	break;
6452	6575	}
6453		- case 477LLU: // copy-back deleter (equtype to equletdef)
	6576	+ case 496LLU: // copy-back deleter (equtype to equletdef)
6454	6577	{
6455	6578	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
6456	6579	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6462,10 +6585,10 @@
6462	6585	}
6463	6586	Free(15LLU + 1, sizeof(uint64_t), stack);
6464	6587	stack = oldstack;
6465		- label = 475LLU; // continue to unroll stack
	6588	+ label = 494LLU; // continue to unroll stack
6466	6589	break;
6467	6590	}
6468		- case 478LLU: // return from equtype to equletdef
	6591	+ case 497LLU: // return from equtype to equletdef
6469	6592	{
6470	6593	uint64_t oldstack = (uint64_t )stack[0];
6471	6594	// copy mutable arguments back from call to equtype

		@@ -6479,9 +6602,9 @@
6479	6602	Free(15LLU + 1, sizeof(uint64_t), stack);
6480	6603	stack = oldstack;
6481	6604	// call and from equletdef
6482		- stack[base + 15LLU] = 479LLU/throw to this address/;
	6605	+ stack[base + 15LLU] = 498LLU/throw to this address/;
6483	6606	stack[base + 16LLU] = base;
6484		- stack[base + 17LLU] = 480LLU;
	6607	+ stack[base + 17LLU] = 499LLU;
6485	6608	// arguments for call to and
6486	6609	stack[base + 19LLU] = stack[base + 13]/result/;
6487	6610	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6490,22 +6613,22 @@
6490	6613	label = 18446744073709551613LLU; // and
6491	6614	break;
6492	6615	}
6493		- case 479LLU: // copy-back deleter (and to equletdef)
	6616	+ case 498LLU: // copy-back deleter (and to equletdef)
6494	6617	{
6495	6618	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6496	6619	// copy mutable arguments back from call to and
6497		- label = 475LLU; // continue to roll stack
	6620	+ label = 494LLU; // continue to roll stack
6498	6621	break;
6499	6622	}
6500		- case 480LLU: // return from and to equletdef
	6623	+ case 499LLU: // return from and to equletdef
6501	6624	{
6502	6625	// copy mutable arguments back from call to and
6503	6626	// copy back results provided by call to and
6504	6627	stack[base + 13] = stack[base + 18LLU];
6505	6628	// call equ from equletdef
6506		- stack[base + 15LLU] = 481LLU/throw to this address/;
	6629	+ stack[base + 15LLU] = 500LLU/throw to this address/;
6507	6630	stack[base + 16LLU] = base;
6508		- stack[base + 17LLU] = 482LLU;
	6631	+ stack[base + 17LLU] = 501LLU;
6509	6632	// arguments for call to equ
6510	6633	stack[base + 19LLU] = stack[base + 4]/xid/;
6511	6634	stack[base + 20LLU] = stack[base + 9]/yid/;

		@@ -6514,22 +6637,22 @@
6514	6637	label = 18446744073709551600LLU; // equ
6515	6638	break;
6516	6639	}
6517		- case 481LLU: // copy-back deleter (equ to equletdef)
	6640	+ case 500LLU: // copy-back deleter (equ to equletdef)
6518	6641	{
6519	6642	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6520	6643	// copy mutable arguments back from call to equ
6521		- label = 475LLU; // continue to roll stack
	6644	+ label = 494LLU; // continue to roll stack
6522	6645	break;
6523	6646	}
6524		- case 482LLU: // return from equ to equletdef
	6647	+ case 501LLU: // return from equ to equletdef
6525	6648	{
6526	6649	// copy mutable arguments back from call to equ
6527	6650	// copy back results provided by call to equ
6528	6651	stack[base + 14] = stack[base + 18LLU];
6529	6652	// call and from equletdef
6530		- stack[base + 15LLU] = 483LLU/throw to this address/;
	6653	+ stack[base + 15LLU] = 502LLU/throw to this address/;
6531	6654	stack[base + 16LLU] = base;
6532		- stack[base + 17LLU] = 484LLU;
	6655	+ stack[base + 17LLU] = 503LLU;
6533	6656	// arguments for call to and
6534	6657	stack[base + 19LLU] = stack[base + 13]/result/;
6535	6658	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6538,22 +6661,22 @@
6538	6661	label = 18446744073709551613LLU; // and
6539	6662	break;
6540	6663	}
6541		- case 483LLU: // copy-back deleter (and to equletdef)
	6664	+ case 502LLU: // copy-back deleter (and to equletdef)
6542	6665	{
6543	6666	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6544	6667	// copy mutable arguments back from call to and
6545		- label = 475LLU; // continue to roll stack
	6668	+ label = 494LLU; // continue to roll stack
6546	6669	break;
6547	6670	}
6548		- case 484LLU: // return from and to equletdef
	6671	+ case 503LLU: // return from and to equletdef
6549	6672	{
6550	6673	// copy mutable arguments back from call to and
6551	6674	// copy back results provided by call to and
6552	6675	stack[base + 13] = stack[base + 18LLU];
6553	6676	// call equ from equletdef
6554		- stack[base + 15LLU] = 485LLU/throw to this address/;
	6677	+ stack[base + 15LLU] = 504LLU/throw to this address/;
6555	6678	stack[base + 16LLU] = base;
6556		- stack[base + 17LLU] = 486LLU;
	6679	+ stack[base + 17LLU] = 505LLU;
6557	6680	// arguments for call to equ
6558	6681	stack[base + 19LLU] = stack[base + 5]/xindex/;
6559	6682	stack[base + 20LLU] = stack[base + 10]/yindex/;

		@@ -6562,22 +6685,22 @@
6562	6685	label = 18446744073709551600LLU; // equ
6563	6686	break;
6564	6687	}
6565		- case 485LLU: // copy-back deleter (equ to equletdef)
	6688	+ case 504LLU: // copy-back deleter (equ to equletdef)
6566	6689	{
6567	6690	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6568	6691	// copy mutable arguments back from call to equ
6569		- label = 475LLU; // continue to roll stack
	6692	+ label = 494LLU; // continue to roll stack
6570	6693	break;
6571	6694	}
6572		- case 486LLU: // return from equ to equletdef
	6695	+ case 505LLU: // return from equ to equletdef
6573	6696	{
6574	6697	// copy mutable arguments back from call to equ
6575	6698	// copy back results provided by call to equ
6576	6699	stack[base + 14] = stack[base + 18LLU];
6577	6700	// call and from equletdef
6578		- stack[base + 15LLU] = 487LLU/throw to this address/;
	6701	+ stack[base + 15LLU] = 506LLU/throw to this address/;
6579	6702	stack[base + 16LLU] = base;
6580		- stack[base + 17LLU] = 488LLU;
	6703	+ stack[base + 17LLU] = 507LLU;
6581	6704	// arguments for call to and
6582	6705	stack[base + 19LLU] = stack[base + 13]/result/;
6583	6706	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6586,22 +6709,22 @@
6586	6709	label = 18446744073709551613LLU; // and
6587	6710	break;
6588	6711	}
6589		- case 487LLU: // copy-back deleter (and to equletdef)
	6712	+ case 506LLU: // copy-back deleter (and to equletdef)
6590	6713	{
6591	6714	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6592	6715	// copy mutable arguments back from call to and
6593		- label = 475LLU; // continue to roll stack
	6716	+ label = 494LLU; // continue to roll stack
6594	6717	break;
6595	6718	}
6596		- case 488LLU: // return from and to equletdef
	6719	+ case 507LLU: // return from and to equletdef
6597	6720	{
6598	6721	// copy mutable arguments back from call to and
6599	6722	// copy back results provided by call to and
6600	6723	stack[base + 13] = stack[base + 18LLU];
6601	6724	// call equ from equletdef
6602		- stack[base + 15LLU] = 489LLU/throw to this address/;
	6725	+ stack[base + 15LLU] = 508LLU/throw to this address/;
6603	6726	stack[base + 16LLU] = base;
6604		- stack[base + 17LLU] = 490LLU;
	6727	+ stack[base + 17LLU] = 509LLU;
6605	6728	// arguments for call to equ
6606	6729	stack[base + 19LLU] = stack[base + 6]/xmutable/;
6607	6730	stack[base + 20LLU] = stack[base + 11]/ymutable/;

		@@ -6610,22 +6733,22 @@
6610	6733	label = 18446744073709551600LLU; // equ
6611	6734	break;
6612	6735	}
6613		- case 489LLU: // copy-back deleter (equ to equletdef)
	6736	+ case 508LLU: // copy-back deleter (equ to equletdef)
6614	6737	{
6615	6738	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6616	6739	// copy mutable arguments back from call to equ
6617		- label = 475LLU; // continue to roll stack
	6740	+ label = 494LLU; // continue to roll stack
6618	6741	break;
6619	6742	}
6620		- case 490LLU: // return from equ to equletdef
	6743	+ case 509LLU: // return from equ to equletdef
6621	6744	{
6622	6745	// copy mutable arguments back from call to equ
6623	6746	// copy back results provided by call to equ
6624	6747	stack[base + 14] = stack[base + 18LLU];
6625	6748	// call and from equletdef
6626		- stack[base + 15LLU] = 491LLU/throw to this address/;
	6749	+ stack[base + 15LLU] = 510LLU/throw to this address/;
6627	6750	stack[base + 16LLU] = base;
6628		- stack[base + 17LLU] = 492LLU;
	6751	+ stack[base + 17LLU] = 511LLU;
6629	6752	// arguments for call to and
6630	6753	stack[base + 19LLU] = stack[base + 13]/result/;
6631	6754	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6634,22 +6757,22 @@
6634	6757	label = 18446744073709551613LLU; // and
6635	6758	break;
6636	6759	}
6637		- case 491LLU: // copy-back deleter (and to equletdef)
	6760	+ case 510LLU: // copy-back deleter (and to equletdef)
6638	6761	{
6639	6762	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6640	6763	// copy mutable arguments back from call to and
6641		- label = 475LLU; // continue to roll stack
	6764	+ label = 494LLU; // continue to roll stack
6642	6765	break;
6643	6766	}
6644		- case 492LLU: // return from and to equletdef
	6767	+ case 511LLU: // return from and to equletdef
6645	6768	{
6646	6769	// copy mutable arguments back from call to and
6647	6770	// copy back results provided by call to and
6648	6771	stack[base + 13] = stack[base + 18LLU];
6649	6772	// call equ from equletdef
6650		- stack[base + 15LLU] = 493LLU/throw to this address/;
	6773	+ stack[base + 15LLU] = 512LLU/throw to this address/;
6651	6774	stack[base + 16LLU] = base;
6652		- stack[base + 17LLU] = 494LLU;
	6775	+ stack[base + 17LLU] = 513LLU;
6653	6776	// arguments for call to equ
6654	6777	stack[base + 19LLU] = stack[base + 7]/xsubstruct/;
6655	6778	stack[base + 20LLU] = stack[base + 12]/ysubstruct/;

		@@ -6658,22 +6781,22 @@
6658	6781	label = 18446744073709551600LLU; // equ
6659	6782	break;
6660	6783	}
6661		- case 493LLU: // copy-back deleter (equ to equletdef)
	6784	+ case 512LLU: // copy-back deleter (equ to equletdef)
6662	6785	{
6663	6786	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
6664	6787	// copy mutable arguments back from call to equ
6665		- label = 475LLU; // continue to roll stack
	6788	+ label = 494LLU; // continue to roll stack
6666	6789	break;
6667	6790	}
6668		- case 494LLU: // return from equ to equletdef
	6791	+ case 513LLU: // return from equ to equletdef
6669	6792	{
6670	6793	// copy mutable arguments back from call to equ
6671	6794	// copy back results provided by call to equ
6672	6795	stack[base + 14] = stack[base + 18LLU];
6673	6796	// call and from equletdef
6674		- stack[base + 15LLU] = 495LLU/throw to this address/;
	6797	+ stack[base + 15LLU] = 514LLU/throw to this address/;
6675	6798	stack[base + 16LLU] = base;
6676		- stack[base + 17LLU] = 496LLU;
	6799	+ stack[base + 17LLU] = 515LLU;
6677	6800	// arguments for call to and
6678	6801	stack[base + 19LLU] = stack[base + 13]/result/;
6679	6802	stack[base + 20LLU] = stack[base + 14]/isequal/;

		@@ -6682,35 +6805,35 @@
6682	6805	label = 18446744073709551613LLU; // and
6683	6806	break;
6684	6807	}
6685		- case 495LLU: // copy-back deleter (and to equletdef)
	6808	+ case 514LLU: // copy-back deleter (and to equletdef)
6686	6809	{
6687	6810	fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
6688	6811	// copy mutable arguments back from call to and
6689		- label = 475LLU; // continue to roll stack
	6812	+ label = 494LLU; // continue to roll stack
6690	6813	break;
6691	6814	}
6692		- case 496LLU: // return from and to equletdef
	6815	+ case 515LLU: // return from and to equletdef
6693	6816	{
6694	6817	// copy mutable arguments back from call to and
6695	6818	// copy back results provided by call to and
6696	6819	stack[base + 13] = stack[base + 18LLU];
6697		- label = 498LLU; // skip deleter
	6820	+ label = 517LLU; // skip deleter
6698	6821	break;
6699	6822	}
6700		- case 497LLU: // deleter
	6823	+ case 516LLU: // deleter
6701	6824	{
6702	6825	// throw from equletdef
6703	6826	if(!stack[base + 0])
6704	6827	{
6705	6828	fprintf(stderr, "in function equletdef: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6706		- label = 475LLU; // skip, variable already deleted/unscoped
	6829	+ label = 494LLU; // skip, variable already deleted/unscoped
6707	6830	break;
6708	6831	}
6709	6832	fprintf(stderr, "in function equletdef: unrolling stack, variable u64 \n");
6710		- label = 475LLU; // continue unrolling stack, delete next variable
	6833	+ label = 494LLU; // continue unrolling stack, delete next variable
6711	6834	break;
6712	6835	}
6713		- case 498LLU: // skipped deleter
	6836	+ case 517LLU: // skipped deleter
6714	6837	{
6715	6838	stack[base + 0] = stack[base + 13]/result/;
6716	6839	((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];

		@@ -6723,15 +6846,30 @@
6723	6846	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
6724	6847	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
6725	6848	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6726		- label = 471LLU; // case complete
	6849	+ label = 489LLU; // case complete
6727	6850	break;
6728	6851	}
6729		- case 472LLU: // try next case
	6852	+ case 491LLU: // copy-back deleter (switch)
6730	6853	{
	6854	+ ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
	6855	+ ((uint64_t **)(stack[base + 2]))[1][3] = stack[base + 11];
	6856	+ ((uint64_t **)(stack[base + 2]))[1][2] = stack[base + 10];
	6857	+ ((uint64_t **)(stack[base + 2]))[1][1] = stack[base + 9];
	6858	+ ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 8];
	6859	+ ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 7];
	6860	+ ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 6];
	6861	+ ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
	6862	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
	6863	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
	6864	+ label = 488LLU; // continue to unroll stack
	6865	+ break;
	6866	+ }
	6867	+ case 490LLU: // try next case
	6868	+ {
6731	6869	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6732	6870	exit(-1);
6733	6871	}
6734		- case 471LLU: // completed switch
	6872	+ case 489LLU: // completed switch
6735	6873	{
6736	6874	// return from equletdef
6737	6875	label = stack[base - 1];

		@@ -6738,7 +6876,7 @@
6738	6876	base = stack[base - 2];
6739	6877	break;
6740	6878	}
6741		- case 500LLU: // function copyletdef failed
	6879	+ case 519LLU: // function copyletdef failed
6742	6880	{
6743	6881	fprintf(stderr, "function copyletdef failed\n");
6744	6882	label = stack[base - 3];

		@@ -6745,13 +6883,13 @@
6745	6883	base = stack[base - 2];
6746	6884	break;
6747	6885	}
6748		- case 499LLU: // copyletdef
	6886	+ case 518LLU: // copyletdef
6749	6887	{
6750	6888	//#define res0 0
6751	6889	//#define arg0 1
6752	6890	if(/letdef/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
6753	6891	{
6754		- label = 502LLU; // jump to alternative
	6892	+ label = 521LLU; // jump to alternative
6755	6893	break;
6756	6894	}
6757	6895

		@@ -6765,7 +6903,7 @@
6765	6903	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
6766	6904	if(!newstack)
6767	6905	{
6768		- label = 500LLU; // throw: begin to unroll stack
	6906	+ label = 522LLU; // throw: begin to unroll stack
6769	6907	break;
6770	6908	}
6771	6909

		@@ -6772,18 +6910,18 @@
6772	6910	newstack[15LLU] = 9876543210LLU; // overflow-marker
6773	6911	// call copytype from copyletdef
6774	6912	newstack[0] = (uint64_t)stack; // backup stack location
6775		- newstack[1] = 503LLU;
	6913	+ newstack[1] = 523LLU;
6776	6914	newstack[2] = base;
6777		- newstack[3] = 504LLU;
	6915	+ newstack[3] = 524LLU;
6778	6916	// arguments for call to copytype
6779	6917	newstack[5LLU] = stack[base + 2]/type/;
6780	6918	stack = newstack;
6781	6919	// set stack-base & callee-address
6782	6920	base = 4/deloffset/;
6783		- label = 322LLU; // copytype
	6921	+ label = 326LLU; // copytype
6784	6922	break;
6785	6923	}
6786		- case 503LLU: // copy-back deleter (copytype to copyletdef)
	6924	+ case 523LLU: // copy-back deleter (copytype to copyletdef)
6787	6925	{
6788	6926	fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
6789	6927	uint64_t oldstack = (uint64_t )stack[0];

		@@ -6795,10 +6933,10 @@
6795	6933	}
6796	6934	Free(15LLU + 1, sizeof(uint64_t), stack);
6797	6935	stack = oldstack;
6798		- label = 500LLU; // continue to unroll stack
	6936	+ label = 522LLU; // continue to unroll stack
6799	6937	break;
6800	6938	}
6801		- case 504LLU: // return from copytype to copyletdef
	6939	+ case 524LLU: // return from copytype to copyletdef
6802	6940	{
6803	6941	uint64_t oldstack = (uint64_t )stack[0];
6804	6942	// copy mutable arguments back from call to copytype

		@@ -6811,16 +6949,16 @@
6811	6949	}
6812	6950	Free(15LLU + 1, sizeof(uint64_t), stack);
6813	6951	stack = oldstack;
6814		- label = 506LLU; // skip deleter
	6952	+ label = 526LLU; // skip deleter
6815	6953	break;
6816	6954	}
6817		- case 505LLU: // deleter
	6955	+ case 525LLU: // deleter
6818	6956	{
6819	6957	// throw from copyletdef
6820	6958	if(!stack[base + 0])
6821	6959	{
6822	6960	fprintf(stderr, "in function copyletdef: unrolling stack, skipping already deleted/unscoped variable letdef \n");
6823		- label = 500LLU; // skip, variable already deleted/unscoped
	6961	+ label = 522LLU; // skip, variable already deleted/unscoped
6824	6962	break;
6825	6963	}
6826	6964	fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");

		@@ -6830,28 +6968,28 @@
6830	6968	newstack[0] = (uint64_t)stack; // backup stack location
6831	6969	newstack[1] = 1234567890;
6832	6970	newstack[2] = base;
6833		- newstack[3] = 507LLU;
	6971	+ newstack[3] = 527LLU;
6834	6972	stack = newstack;
6835	6973	// set stack-base & callee-address
6836	6974	base = 4/deloffset/;
6837		- label = 438LLU; // ~letdef
	6975	+ label = 455LLU; // ~letdef
6838	6976	break;
6839	6977	}
6840		- case 507LLU: // return from ~letdef to copyletdef
	6978	+ case 527LLU: // return from ~letdef to copyletdef
6841	6979	{
6842	6980	stack = (uint64_t *)stack[0];
6843	6981	// releasing toplevel container
6844	6982	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
6845	6983
6846		- label = 500LLU; // continue unrolling stack, delete next variable
	6984	+ label = 522LLU; // continue unrolling stack, delete next variable
6847	6985	break;
6848	6986	}
6849		- case 506LLU: // skipped deleter
	6987	+ case 526LLU: // skipped deleter
6850	6988	{
6851	6989	// construct letdef.letdef
6852	6990	if(!(stack[base + 0] = construct(5)))
6853	6991	{
6854		- label = 500LLU; // throw: begin to unroll stack
	6992	+ label = 522LLU; // throw: begin to unroll stack
6855	6993	break;
6856	6994	}
6857	6995

		@@ -6867,15 +7005,25 @@
6867	7005	((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
6868	7006	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
6869	7007	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
6870		- label = 501LLU; // case complete
	7008	+ label = 520LLU; // case complete
6871	7009	break;
6872	7010	}
6873		- case 502LLU: // try next case
	7011	+ case 522LLU: // copy-back deleter (switch)
6874	7012	{
	7013	+ ((uint64_t **)(stack[base + 1]))[1][4] = stack[base + 6];
	7014	+ ((uint64_t **)(stack[base + 1]))[1][3] = stack[base + 5];
	7015	+ ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
	7016	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	7017	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	7018	+ label = 519LLU; // continue to unroll stack
	7019	+ break;
	7020	+ }
	7021	+ case 521LLU: // try next case
	7022	+ {
6875	7023	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
6876	7024	exit(-1);
6877	7025	}
6878		- case 501LLU: // completed switch
	7026	+ case 520LLU: // completed switch
6879	7027	{
6880	7028	// return from copyletdef
6881	7029	label = stack[base - 1];

		@@ -6882,7 +7030,7 @@
6882	7030	base = stack[base - 2];
6883	7031	break;
6884	7032	}
6885		- case 508LLU: // ~scope
	7033	+ case 528LLU: // ~scope
6886	7034	{
6887	7035	if(stack[base + 0]/variant-nr/ >= 1)
6888	7036	{

		@@ -6889,23 +7037,23 @@
6889	7037	fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
6890	7038	exit(-1);
6891	7039	}
6892		- label = 508LLU + 1LLU + stack[base + 0]/variant-nr/;
	7040	+ label = 528LLU + 1LLU + stack[base + 0]/variant-nr/;
6893	7041	break;
6894	7042	}
6895		- case 508LLU + 1LLU + 0LLU: // ~scope.scope
	7043	+ case 528LLU + 1LLU + 0LLU: // ~scope.scope
6896	7044	{
6897	7045	// release element deleteaddr
6898	7046	// release element letdefs
6899	7047	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[1/element-nr*/];
6900	7048	// delete list
6901		- label = 510LLU; // start to repeat
	7049	+ label = 530LLU; // start to repeat
6902	7050	break;
6903	7051	}
6904		- case 510LLU: // repeat from here
	7052	+ case 530LLU: // repeat from here
6905	7053	{
6906	7054	if(!stack[base + 0])
6907	7055	{
6908		- label = 511LLU; // break loop
	7056	+ label = 531LLU; // break loop
6909	7057	break;
6910	7058	}
6911	7059

		@@ -6916,14 +7064,14 @@
6916	7064	newstack[0] = (uint64_t)stack; // backup stack location
6917	7065	newstack[1] = 1234567890;
6918	7066	newstack[2] = base;
6919		- newstack[3] = 512LLU;
	7067	+ newstack[3] = 532LLU;
6920	7068	stack = newstack;
6921	7069	// set stack-base & callee-address
6922	7070	base = 4/deloffset/;
6923		- label = 438LLU; // ~letdef
	7071	+ label = 455LLU; // ~letdef
6924	7072	break;
6925	7073	}
6926		- case 512LLU: // return from ~letdef to scope
	7074	+ case 532LLU: // return from ~letdef to scope
6927	7075	{
6928	7076	stack = (uint64_t *)stack[0];
6929	7077	// releasing toplevel container

		@@ -6934,10 +7082,10 @@
6934	7082	stack[base + 0] = (uint64_t)list->next;
6935	7083	Free(1, sizeof(struct listnode), list);
6936	7084	}
6937		- label = 510LLU; // repeat
	7085	+ label = 530LLU; // repeat
6938	7086	break;
6939	7087	}
6940		- case 511LLU: // loop finished
	7088	+ case 531LLU: // loop finished
6941	7089	{
6942	7090	// release variant container
6943	7091	Free(2, sizeof(uint64_t), ((uint64_t )stack[base + 1]/variant*/));

		@@ -6945,7 +7093,7 @@
6945	7093	base = stack[base - 2];
6946	7094	break;
6947	7095	}
6948		- case 514LLU: // function emptyscope failed
	7096	+ case 534LLU: // function emptyscope failed
6949	7097	{
6950	7098	fprintf(stderr, "function emptyscope failed\n");
6951	7099	label = stack[base - 3];

		@@ -6952,50 +7100,50 @@
6952	7100	base = stack[base - 2];
6953	7101	break;
6954	7102	}
6955		- case 513LLU: // emptyscope
	7103	+ case 533LLU: // emptyscope
6956	7104	{
6957	7105	//#define res0 0
6958		- label = 516LLU; // skip deleter
	7106	+ label = 536LLU; // skip deleter
6959	7107	break;
6960	7108	}
6961		- case 515LLU: // deleter
	7109	+ case 535LLU: // deleter
6962	7110	{
6963	7111	// throw from emptyscope
6964	7112	if(!stack[base + 1])
6965	7113	{
6966	7114	fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable u64 \n");
6967		- label = 514LLU; // skip, variable already deleted/unscoped
	7115	+ label = 534LLU; // skip, variable already deleted/unscoped
6968	7116	break;
6969	7117	}
6970	7118	fprintf(stderr, "in function emptyscope: unrolling stack, variable u64 \n");
6971		- label = 514LLU; // continue unrolling stack, delete next variable
	7119	+ label = 534LLU; // continue unrolling stack, delete next variable
6972	7120	break;
6973	7121	}
6974		- case 516LLU: // skipped deleter
	7122	+ case 536LLU: // skipped deleter
6975	7123	{
6976	7124	stack[base + 1] = 1234567890;
6977		- label = 518LLU; // skip deleter
	7125	+ label = 538LLU; // skip deleter
6978	7126	break;
6979	7127	}
6980		- case 517LLU: // deleter
	7128	+ case 537LLU: // deleter
6981	7129	{
6982	7130	// throw from emptyscope
6983	7131	if(!stack[base + 2])
6984	7132	{
6985	7133	fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
6986		- label = 515LLU; // skip, variable already deleted/unscoped
	7134	+ label = 535LLU; // skip, variable already deleted/unscoped
6987	7135	break;
6988	7136	}
6989	7137	fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] \n");
6990	7138	// delete list
6991		- label = 519LLU; // start to repeat
	7139	+ label = 539LLU; // start to repeat
6992	7140	break;
6993	7141	}
6994		- case 519LLU: // repeat from here
	7142	+ case 539LLU: // repeat from here
6995	7143	{
6996	7144	if(!stack[base + 2])
6997	7145	{
6998		- label = 520LLU; // break loop
	7146	+ label = 540LLU; // break loop
6999	7147	break;
7000	7148	}
7001	7149

		@@ -7006,14 +7154,14 @@
7006	7154	newstack[0] = (uint64_t)stack; // backup stack location
7007	7155	newstack[1] = 1234567890;
7008	7156	newstack[2] = base;
7009		- newstack[3] = 521LLU;
	7157	+ newstack[3] = 541LLU;
7010	7158	stack = newstack;
7011	7159	// set stack-base & callee-address
7012	7160	base = 4/deloffset/;
7013		- label = 438LLU; // ~letdef
	7161	+ label = 455LLU; // ~letdef
7014	7162	break;
7015	7163	}
7016		- case 521LLU: // return from ~letdef to emptyscope
	7164	+ case 541LLU: // return from ~letdef to emptyscope
7017	7165	{
7018	7166	stack = (uint64_t *)stack[0];
7019	7167	// releasing toplevel container

		@@ -7024,27 +7172,27 @@
7024	7172	stack[base + 2] = (uint64_t)list->next;
7025	7173	Free(1, sizeof(struct listnode), list);
7026	7174	}
7027		- label = 519LLU; // repeat
	7175	+ label = 539LLU; // repeat
7028	7176	break;
7029	7177	}
7030		- case 520LLU: // loop finished
	7178	+ case 540LLU: // loop finished
7031	7179	{
7032		- label = 515LLU; // continue unrolling stack, delete next variable
	7180	+ label = 535LLU; // continue unrolling stack, delete next variable
7033	7181	break;
7034	7182	}
7035		- case 518LLU: // skipped deleter
	7183	+ case 538LLU: // skipped deleter
7036	7184	{
7037	7185	stack[base + 2] = 0;
7038		- label = 523LLU; // skip deleter
	7186	+ label = 543LLU; // skip deleter
7039	7187	break;
7040	7188	}
7041		- case 522LLU: // deleter
	7189	+ case 542LLU: // deleter
7042	7190	{
7043	7191	// throw from emptyscope
7044	7192	if(!stack[base + 0])
7045	7193	{
7046	7194	fprintf(stderr, "in function emptyscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7047		- label = 517LLU; // skip, variable already deleted/unscoped
	7195	+ label = 537LLU; // skip, variable already deleted/unscoped
7048	7196	break;
7049	7197	}
7050	7198	fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");

		@@ -7054,28 +7202,28 @@
7054	7202	newstack[0] = (uint64_t)stack; // backup stack location
7055	7203	newstack[1] = 1234567890;
7056	7204	newstack[2] = base;
7057		- newstack[3] = 524LLU;
	7205	+ newstack[3] = 544LLU;
7058	7206	stack = newstack;
7059	7207	// set stack-base & callee-address
7060	7208	base = 4/deloffset/;
7061		- label = 508LLU; // ~scope
	7209	+ label = 528LLU; // ~scope
7062	7210	break;
7063	7211	}
7064		- case 524LLU: // return from ~scope to emptyscope
	7212	+ case 544LLU: // return from ~scope to emptyscope
7065	7213	{
7066	7214	stack = (uint64_t *)stack[0];
7067	7215	// releasing toplevel container
7068	7216	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7069	7217
7070		- label = 517LLU; // continue unrolling stack, delete next variable
	7218	+ label = 537LLU; // continue unrolling stack, delete next variable
7071	7219	break;
7072	7220	}
7073		- case 523LLU: // skipped deleter
	7221	+ case 543LLU: // skipped deleter
7074	7222	{
7075	7223	// construct scope.scope
7076	7224	if(!(stack[base + 0] = construct(2)))
7077	7225	{
7078		- label = 517LLU; // throw: begin to unroll stack
	7226	+ label = 537LLU; // throw: begin to unroll stack
7079	7227	break;
7080	7228	}
7081	7229

		@@ -7088,7 +7236,7 @@
7088	7236	base = stack[base - 2];
7089	7237	break;
7090	7238	}
7091		- case 526LLU: // function chainscope failed
	7239	+ case 546LLU: // function chainscope failed
7092	7240	{
7093	7241	fprintf(stderr, "function chainscope failed\n");
7094	7242	label = stack[base - 3];

		@@ -7095,32 +7243,32 @@
7095	7243	base = stack[base - 2];
7096	7244	break;
7097	7245	}
7098		- case 525LLU: // chainscope
	7246	+ case 545LLU: // chainscope
7099	7247	{
7100	7248	//#define res0 0
7101	7249	//#define arg0 1
7102		- label = 528LLU; // skip deleter
	7250	+ label = 548LLU; // skip deleter
7103	7251	break;
7104	7252	}
7105		- case 527LLU: // deleter
	7253	+ case 547LLU: // deleter
7106	7254	{
7107	7255	// throw from chainscope
7108	7256	if(!stack[base + 2])
7109	7257	{
7110	7258	fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
7111		- label = 526LLU; // skip, variable already deleted/unscoped
	7259	+ label = 546LLU; // skip, variable already deleted/unscoped
7112	7260	break;
7113	7261	}
7114	7262	fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] \n");
7115	7263	// delete list
7116		- label = 529LLU; // start to repeat
	7264	+ label = 549LLU; // start to repeat
7117	7265	break;
7118	7266	}
7119		- case 529LLU: // repeat from here
	7267	+ case 549LLU: // repeat from here
7120	7268	{
7121	7269	if(!stack[base + 2])
7122	7270	{
7123		- label = 530LLU; // break loop
	7271	+ label = 550LLU; // break loop
7124	7272	break;
7125	7273	}
7126	7274

		@@ -7131,14 +7279,14 @@
7131	7279	newstack[0] = (uint64_t)stack; // backup stack location
7132	7280	newstack[1] = 1234567890;
7133	7281	newstack[2] = base;
7134		- newstack[3] = 531LLU;
	7282	+ newstack[3] = 551LLU;
7135	7283	stack = newstack;
7136	7284	// set stack-base & callee-address
7137	7285	base = 4/deloffset/;
7138		- label = 438LLU; // ~letdef
	7286	+ label = 455LLU; // ~letdef
7139	7287	break;
7140	7288	}
7141		- case 531LLU: // return from ~letdef to chainscope
	7289	+ case 551LLU: // return from ~letdef to chainscope
7142	7290	{
7143	7291	stack = (uint64_t *)stack[0];
7144	7292	// releasing toplevel container

		@@ -7149,27 +7297,27 @@
7149	7297	stack[base + 2] = (uint64_t)list->next;
7150	7298	Free(1, sizeof(struct listnode), list);
7151	7299	}
7152		- label = 529LLU; // repeat
	7300	+ label = 549LLU; // repeat
7153	7301	break;
7154	7302	}
7155		- case 530LLU: // loop finished
	7303	+ case 550LLU: // loop finished
7156	7304	{
7157		- label = 526LLU; // continue unrolling stack, delete next variable
	7305	+ label = 546LLU; // continue unrolling stack, delete next variable
7158	7306	break;
7159	7307	}
7160		- case 528LLU: // skipped deleter
	7308	+ case 548LLU: // skipped deleter
7161	7309	{
7162	7310	stack[base + 2] = 0;
7163		- label = 533LLU; // skip deleter
	7311	+ label = 553LLU; // skip deleter
7164	7312	break;
7165	7313	}
7166		- case 532LLU: // deleter
	7314	+ case 552LLU: // deleter
7167	7315	{
7168	7316	// throw from chainscope
7169	7317	if(!stack[base + 0])
7170	7318	{
7171	7319	fprintf(stderr, "in function chainscope: unrolling stack, skipping already deleted/unscoped variable scope \n");
7172		- label = 527LLU; // skip, variable already deleted/unscoped
	7320	+ label = 547LLU; // skip, variable already deleted/unscoped
7173	7321	break;
7174	7322	}
7175	7323	fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");

		@@ -7179,28 +7327,28 @@
7179	7327	newstack[0] = (uint64_t)stack; // backup stack location
7180	7328	newstack[1] = 1234567890;
7181	7329	newstack[2] = base;
7182		- newstack[3] = 534LLU;
	7330	+ newstack[3] = 554LLU;
7183	7331	stack = newstack;
7184	7332	// set stack-base & callee-address
7185	7333	base = 4/deloffset/;
7186		- label = 508LLU; // ~scope
	7334	+ label = 528LLU; // ~scope
7187	7335	break;
7188	7336	}
7189		- case 534LLU: // return from ~scope to chainscope
	7337	+ case 554LLU: // return from ~scope to chainscope
7190	7338	{
7191	7339	stack = (uint64_t *)stack[0];
7192	7340	// releasing toplevel container
7193	7341	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
7194	7342
7195		- label = 527LLU; // continue unrolling stack, delete next variable
	7343	+ label = 547LLU; // continue unrolling stack, delete next variable
7196	7344	break;
7197	7345	}
7198		- case 533LLU: // skipped deleter
	7346	+ case 553LLU: // skipped deleter
7199	7347	{
7200	7348	// construct scope.scope
7201	7349	if(!(stack[base + 0] = construct(2)))
7202	7350	{
7203		- label = 527LLU; // throw: begin to unroll stack
	7351	+ label = 547LLU; // throw: begin to unroll stack
7204	7352	break;
7205	7353	}
7206	7354

		@@ -7213,7 +7361,7 @@
7213	7361	base = stack[base - 2];
7214	7362	break;
7215	7363	}
7216		- case 536LLU: // function linkscope failed
	7364	+ case 556LLU: // function linkscope failed
7217	7365	{
7218	7366	fprintf(stderr, "function linkscope failed\n");
7219	7367	label = stack[base - 3];

		@@ -7220,13 +7368,13 @@
7220	7368	base = stack[base - 2];
7221	7369	break;
7222	7370	}
7223		- case 535LLU: // linkscope
	7371	+ case 555LLU: // linkscope
7224	7372	{
7225	7373	//#define res0 0
7226	7374	//#define arg0 1
7227	7375	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7228	7376	{
7229		- label = 538LLU; // jump to alternative
	7377	+ label = 558LLU; // jump to alternative
7230	7378	break;
7231	7379	}
7232	7380

		@@ -7235,24 +7383,24 @@
7235	7383
7236	7384	// case
7237	7385	// call chainscope from linkscope
7238		- stack[base + 4LLU] = 539LLU/throw to this address/;
	7386	+ stack[base + 4LLU] = 560LLU/throw to this address/;
7239	7387	stack[base + 5LLU] = base;
7240		- stack[base + 6LLU] = 540LLU;
	7388	+ stack[base + 6LLU] = 561LLU;
7241	7389	// arguments for call to chainscope
7242	7390	stack[base + 8LLU] = stack[base + 2]/labelthrow/;
7243	7391	// set stack-base & callee-address
7244	7392	base += 7LLU;
7245		- label = 525LLU; // chainscope
	7393	+ label = 545LLU; // chainscope
7246	7394	break;
7247	7395	}
7248		- case 539LLU: // copy-back deleter (chainscope to linkscope)
	7396	+ case 560LLU: // copy-back deleter (chainscope to linkscope)
7249	7397	{
7250	7398	fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
7251	7399	// copy mutable arguments back from call to chainscope
7252		- label = 536LLU; // continue to roll stack
	7400	+ label = 559LLU; // continue to roll stack
7253	7401	break;
7254	7402	}
7255		- case 540LLU: // return from chainscope to linkscope
	7403	+ case 561LLU: // return from chainscope to linkscope
7256	7404	{
7257	7405	// copy mutable arguments back from call to chainscope
7258	7406	// copy back results provided by call to chainscope

		@@ -7259,15 +7407,22 @@
7259	7407	stack[base + 0] = stack[base + 7LLU];
7260	7408	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7261	7409	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7262		- label = 537LLU; // case complete
	7410	+ label = 557LLU; // case complete
7263	7411	break;
7264	7412	}
7265		- case 538LLU: // try next case
	7413	+ case 559LLU: // copy-back deleter (switch)
7266	7414	{
	7415	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	7416	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	7417	+ label = 556LLU; // continue to unroll stack
	7418	+ break;
	7419	+ }
	7420	+ case 558LLU: // try next case
	7421	+ {
7267	7422	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7268	7423	exit(-1);
7269	7424	}
7270		- case 537LLU: // completed switch
	7425	+ case 557LLU: // completed switch
7271	7426	{
7272	7427	// return from linkscope
7273	7428	label = stack[base - 1];

		@@ -7274,7 +7429,7 @@
7274	7429	base = stack[base - 2];
7275	7430	break;
7276	7431	}
7277		- case 542LLU: // function getdeladdr failed
	7432	+ case 563LLU: // function getdeladdr failed
7278	7433	{
7279	7434	fprintf(stderr, "function getdeladdr failed\n");
7280	7435	label = stack[base - 3];

		@@ -7281,13 +7436,13 @@
7281	7436	base = stack[base - 2];
7282	7437	break;
7283	7438	}
7284		- case 541LLU: // getdeladdr
	7439	+ case 562LLU: // getdeladdr
7285	7440	{
7286	7441	//#define res0 0
7287	7442	//#define arg0 1
7288	7443	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
7289	7444	{
7290		- label = 544LLU; // jump to alternative
	7445	+ label = 565LLU; // jump to alternative
7291	7446	break;
7292	7447	}
7293	7448

		@@ -7295,36 +7450,43 @@
7295	7450	/letdefs/stack[base + 3] = ((uint64_t *)(stack[base + 1]/scope/))[1][1]/letdefs*/;
7296	7451
7297	7452	// case
7298		- label = 546LLU; // skip deleter
	7453	+ label = 568LLU; // skip deleter
7299	7454	break;
7300	7455	}
7301		- case 545LLU: // deleter
	7456	+ case 567LLU: // deleter
7302	7457	{
7303	7458	// throw from getdeladdr
7304	7459	if(!stack[base + 0])
7305	7460	{
7306	7461	fprintf(stderr, "in function getdeladdr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7307		- label = 542LLU; // skip, variable already deleted/unscoped
	7462	+ label = 566LLU; // skip, variable already deleted/unscoped
7308	7463	break;
7309	7464	}
7310	7465	fprintf(stderr, "in function getdeladdr: unrolling stack, variable u64 \n");
7311		- label = 542LLU; // continue unrolling stack, delete next variable
	7466	+ label = 566LLU; // continue unrolling stack, delete next variable
7312	7467	break;
7313	7468	}
7314		- case 546LLU: // skipped deleter
	7469	+ case 568LLU: // skipped deleter
7315	7470	{
7316	7471	stack[base + 0] = stack[base + 2]/labelthrow/;
7317	7472	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
7318	7473	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7319		- label = 543LLU; // case complete
	7474	+ label = 564LLU; // case complete
7320	7475	break;
7321	7476	}
7322		- case 544LLU: // try next case
	7477	+ case 566LLU: // copy-back deleter (switch)
7323	7478	{
	7479	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	7480	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	7481	+ label = 563LLU; // continue to unroll stack
	7482	+ break;
	7483	+ }
	7484	+ case 565LLU: // try next case
	7485	+ {
7324	7486	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7325	7487	exit(-1);
7326	7488	}
7327		- case 543LLU: // completed switch
	7489	+ case 564LLU: // completed switch
7328	7490	{
7329	7491	// return from getdeladdr
7330	7492	label = stack[base - 1];

		@@ -7331,7 +7493,7 @@
7331	7493	base = stack[base - 2];
7332	7494	break;
7333	7495	}
7334		- case 548LLU: // function existslet failed
	7496	+ case 570LLU: // function existslet failed
7335	7497	{
7336	7498	fprintf(stderr, "function existslet failed\n");
7337	7499	label = stack[base - 3];

		@@ -7338,39 +7500,39 @@
7338	7500	base = stack[base - 2];
7339	7501	break;
7340	7502	}
7341		- case 547LLU: // existslet
	7503	+ case 569LLU: // existslet
7342	7504	{
7343	7505	//#define res0 0
7344	7506	//#define arg0 1
7345	7507	//#define arg1 2
7346		- label = 550LLU; // skip deleter
	7508	+ label = 572LLU; // skip deleter
7347	7509	break;
7348	7510	}
7349		- case 549LLU: // deleter
	7511	+ case 571LLU: // deleter
7350	7512	{
7351	7513	// throw from existslet
7352	7514	if(!stack[base + 3])
7353	7515	{
7354	7516	fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7355		- label = 548LLU; // skip, variable already deleted/unscoped
	7517	+ label = 570LLU; // skip, variable already deleted/unscoped
7356	7518	break;
7357	7519	}
7358	7520	fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7359		- label = 548LLU; // continue unrolling stack, delete next variable
	7521	+ label = 570LLU; // continue unrolling stack, delete next variable
7360	7522	break;
7361	7523	}
7362		- case 550LLU: // skipped deleter
	7524	+ case 572LLU: // skipped deleter
7363	7525	{
7364	7526	stack[base + 3] = 0;
7365	7527	flippedassign(stack[base + 1]/letdefs/, &stack[base + 4]);
7366		- label = 551LLU; // start to repeat
	7528	+ label = 573LLU; // start to repeat
7367	7529	break;
7368	7530	}
7369		- case 551LLU: // repeat from here
	7531	+ case 573LLU: // repeat from here
7370	7532	{
7371	7533	if(!stack[base + 4])
7372	7534	{
7373		- label = 552LLU; // break loop
	7535	+ label = 574LLU; // break loop
7374	7536	break;
7375	7537	}
7376	7538

		@@ -7380,19 +7542,19 @@
7380	7542	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
7381	7543	if(!stack[base + 3]/found/)
7382	7544	{
7383		- label = 553LLU; // jump to alternative
	7545	+ label = 575LLU; // jump to alternative
7384	7546	break;
7385	7547	}
7386	7548
7387	7549	// consequent
7388		- label = 554LLU; // consequent complete
	7550	+ label = 576LLU; // consequent complete
7389	7551	break;
7390	7552	}
7391		- case 553LLU: // alternative
	7553	+ case 575LLU: // alternative
7392	7554	{
7393	7555	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
7394	7556	{
7395		- label = 556LLU; // jump to alternative
	7557	+ label = 578LLU; // jump to alternative
7396	7558	break;
7397	7559	}
7398	7560

		@@ -7404,9 +7566,9 @@
7404	7566
7405	7567	// case
7406	7568	// call equ from existslet
7407		- stack[base + 12LLU] = 557LLU/throw to this address/;
	7569	+ stack[base + 12LLU] = 580LLU/throw to this address/;
7408	7570	stack[base + 13LLU] = base;
7409		- stack[base + 14LLU] = 558LLU;
	7571	+ stack[base + 14LLU] = 581LLU;
7410	7572	// arguments for call to equ
7411	7573	stack[base + 16LLU] = stack[base + 8]/curid/;
7412	7574	stack[base + 17LLU] = stack[base + 2]/id/;

		@@ -7415,14 +7577,14 @@
7415	7577	label = 18446744073709551600LLU; // equ
7416	7578	break;
7417	7579	}
7418		- case 557LLU: // copy-back deleter (equ to existslet)
	7580	+ case 580LLU: // copy-back deleter (equ to existslet)
7419	7581	{
7420	7582	fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
7421	7583	// copy mutable arguments back from call to equ
7422		- label = 549LLU; // continue to roll stack
	7584	+ label = 579LLU; // continue to roll stack
7423	7585	break;
7424	7586	}
7425		- case 558LLU: // return from equ to existslet
	7587	+ case 581LLU: // return from equ to existslet
7426	7588	{
7427	7589	// copy mutable arguments back from call to equ
7428	7590	// copy back results provided by call to equ

		@@ -7432,44 +7594,54 @@
7432	7594	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
7433	7595	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
7434	7596	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7435		- label = 555LLU; // case complete
	7597	+ label = 577LLU; // case complete
7436	7598	break;
7437	7599	}
7438		- case 556LLU: // try next case
	7600	+ case 579LLU: // copy-back deleter (switch)
7439	7601	{
	7602	+ ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 11];
	7603	+ ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 10];
	7604	+ ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
	7605	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
	7606	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
	7607	+ label = 571LLU; // continue to unroll stack
	7608	+ break;
	7609	+ }
	7610	+ case 578LLU: // try next case
	7611	+ {
7440	7612	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7441	7613	exit(-1);
7442	7614	}
7443		- case 555LLU: // completed switch
	7615	+ case 577LLU: // completed switch
7444	7616	{
7445		- label = 554LLU; // alternative complete
	7617	+ label = 576LLU; // alternative complete
7446	7618	break;
7447	7619	}
7448		- case 554LLU: // completed if-then-else
	7620	+ case 576LLU: // completed if-then-else
7449	7621	{
7450	7622	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
7451		- label = 551LLU; // repeat
	7623	+ label = 573LLU; // repeat
7452	7624	break;
7453	7625	}
7454		- case 552LLU: // loop finished
	7626	+ case 574LLU: // loop finished
7455	7627	{
7456		- label = 560LLU; // skip deleter
	7628	+ label = 583LLU; // skip deleter
7457	7629	break;
7458	7630	}
7459		- case 559LLU: // deleter
	7631	+ case 582LLU: // deleter
7460	7632	{
7461	7633	// throw from existslet
7462	7634	if(!stack[base + 0])
7463	7635	{
7464	7636	fprintf(stderr, "in function existslet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7465		- label = 549LLU; // skip, variable already deleted/unscoped
	7637	+ label = 571LLU; // skip, variable already deleted/unscoped
7466	7638	break;
7467	7639	}
7468	7640	fprintf(stderr, "in function existslet: unrolling stack, variable u64 \n");
7469		- label = 549LLU; // continue unrolling stack, delete next variable
	7641	+ label = 571LLU; // continue unrolling stack, delete next variable
7470	7642	break;
7471	7643	}
7472		- case 560LLU: // skipped deleter
	7644	+ case 583LLU: // skipped deleter
7473	7645	{
7474	7646	stack[base + 0] = stack[base + 3]/found/;
7475	7647	// return from existslet

		@@ -7477,7 +7649,7 @@
7477	7649	base = stack[base - 2];
7478	7650	break;
7479	7651	}
7480		- case 562LLU: // function FindLetNew failed
	7652	+ case 585LLU: // function FindLetNew failed
7481	7653	{
7482	7654	fprintf(stderr, "function FindLetNew failed\n");
7483	7655	label = stack[base - 3];

		@@ -7484,7 +7656,7 @@
7484	7656	base = stack[base - 2];
7485	7657	break;
7486	7658	}
7487		- case 561LLU: // FindLetNew
	7659	+ case 584LLU: // FindLetNew
7488	7660	{
7489	7661	//#define res0 0
7490	7662	//#define arg0 1

		@@ -7492,87 +7664,87 @@
7492	7664	//#define arg2 3
7493	7665	//#define arg3 4
7494	7666	// call mkletdummy from FindLetNew
7495		- stack[base + 6LLU] = 563LLU/throw to this address/;
	7667	+ stack[base + 6LLU] = 586LLU/throw to this address/;
7496	7668	stack[base + 7LLU] = base;
7497		- stack[base + 8LLU] = 564LLU;
	7669	+ stack[base + 8LLU] = 587LLU;
7498	7670	// arguments for call to mkletdummy
7499	7671	// set stack-base & callee-address
7500	7672	base += 9LLU;
7501		- label = 441LLU; // mkletdummy
	7673	+ label = 458LLU; // mkletdummy
7502	7674	break;
7503	7675	}
7504		- case 563LLU: // copy-back deleter (mkletdummy to FindLetNew)
	7676	+ case 586LLU: // copy-back deleter (mkletdummy to FindLetNew)
7505	7677	{
7506	7678	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (mkletdummy to FindLetNew)\n");
7507	7679	// copy mutable arguments back from call to mkletdummy
7508		- label = 562LLU; // continue to roll stack
	7680	+ label = 585LLU; // continue to roll stack
7509	7681	break;
7510	7682	}
7511		- case 564LLU: // return from mkletdummy to FindLetNew
	7683	+ case 587LLU: // return from mkletdummy to FindLetNew
7512	7684	{
7513	7685	// copy mutable arguments back from call to mkletdummy
7514	7686	// copy back results provided by call to mkletdummy
7515	7687	stack[base + 5] = stack[base + 9LLU];
7516		- label = 566LLU; // skip deleter
	7688	+ label = 589LLU; // skip deleter
7517	7689	break;
7518	7690	}
7519		- case 565LLU: // deleter
	7691	+ case 588LLU: // deleter
7520	7692	{
7521	7693	// throw from FindLetNew
7522	7694	if(!stack[base + 6])
7523	7695	{
7524	7696	fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7525		- label = 562LLU; // skip, variable already deleted/unscoped
	7697	+ label = 585LLU; // skip, variable already deleted/unscoped
7526	7698	break;
7527	7699	}
7528	7700	fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7529		- label = 562LLU; // continue unrolling stack, delete next variable
	7701	+ label = 585LLU; // continue unrolling stack, delete next variable
7530	7702	break;
7531	7703	}
7532		- case 566LLU: // skipped deleter
	7704	+ case 589LLU: // skipped deleter
7533	7705	{
7534	7706	stack[base + 6] = 0;
7535		- label = 568LLU; // skip deleter
	7707	+ label = 591LLU; // skip deleter
7536	7708	break;
7537	7709	}
7538		- case 567LLU: // deleter
	7710	+ case 590LLU: // deleter
7539	7711	{
7540	7712	// throw from FindLetNew
7541	7713	if(!stack[base + 7])
7542	7714	{
7543	7715	fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7544		- label = 565LLU; // skip, variable already deleted/unscoped
	7716	+ label = 588LLU; // skip, variable already deleted/unscoped
7545	7717	break;
7546	7718	}
7547	7719	fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7548		- label = 565LLU; // continue unrolling stack, delete next variable
	7720	+ label = 588LLU; // continue unrolling stack, delete next variable
7549	7721	break;
7550	7722	}
7551		- case 568LLU: // skipped deleter
	7723	+ case 591LLU: // skipped deleter
7552	7724	{
7553	7725	stack[base + 7] = 0;
7554		- label = 570LLU; // skip deleter
	7726	+ label = 593LLU; // skip deleter
7555	7727	break;
7556	7728	}
7557		- case 569LLU: // deleter
	7729	+ case 592LLU: // deleter
7558	7730	{
7559	7731	// throw from FindLetNew
7560	7732	if(!stack[base + 8])
7561	7733	{
7562	7734	fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable u64 \n");
7563		- label = 567LLU; // skip, variable already deleted/unscoped
	7735	+ label = 590LLU; // skip, variable already deleted/unscoped
7564	7736	break;
7565	7737	}
7566	7738	fprintf(stderr, "in function FindLetNew: unrolling stack, variable u64 \n");
7567		- label = 567LLU; // continue unrolling stack, delete next variable
	7739	+ label = 590LLU; // continue unrolling stack, delete next variable
7568	7740	break;
7569	7741	}
7570		- case 570LLU: // skipped deleter
	7742	+ case 593LLU: // skipped deleter
7571	7743	{
7572	7744	stack[base + 8] = 0;
7573	7745	if(/scope/0 != ((uint64_t )(stack[base + 4]/SCOPE*/))[0])
7574	7746	{
7575		- label = 572LLU; // jump to alternative
	7747	+ label = 595LLU; // jump to alternative
7576	7748	break;
7577	7749	}
7578	7750

		@@ -7581,14 +7753,14 @@
7581	7753
7582	7754	// case
7583	7755	flippedassign(stack[base + 10]/scope/, &stack[base + 11]);
7584		- label = 573LLU; // start to repeat
	7756	+ label = 597LLU; // start to repeat
7585	7757	break;
7586	7758	}
7587		- case 573LLU: // repeat from here
	7759	+ case 597LLU: // repeat from here
7588	7760	{
7589	7761	if(!stack[base + 11])
7590	7762	{
7591		- label = 574LLU; // break loop
	7763	+ label = 598LLU; // break loop
7592	7764	break;
7593	7765	}
7594	7766

		@@ -7598,19 +7770,19 @@
7598	7770	stack[base + 11] = (uint64_t)(((const struct listnode *)(stack[base + 11]))->next);
7599	7771	if(!stack[base + 8]/found/)
7600	7772	{
7601		- label = 575LLU; // jump to alternative
	7773	+ label = 599LLU; // jump to alternative
7602	7774	break;
7603	7775	}
7604	7776
7605	7777	// consequent
7606		- label = 576LLU; // consequent complete
	7778	+ label = 600LLU; // consequent complete
7607	7779	break;
7608	7780	}
7609		- case 575LLU: // alternative
	7781	+ case 599LLU: // alternative
7610	7782	{
7611	7783	if(/letdef/0 != ((uint64_t )(stack[base + 12]/letdef*/))[0])
7612	7784	{
7613		- label = 578LLU; // jump to alternative
	7785	+ label = 602LLU; // jump to alternative
7614	7786	break;
7615	7787	}
7616	7788

		@@ -7622,9 +7794,9 @@
7622	7794
7623	7795	// case
7624	7796	// call equ from FindLetNew
7625		- stack[base + 19LLU] = 579LLU/throw to this address/;
	7797	+ stack[base + 19LLU] = 604LLU/throw to this address/;
7626	7798	stack[base + 20LLU] = base;
7627		- stack[base + 21LLU] = 580LLU;
	7799	+ stack[base + 21LLU] = 605LLU;
7628	7800	// arguments for call to equ
7629	7801	stack[base + 23LLU] = stack[base + 15]/curid/;
7630	7802	stack[base + 24LLU] = stack[base + 2]/id/;

		@@ -7633,14 +7805,14 @@
7633	7805	label = 18446744073709551600LLU; // equ
7634	7806	break;
7635	7807	}
7636		- case 579LLU: // copy-back deleter (equ to FindLetNew)
	7808	+ case 604LLU: // copy-back deleter (equ to FindLetNew)
7637	7809	{
7638	7810	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
7639	7811	// copy mutable arguments back from call to equ
7640		- label = 569LLU; // continue to roll stack
	7812	+ label = 603LLU; // continue to roll stack
7641	7813	break;
7642	7814	}
7643		- case 580LLU: // return from equ to FindLetNew
	7815	+ case 605LLU: // return from equ to FindLetNew
7644	7816	{
7645	7817	// copy mutable arguments back from call to equ
7646	7818	// copy back results provided by call to equ

		@@ -7647,30 +7819,30 @@
7647	7819	stack[base + 8] = stack[base + 22LLU];
7648	7820	if(!stack[base + 8]/found/)
7649	7821	{
7650		- label = 581LLU; // jump to alternative
	7822	+ label = 606LLU; // jump to alternative
7651	7823	break;
7652	7824	}
7653	7825
7654	7826	// consequent
7655	7827	// call copyletdef from FindLetNew
7656		- stack[base + 20LLU] = 583LLU/throw to this address/;
	7828	+ stack[base + 20LLU] = 608LLU/throw to this address/;
7657	7829	stack[base + 21LLU] = base;
7658		- stack[base + 22LLU] = 584LLU;
	7830	+ stack[base + 22LLU] = 609LLU;
7659	7831	// arguments for call to copyletdef
7660	7832	stack[base + 24LLU] = stack[base + 12]/letdef/;
7661	7833	// set stack-base & callee-address
7662	7834	base += 23LLU;
7663		- label = 499LLU; // copyletdef
	7835	+ label = 518LLU; // copyletdef
7664	7836	break;
7665	7837	}
7666		- case 583LLU: // copy-back deleter (copyletdef to FindLetNew)
	7838	+ case 608LLU: // copy-back deleter (copyletdef to FindLetNew)
7667	7839	{
7668	7840	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
7669	7841	// copy mutable arguments back from call to copyletdef
7670		- label = 569LLU; // continue to roll stack
	7842	+ label = 603LLU; // continue to roll stack
7671	7843	break;
7672	7844	}
7673		- case 584LLU: // return from copyletdef to FindLetNew
	7845	+ case 609LLU: // return from copyletdef to FindLetNew
7674	7846	{
7675	7847	// copy mutable arguments back from call to copyletdef
7676	7848	// copy back results provided by call to copyletdef

		@@ -7682,28 +7854,28 @@
7682	7854	newstack[0] = (uint64_t)stack; // backup stack location
7683	7855	newstack[1] = 1234567890;
7684	7856	newstack[2] = base;
7685		- newstack[3] = 585LLU;
	7857	+ newstack[3] = 610LLU;
7686	7858	stack = newstack;
7687	7859	// set stack-base & callee-address
7688	7860	base = 4/deloffset/;
7689		- label = 438LLU; // ~letdef
	7861	+ label = 455LLU; // ~letdef
7690	7862	break;
7691	7863	}
7692		- case 585LLU: // return from ~letdef to FindLetNew
	7864	+ case 610LLU: // return from ~letdef to FindLetNew
7693	7865	{
7694	7866	stack = (uint64_t *)stack[0];
7695	7867	// releasing toplevel container
7696	7868	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 19] - sizeof(uint64_t) 4));
7697	7869
7698		- label = 582LLU; // consequent complete
	7870	+ label = 607LLU; // consequent complete
7699	7871	break;
7700	7872	}
7701		- case 581LLU: // alternative
	7873	+ case 606LLU: // alternative
7702	7874	{
7703		- label = 582LLU; // alternative complete
	7875	+ label = 607LLU; // alternative complete
7704	7876	break;
7705	7877	}
7706		- case 582LLU: // completed if-then-else
	7878	+ case 607LLU: // completed if-then-else
7707	7879	{
7708	7880	((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
7709	7881	((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];

		@@ -7710,60 +7882,77 @@
7710	7882	((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
7711	7883	((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
7712	7884	((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7713		- label = 577LLU; // case complete
	7885	+ label = 601LLU; // case complete
7714	7886	break;
7715	7887	}
7716		- case 578LLU: // try next case
	7888	+ case 603LLU: // copy-back deleter (switch)
7717	7889	{
	7890	+ ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
	7891	+ ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];
	7892	+ ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
	7893	+ ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
	7894	+ ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
	7895	+ label = 596LLU; // continue to unroll stack
	7896	+ break;
	7897	+ }
	7898	+ case 602LLU: // try next case
	7899	+ {
7718	7900	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7719	7901	exit(-1);
7720	7902	}
7721		- case 577LLU: // completed switch
	7903	+ case 601LLU: // completed switch
7722	7904	{
7723		- label = 576LLU; // alternative complete
	7905	+ label = 600LLU; // alternative complete
7724	7906	break;
7725	7907	}
7726		- case 576LLU: // completed if-then-else
	7908	+ case 600LLU: // completed if-then-else
7727	7909	{
7728	7910	((struct listnode )(stack[base + 13]/previous*/))->data = stack[base + 12];
7729		- label = 573LLU; // repeat
	7911	+ label = 597LLU; // repeat
7730	7912	break;
7731	7913	}
7732		- case 574LLU: // loop finished
	7914	+ case 598LLU: // loop finished
7733	7915	{
7734	7916	((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
7735	7917	((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7736		- label = 571LLU; // case complete
	7918	+ label = 594LLU; // case complete
7737	7919	break;
7738	7920	}
7739		- case 572LLU: // try next case
	7921	+ case 596LLU: // copy-back deleter (switch)
7740	7922	{
	7923	+ ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
	7924	+ ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
	7925	+ label = 592LLU; // continue to unroll stack
	7926	+ break;
	7927	+ }
	7928	+ case 595LLU: // try next case
	7929	+ {
7741	7930	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7742	7931	exit(-1);
7743	7932	}
7744		- case 571LLU: // completed switch
	7933	+ case 594LLU: // completed switch
7745	7934	{
7746	7935	if(!stack[base + 8]/found/)
7747	7936	{
7748		- label = 586LLU; // jump to alternative
	7937	+ label = 611LLU; // jump to alternative
7749	7938	break;
7750	7939	}
7751	7940
7752	7941	// consequent
7753		- label = 587LLU; // consequent complete
	7942	+ label = 612LLU; // consequent complete
7754	7943	break;
7755	7944	}
7756		- case 586LLU: // alternative
	7945	+ case 611LLU: // alternative
7757	7946	{
7758	7947	flippedassign(stack[base + 3]/scopes/, &stack[base + 9]);
7759		- label = 588LLU; // start to repeat
	7948	+ label = 613LLU; // start to repeat
7760	7949	break;
7761	7950	}
7762		- case 588LLU: // repeat from here
	7951	+ case 613LLU: // repeat from here
7763	7952	{
7764	7953	if(!stack[base + 9])
7765	7954	{
7766		- label = 589LLU; // break loop
	7955	+ label = 614LLU; // break loop
7767	7956	break;
7768	7957	}
7769	7958

		@@ -7773,19 +7962,19 @@
7773	7962	stack[base + 9] = (uint64_t)(((const struct listnode *)(stack[base + 9]))->next);
7774	7963	if(!stack[base + 8]/found/)
7775	7964	{
7776		- label = 590LLU; // jump to alternative
	7965	+ label = 615LLU; // jump to alternative
7777	7966	break;
7778	7967	}
7779	7968
7780	7969	// consequent
7781		- label = 591LLU; // consequent complete
	7970	+ label = 616LLU; // consequent complete
7782	7971	break;
7783	7972	}
7784		- case 590LLU: // alternative
	7973	+ case 615LLU: // alternative
7785	7974	{
7786	7975	if(/scope/0 != ((uint64_t )(stack[base + 10]/SCOPE*/))[0])
7787	7976	{
7788		- label = 593LLU; // jump to alternative
	7977	+ label = 618LLU; // jump to alternative
7789	7978	break;
7790	7979	}
7791	7980

		@@ -7794,14 +7983,14 @@
7794	7983
7795	7984	// case
7796	7985	flippedassign(stack[base + 13]/scope/, &stack[base + 14]);
7797		- label = 594LLU; // start to repeat
	7986	+ label = 620LLU; // start to repeat
7798	7987	break;
7799	7988	}
7800		- case 594LLU: // repeat from here
	7989	+ case 620LLU: // repeat from here
7801	7990	{
7802	7991	if(!stack[base + 14])
7803	7992	{
7804		- label = 595LLU; // break loop
	7993	+ label = 621LLU; // break loop
7805	7994	break;
7806	7995	}
7807	7996

		@@ -7811,19 +8000,19 @@
7811	8000	stack[base + 14] = (uint64_t)(((const struct listnode *)(stack[base + 14]))->next);
7812	8001	if(!stack[base + 8]/found/)
7813	8002	{
7814		- label = 596LLU; // jump to alternative
	8003	+ label = 622LLU; // jump to alternative
7815	8004	break;
7816	8005	}
7817	8006
7818	8007	// consequent
7819		- label = 597LLU; // consequent complete
	8008	+ label = 623LLU; // consequent complete
7820	8009	break;
7821	8010	}
7822		- case 596LLU: // alternative
	8011	+ case 622LLU: // alternative
7823	8012	{
7824	8013	if(!stack[base + 15]/letdef/)
7825	8014	{
7826		- label = 598LLU; // jump to alternative
	8015	+ label = 624LLU; // jump to alternative
7827	8016	break;
7828	8017	}
7829	8018

		@@ -7830,7 +8019,7 @@
7830	8019	// consequent
7831	8020	if(/letdef/0 != ((uint64_t )(stack[base + 15]/letdef*/))[0])
7832	8021	{
7833		- label = 601LLU; // jump to alternative
	8022	+ label = 627LLU; // jump to alternative
7834	8023	break;
7835	8024	}
7836	8025

		@@ -7842,9 +8031,9 @@
7842	8031
7843	8032	// case
7844	8033	// call equ from FindLetNew
7845		- stack[base + 22LLU] = 602LLU/throw to this address/;
	8034	+ stack[base + 22LLU] = 629LLU/throw to this address/;
7846	8035	stack[base + 23LLU] = base;
7847		- stack[base + 24LLU] = 603LLU;
	8036	+ stack[base + 24LLU] = 630LLU;
7848	8037	// arguments for call to equ
7849	8038	stack[base + 26LLU] = stack[base + 18]/curid/;
7850	8039	stack[base + 27LLU] = stack[base + 2]/id/;

		@@ -7853,14 +8042,14 @@
7853	8042	label = 18446744073709551600LLU; // equ
7854	8043	break;
7855	8044	}
7856		- case 602LLU: // copy-back deleter (equ to FindLetNew)
	8045	+ case 629LLU: // copy-back deleter (equ to FindLetNew)
7857	8046	{
7858	8047	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
7859	8048	// copy mutable arguments back from call to equ
7860		- label = 569LLU; // continue to roll stack
	8049	+ label = 628LLU; // continue to roll stack
7861	8050	break;
7862	8051	}
7863		- case 603LLU: // return from equ to FindLetNew
	8052	+ case 630LLU: // return from equ to FindLetNew
7864	8053	{
7865	8054	// copy mutable arguments back from call to equ
7866	8055	// copy back results provided by call to equ

		@@ -7867,30 +8056,30 @@
7867	8056	stack[base + 8] = stack[base + 25LLU];
7868	8057	if(!stack[base + 8]/found/)
7869	8058	{
7870		- label = 604LLU; // jump to alternative
	8059	+ label = 631LLU; // jump to alternative
7871	8060	break;
7872	8061	}
7873	8062
7874	8063	// consequent
7875	8064	// call copyletdef from FindLetNew
7876		- stack[base + 23LLU] = 606LLU/throw to this address/;
	8065	+ stack[base + 23LLU] = 633LLU/throw to this address/;
7877	8066	stack[base + 24LLU] = base;
7878		- stack[base + 25LLU] = 607LLU;
	8067	+ stack[base + 25LLU] = 634LLU;
7879	8068	// arguments for call to copyletdef
7880	8069	stack[base + 27LLU] = stack[base + 15]/letdef/;
7881	8070	// set stack-base & callee-address
7882	8071	base += 26LLU;
7883		- label = 499LLU; // copyletdef
	8072	+ label = 518LLU; // copyletdef
7884	8073	break;
7885	8074	}
7886		- case 606LLU: // copy-back deleter (copyletdef to FindLetNew)
	8075	+ case 633LLU: // copy-back deleter (copyletdef to FindLetNew)
7887	8076	{
7888	8077	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
7889	8078	// copy mutable arguments back from call to copyletdef
7890		- label = 569LLU; // continue to roll stack
	8079	+ label = 628LLU; // continue to roll stack
7891	8080	break;
7892	8081	}
7893		- case 607LLU: // return from copyletdef to FindLetNew
	8082	+ case 634LLU: // return from copyletdef to FindLetNew
7894	8083	{
7895	8084	// copy mutable arguments back from call to copyletdef
7896	8085	// copy back results provided by call to copyletdef

		@@ -7902,28 +8091,28 @@
7902	8091	newstack[0] = (uint64_t)stack; // backup stack location
7903	8092	newstack[1] = 1234567890;
7904	8093	newstack[2] = base;
7905		- newstack[3] = 608LLU;
	8094	+ newstack[3] = 635LLU;
7906	8095	stack = newstack;
7907	8096	// set stack-base & callee-address
7908	8097	base = 4/deloffset/;
7909		- label = 438LLU; // ~letdef
	8098	+ label = 455LLU; // ~letdef
7910	8099	break;
7911	8100	}
7912		- case 608LLU: // return from ~letdef to FindLetNew
	8101	+ case 635LLU: // return from ~letdef to FindLetNew
7913	8102	{
7914	8103	stack = (uint64_t *)stack[0];
7915	8104	// releasing toplevel container
7916	8105	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 22] - sizeof(uint64_t) 4));
7917	8106
7918		- label = 605LLU; // consequent complete
	8107	+ label = 632LLU; // consequent complete
7919	8108	break;
7920	8109	}
7921		- case 604LLU: // alternative
	8110	+ case 631LLU: // alternative
7922	8111	{
7923		- label = 605LLU; // alternative complete
	8112	+ label = 632LLU; // alternative complete
7924	8113	break;
7925	8114	}
7926		- case 605LLU: // completed if-then-else
	8115	+ case 632LLU: // completed if-then-else
7927	8116	{
7928	8117	((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
7929	8118	((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];

		@@ -7930,78 +8119,95 @@
7930	8119	((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
7931	8120	((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
7932	8121	((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
7933		- label = 600LLU; // case complete
	8122	+ label = 626LLU; // case complete
7934	8123	break;
7935	8124	}
7936		- case 601LLU: // try next case
	8125	+ case 628LLU: // copy-back deleter (switch)
7937	8126	{
	8127	+ ((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
	8128	+ ((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];
	8129	+ ((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
	8130	+ ((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
	8131	+ ((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
	8132	+ label = 619LLU; // continue to unroll stack
	8133	+ break;
	8134	+ }
	8135	+ case 627LLU: // try next case
	8136	+ {
7938	8137	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7939	8138	exit(-1);
7940	8139	}
7941		- case 600LLU: // completed switch
	8140	+ case 626LLU: // completed switch
7942	8141	{
7943		- label = 599LLU; // consequent complete
	8142	+ label = 625LLU; // consequent complete
7944	8143	break;
7945	8144	}
7946		- case 598LLU: // alternative
	8145	+ case 624LLU: // alternative
7947	8146	{
7948	8147	fprintf(stderr, "%s", "INTERNAL ERROR empty scope\n");
7949		- label = 599LLU; // alternative complete
	8148	+ label = 625LLU; // alternative complete
7950	8149	break;
7951	8150	}
7952		- case 599LLU: // completed if-then-else
	8151	+ case 625LLU: // completed if-then-else
7953	8152	{
7954		- label = 597LLU; // alternative complete
	8153	+ label = 623LLU; // alternative complete
7955	8154	break;
7956	8155	}
7957		- case 597LLU: // completed if-then-else
	8156	+ case 623LLU: // completed if-then-else
7958	8157	{
7959	8158	((struct listnode )(stack[base + 16]/previous*/))->data = stack[base + 15];
7960		- label = 594LLU; // repeat
	8159	+ label = 620LLU; // repeat
7961	8160	break;
7962	8161	}
7963		- case 595LLU: // loop finished
	8162	+ case 621LLU: // loop finished
7964	8163	{
7965	8164	((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
7966	8165	((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
7967		- label = 592LLU; // case complete
	8166	+ label = 617LLU; // case complete
7968	8167	break;
7969	8168	}
7970		- case 593LLU: // try next case
	8169	+ case 619LLU: // copy-back deleter (switch)
7971	8170	{
	8171	+ ((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
	8172	+ ((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
	8173	+ label = 592LLU; // continue to unroll stack
	8174	+ break;
	8175	+ }
	8176	+ case 618LLU: // try next case
	8177	+ {
7972	8178	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
7973	8179	exit(-1);
7974	8180	}
7975		- case 592LLU: // completed switch
	8181	+ case 617LLU: // completed switch
7976	8182	{
7977		- label = 591LLU; // alternative complete
	8183	+ label = 616LLU; // alternative complete
7978	8184	break;
7979	8185	}
7980		- case 591LLU: // completed if-then-else
	8186	+ case 616LLU: // completed if-then-else
7981	8187	{
7982	8188	((struct listnode )(stack[base + 11]/previous*/))->data = stack[base + 10];
7983		- label = 588LLU; // repeat
	8189	+ label = 613LLU; // repeat
7984	8190	break;
7985	8191	}
7986		- case 589LLU: // loop finished
	8192	+ case 614LLU: // loop finished
7987	8193	{
7988	8194	if(!stack[base + 8]/found/)
7989	8195	{
7990		- label = 609LLU; // jump to alternative
	8196	+ label = 636LLU; // jump to alternative
7991	8197	break;
7992	8198	}
7993	8199
7994	8200	// consequent
7995		- label = 610LLU; // consequent complete
	8201	+ label = 637LLU; // consequent complete
7996	8202	break;
7997	8203	}
7998		- case 609LLU: // alternative
	8204	+ case 636LLU: // alternative
7999	8205	{
8000	8206	fprintf(stderr, "%s", "in function ");
8001	8207	// call reportid from FindLetNew
8002		- stack[base + 12LLU] = 611LLU/throw to this address/;
	8208	+ stack[base + 12LLU] = 638LLU/throw to this address/;
8003	8209	stack[base + 13LLU] = base;
8004		- stack[base + 14LLU] = 612LLU;
	8210	+ stack[base + 14LLU] = 639LLU;
8005	8211	// arguments for call to reportid
8006	8212	stack[base + 15LLU] = stack[base + 1]/fnid/;
8007	8213	// set stack-base & callee-address

		@@ -8009,22 +8215,22 @@
8009	8215	label = 18446744073709551586LLU; // reportid
8010	8216	break;
8011	8217	}
8012		- case 611LLU: // copy-back deleter (reportid to FindLetNew)
	8218	+ case 638LLU: // copy-back deleter (reportid to FindLetNew)
8013	8219	{
8014	8220	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
8015	8221	// copy mutable arguments back from call to reportid
8016		- label = 569LLU; // continue to roll stack
	8222	+ label = 592LLU; // continue to roll stack
8017	8223	break;
8018	8224	}
8019		- case 612LLU: // return from reportid to FindLetNew
	8225	+ case 639LLU: // return from reportid to FindLetNew
8020	8226	{
8021	8227	// copy mutable arguments back from call to reportid
8022	8228	fprintf(stderr, "%s", ": ");
8023	8229	fprintf(stderr, "%s", "variable ");
8024	8230	// call reportid from FindLetNew
8025		- stack[base + 12LLU] = 613LLU/throw to this address/;
	8231	+ stack[base + 12LLU] = 640LLU/throw to this address/;
8026	8232	stack[base + 13LLU] = base;
8027		- stack[base + 14LLU] = 614LLU;
	8233	+ stack[base + 14LLU] = 641LLU;
8028	8234	// arguments for call to reportid
8029	8235	stack[base + 15LLU] = stack[base + 2]/id/;
8030	8236	// set stack-base & callee-address

		@@ -8032,38 +8238,38 @@
8032	8238	label = 18446744073709551586LLU; // reportid
8033	8239	break;
8034	8240	}
8035		- case 613LLU: // copy-back deleter (reportid to FindLetNew)
	8241	+ case 640LLU: // copy-back deleter (reportid to FindLetNew)
8036	8242	{
8037	8243	fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
8038	8244	// copy mutable arguments back from call to reportid
8039		- label = 569LLU; // continue to roll stack
	8245	+ label = 592LLU; // continue to roll stack
8040	8246	break;
8041	8247	}
8042		- case 614LLU: // return from reportid to FindLetNew
	8248	+ case 641LLU: // return from reportid to FindLetNew
8043	8249	{
8044	8250	// copy mutable arguments back from call to reportid
8045	8251	fprintf(stderr, "%s", " not in scope\n");
8046	8252	exit(-1);
8047		- label = 610LLU; // alternative complete
	8253	+ label = 637LLU; // alternative complete
8048	8254	break;
8049	8255	}
8050		- case 610LLU: // completed if-then-else
	8256	+ case 637LLU: // completed if-then-else
8051	8257	{
8052		- label = 587LLU; // alternative complete
	8258	+ label = 612LLU; // alternative complete
8053	8259	break;
8054	8260	}
8055		- case 587LLU: // completed if-then-else
	8261	+ case 612LLU: // completed if-then-else
8056	8262	{
8057		- label = 616LLU; // skip deleter
	8263	+ label = 643LLU; // skip deleter
8058	8264	break;
8059	8265	}
8060		- case 615LLU: // deleter
	8266	+ case 642LLU: // deleter
8061	8267	{
8062	8268	// throw from FindLetNew
8063	8269	if(!stack[base + 0])
8064	8270	{
8065	8271	fprintf(stderr, "in function FindLetNew: unrolling stack, skipping already deleted/unscoped variable letdef \n");
8066		- label = 569LLU; // skip, variable already deleted/unscoped
	8272	+ label = 592LLU; // skip, variable already deleted/unscoped
8067	8273	break;
8068	8274	}
8069	8275	fprintf(stderr, "in function FindLetNew: unrolling stack, variable letdef \n");

		@@ -8073,23 +8279,23 @@
8073	8279	newstack[0] = (uint64_t)stack; // backup stack location
8074	8280	newstack[1] = 1234567890;
8075	8281	newstack[2] = base;
8076		- newstack[3] = 617LLU;
	8282	+ newstack[3] = 644LLU;
8077	8283	stack = newstack;
8078	8284	// set stack-base & callee-address
8079	8285	base = 4/deloffset/;
8080		- label = 438LLU; // ~letdef
	8286	+ label = 455LLU; // ~letdef
8081	8287	break;
8082	8288	}
8083		- case 617LLU: // return from ~letdef to FindLetNew
	8289	+ case 644LLU: // return from ~letdef to FindLetNew
8084	8290	{
8085	8291	stack = (uint64_t *)stack[0];
8086	8292	// releasing toplevel container
8087	8293	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
8088	8294
8089		- label = 569LLU; // continue unrolling stack, delete next variable
	8295	+ label = 592LLU; // continue unrolling stack, delete next variable
8090	8296	break;
8091	8297	}
8092		- case 616LLU: // skipped deleter
	8298	+ case 643LLU: // skipped deleter
8093	8299	{
8094	8300	INIT(&stack[base + 0], &stack[base + 5]/result/);
8095	8301	// return from FindLetNew

		@@ -8097,7 +8303,7 @@
8097	8303	base = stack[base - 2];
8098	8304	break;
8099	8305	}
8100		- case 619LLU: // function getlettype failed
	8306	+ case 646LLU: // function getlettype failed
8101	8307	{
8102	8308	fprintf(stderr, "function getlettype failed\n");
8103	8309	label = stack[base - 3];

		@@ -8104,7 +8310,7 @@
8104	8310	base = stack[base - 2];
8105	8311	break;
8106	8312	}
8107		- case 618LLU: // getlettype
	8313	+ case 645LLU: // getlettype
8108	8314	{
8109	8315	//#define res0 0
8110	8316	//#define arg0 1

		@@ -8112,9 +8318,9 @@
8112	8318	//#define arg2 3
8113	8319	//#define arg3 4
8114	8320	// call FindLetNew from getlettype
8115		- stack[base + 6LLU] = 620LLU/throw to this address/;
	8321	+ stack[base + 6LLU] = 647LLU/throw to this address/;
8116	8322	stack[base + 7LLU] = base;
8117		- stack[base + 8LLU] = 621LLU;
	8323	+ stack[base + 8LLU] = 648LLU;
8118	8324	// arguments for call to FindLetNew
8119	8325	stack[base + 10LLU] = stack[base + 1]/fnid/;
8120	8326	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8122,17 +8328,17 @@
8122	8328	stack[base + 13LLU] = stack[base + 4]/scope/;
8123	8329	// set stack-base & callee-address
8124	8330	base += 9LLU;
8125		- label = 561LLU; // FindLetNew
	8331	+ label = 584LLU; // FindLetNew
8126	8332	break;
8127	8333	}
8128		- case 620LLU: // copy-back deleter (FindLetNew to getlettype)
	8334	+ case 647LLU: // copy-back deleter (FindLetNew to getlettype)
8129	8335	{
8130	8336	fprintf(stderr, "in function getlettype: unrolling stack, copy-back (FindLetNew to getlettype)\n");
8131	8337	// copy mutable arguments back from call to FindLetNew
8132		- label = 619LLU; // continue to roll stack
	8338	+ label = 646LLU; // continue to roll stack
8133	8339	break;
8134	8340	}
8135		- case 621LLU: // return from FindLetNew to getlettype
	8341	+ case 648LLU: // return from FindLetNew to getlettype
8136	8342	{
8137	8343	// copy mutable arguments back from call to FindLetNew
8138	8344	// copy back results provided by call to FindLetNew

		@@ -8139,7 +8345,7 @@
8139	8345	stack[base + 5] = stack[base + 9LLU];
8140	8346	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8141	8347	{
8142		- label = 623LLU; // jump to alternative
	8348	+ label = 650LLU; // jump to alternative
8143	8349	break;
8144	8350	}
8145	8351

		@@ -8153,7 +8359,7 @@
8153	8359	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
8154	8360	if(!newstack)
8155	8361	{
8156		- label = 619LLU; // throw: begin to unroll stack
	8362	+ label = 651LLU; // throw: begin to unroll stack
8157	8363	break;
8158	8364	}
8159	8365

		@@ -8160,18 +8366,18 @@
8160	8366	newstack[15LLU] = 9876543210LLU; // overflow-marker
8161	8367	// call copytype from getlettype
8162	8368	newstack[0] = (uint64_t)stack; // backup stack location
8163		- newstack[1] = 624LLU;
	8369	+ newstack[1] = 652LLU;
8164	8370	newstack[2] = base;
8165		- newstack[3] = 625LLU;
	8371	+ newstack[3] = 653LLU;
8166	8372	// arguments for call to copytype
8167	8373	newstack[5LLU] = stack[base + 6]/type/;
8168	8374	stack = newstack;
8169	8375	// set stack-base & callee-address
8170	8376	base = 4/deloffset/;
8171		- label = 322LLU; // copytype
	8377	+ label = 326LLU; // copytype
8172	8378	break;
8173	8379	}
8174		- case 624LLU: // copy-back deleter (copytype to getlettype)
	8380	+ case 652LLU: // copy-back deleter (copytype to getlettype)
8175	8381	{
8176	8382	fprintf(stderr, "in function getlettype: unrolling stack, copy-back (copytype to getlettype)\n");
8177	8383	uint64_t oldstack = (uint64_t )stack[0];

		@@ -8183,10 +8389,10 @@
8183	8389	}
8184	8390	Free(15LLU + 1, sizeof(uint64_t), stack);
8185	8391	stack = oldstack;
8186		- label = 619LLU; // continue to unroll stack
	8392	+ label = 651LLU; // continue to unroll stack
8187	8393	break;
8188	8394	}
8189		- case 625LLU: // return from copytype to getlettype
	8395	+ case 653LLU: // return from copytype to getlettype
8190	8396	{
8191	8397	uint64_t oldstack = (uint64_t )stack[0];
8192	8398	// copy mutable arguments back from call to copytype

		@@ -8204,15 +8410,25 @@
8204	8410	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8205	8411	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8206	8412	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8207		- label = 622LLU; // case complete
	8413	+ label = 649LLU; // case complete
8208	8414	break;
8209	8415	}
8210		- case 623LLU: // try next case
	8416	+ case 651LLU: // copy-back deleter (switch)
8211	8417	{
	8418	+ ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
	8419	+ ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
	8420	+ ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
	8421	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
	8422	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
	8423	+ label = 646LLU; // continue to unroll stack
	8424	+ break;
	8425	+ }
	8426	+ case 650LLU: // try next case
	8427	+ {
8212	8428	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8213	8429	exit(-1);
8214	8430	}
8215		- case 622LLU: // completed switch
	8431	+ case 649LLU: // completed switch
8216	8432	{
8217	8433
8218	8434	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8220,14 +8436,14 @@
8220	8436	newstack[0] = (uint64_t)stack; // backup stack location
8221	8437	newstack[1] = 1234567890;
8222	8438	newstack[2] = base;
8223		- newstack[3] = 626LLU;
	8439	+ newstack[3] = 654LLU;
8224	8440	stack = newstack;
8225	8441	// set stack-base & callee-address
8226	8442	base = 4/deloffset/;
8227		- label = 438LLU; // ~letdef
	8443	+ label = 455LLU; // ~letdef
8228	8444	break;
8229	8445	}
8230		- case 626LLU: // return from ~letdef to getlettype
	8446	+ case 654LLU: // return from ~letdef to getlettype
8231	8447	{
8232	8448	stack = (uint64_t *)stack[0];
8233	8449	// releasing toplevel container

		@@ -8238,7 +8454,7 @@
8238	8454	base = stack[base - 2];
8239	8455	break;
8240	8456	}
8241		- case 628LLU: // function findletidx failed
	8457	+ case 656LLU: // function findletidx failed
8242	8458	{
8243	8459	fprintf(stderr, "function findletidx failed\n");
8244	8460	label = stack[base - 3];

		@@ -8245,7 +8461,7 @@
8245	8461	base = stack[base - 2];
8246	8462	break;
8247	8463	}
8248		- case 627LLU: // findletidx
	8464	+ case 655LLU: // findletidx
8249	8465	{
8250	8466	//#define res0 0
8251	8467	//#define arg0 1

		@@ -8253,9 +8469,9 @@
8253	8469	//#define arg2 3
8254	8470	//#define arg3 4
8255	8471	// call FindLetNew from findletidx
8256		- stack[base + 6LLU] = 629LLU/throw to this address/;
	8472	+ stack[base + 6LLU] = 657LLU/throw to this address/;
8257	8473	stack[base + 7LLU] = base;
8258		- stack[base + 8LLU] = 630LLU;
	8474	+ stack[base + 8LLU] = 658LLU;
8259	8475	// arguments for call to FindLetNew
8260	8476	stack[base + 10LLU] = stack[base + 1]/fnid/;
8261	8477	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8263,17 +8479,17 @@
8263	8479	stack[base + 13LLU] = stack[base + 4]/scope/;
8264	8480	// set stack-base & callee-address
8265	8481	base += 9LLU;
8266		- label = 561LLU; // FindLetNew
	8482	+ label = 584LLU; // FindLetNew
8267	8483	break;
8268	8484	}
8269		- case 629LLU: // copy-back deleter (FindLetNew to findletidx)
	8485	+ case 657LLU: // copy-back deleter (FindLetNew to findletidx)
8270	8486	{
8271	8487	fprintf(stderr, "in function findletidx: unrolling stack, copy-back (FindLetNew to findletidx)\n");
8272	8488	// copy mutable arguments back from call to FindLetNew
8273		- label = 628LLU; // continue to roll stack
	8489	+ label = 656LLU; // continue to roll stack
8274	8490	break;
8275	8491	}
8276		- case 630LLU: // return from FindLetNew to findletidx
	8492	+ case 658LLU: // return from FindLetNew to findletidx
8277	8493	{
8278	8494	// copy mutable arguments back from call to FindLetNew
8279	8495	// copy back results provided by call to FindLetNew

		@@ -8280,7 +8496,7 @@
8280	8496	stack[base + 5] = stack[base + 9LLU];
8281	8497	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8282	8498	{
8283		- label = 632LLU; // jump to alternative
	8499	+ label = 660LLU; // jump to alternative
8284	8500	break;
8285	8501	}
8286	8502

		@@ -8291,23 +8507,23 @@
8291	8507	/substruct/stack[base + 10] = ((uint64_t *)(stack[base + 5]/letdef/))[1][4]/substruct*/;
8292	8508
8293	8509	// case
8294		- label = 634LLU; // skip deleter
	8510	+ label = 663LLU; // skip deleter
8295	8511	break;
8296	8512	}
8297		- case 633LLU: // deleter
	8513	+ case 662LLU: // deleter
8298	8514	{
8299	8515	// throw from findletidx
8300	8516	if(!stack[base + 0])
8301	8517	{
8302	8518	fprintf(stderr, "in function findletidx: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8303		- label = 628LLU; // skip, variable already deleted/unscoped
	8519	+ label = 661LLU; // skip, variable already deleted/unscoped
8304	8520	break;
8305	8521	}
8306	8522	fprintf(stderr, "in function findletidx: unrolling stack, variable u64 \n");
8307		- label = 628LLU; // continue unrolling stack, delete next variable
	8523	+ label = 661LLU; // continue unrolling stack, delete next variable
8308	8524	break;
8309	8525	}
8310		- case 634LLU: // skipped deleter
	8526	+ case 663LLU: // skipped deleter
8311	8527	{
8312	8528	stack[base + 0] = stack[base + 8]/index/;
8313	8529	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];

		@@ -8315,15 +8531,25 @@
8315	8531	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8316	8532	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8317	8533	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8318		- label = 631LLU; // case complete
	8534	+ label = 659LLU; // case complete
8319	8535	break;
8320	8536	}
8321		- case 632LLU: // try next case
	8537	+ case 661LLU: // copy-back deleter (switch)
8322	8538	{
	8539	+ ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
	8540	+ ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
	8541	+ ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
	8542	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
	8543	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
	8544	+ label = 656LLU; // continue to unroll stack
	8545	+ break;
	8546	+ }
	8547	+ case 660LLU: // try next case
	8548	+ {
8323	8549	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8324	8550	exit(-1);
8325	8551	}
8326		- case 631LLU: // completed switch
	8552	+ case 659LLU: // completed switch
8327	8553	{
8328	8554
8329	8555	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8331,14 +8557,14 @@
8331	8557	newstack[0] = (uint64_t)stack; // backup stack location
8332	8558	newstack[1] = 1234567890;
8333	8559	newstack[2] = base;
8334		- newstack[3] = 635LLU;
	8560	+ newstack[3] = 664LLU;
8335	8561	stack = newstack;
8336	8562	// set stack-base & callee-address
8337	8563	base = 4/deloffset/;
8338		- label = 438LLU; // ~letdef
	8564	+ label = 455LLU; // ~letdef
8339	8565	break;
8340	8566	}
8341		- case 635LLU: // return from ~letdef to findletidx
	8567	+ case 664LLU: // return from ~letdef to findletidx
8342	8568	{
8343	8569	stack = (uint64_t *)stack[0];
8344	8570	// releasing toplevel container

		@@ -8349,7 +8575,7 @@
8349	8575	base = stack[base - 2];
8350	8576	break;
8351	8577	}
8352		- case 637LLU: // function findletmut failed
	8578	+ case 666LLU: // function findletmut failed
8353	8579	{
8354	8580	fprintf(stderr, "function findletmut failed\n");
8355	8581	label = stack[base - 3];

		@@ -8356,7 +8582,7 @@
8356	8582	base = stack[base - 2];
8357	8583	break;
8358	8584	}
8359		- case 636LLU: // findletmut
	8585	+ case 665LLU: // findletmut
8360	8586	{
8361	8587	//#define res0 0
8362	8588	//#define arg0 1

		@@ -8364,9 +8590,9 @@
8364	8590	//#define arg2 3
8365	8591	//#define arg3 4
8366	8592	// call FindLetNew from findletmut
8367		- stack[base + 6LLU] = 638LLU/throw to this address/;
	8593	+ stack[base + 6LLU] = 667LLU/throw to this address/;
8368	8594	stack[base + 7LLU] = base;
8369		- stack[base + 8LLU] = 639LLU;
	8595	+ stack[base + 8LLU] = 668LLU;
8370	8596	// arguments for call to FindLetNew
8371	8597	stack[base + 10LLU] = stack[base + 1]/fnid/;
8372	8598	stack[base + 11LLU] = stack[base + 2]/id/;

		@@ -8374,17 +8600,17 @@
8374	8600	stack[base + 13LLU] = stack[base + 4]/scope/;
8375	8601	// set stack-base & callee-address
8376	8602	base += 9LLU;
8377		- label = 561LLU; // FindLetNew
	8603	+ label = 584LLU; // FindLetNew
8378	8604	break;
8379	8605	}
8380		- case 638LLU: // copy-back deleter (FindLetNew to findletmut)
	8606	+ case 667LLU: // copy-back deleter (FindLetNew to findletmut)
8381	8607	{
8382	8608	fprintf(stderr, "in function findletmut: unrolling stack, copy-back (FindLetNew to findletmut)\n");
8383	8609	// copy mutable arguments back from call to FindLetNew
8384		- label = 637LLU; // continue to roll stack
	8610	+ label = 666LLU; // continue to roll stack
8385	8611	break;
8386	8612	}
8387		- case 639LLU: // return from FindLetNew to findletmut
	8613	+ case 668LLU: // return from FindLetNew to findletmut
8388	8614	{
8389	8615	// copy mutable arguments back from call to FindLetNew
8390	8616	// copy back results provided by call to FindLetNew

		@@ -8391,7 +8617,7 @@
8391	8617	stack[base + 5] = stack[base + 9LLU];
8392	8618	if(/letdef/0 != ((uint64_t )(stack[base + 5]/letdef*/))[0])
8393	8619	{
8394		- label = 641LLU; // jump to alternative
	8620	+ label = 670LLU; // jump to alternative
8395	8621	break;
8396	8622	}
8397	8623

		@@ -8402,23 +8628,23 @@
8402	8628	/substruct/stack[base + 10] = ((uint64_t *)(stack[base + 5]/letdef/))[1][4]/substruct*/;
8403	8629
8404	8630	// case
8405		- label = 643LLU; // skip deleter
	8631	+ label = 673LLU; // skip deleter
8406	8632	break;
8407	8633	}
8408		- case 642LLU: // deleter
	8634	+ case 672LLU: // deleter
8409	8635	{
8410	8636	// throw from findletmut
8411	8637	if(!stack[base + 0])
8412	8638	{
8413	8639	fprintf(stderr, "in function findletmut: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8414		- label = 637LLU; // skip, variable already deleted/unscoped
	8640	+ label = 671LLU; // skip, variable already deleted/unscoped
8415	8641	break;
8416	8642	}
8417	8643	fprintf(stderr, "in function findletmut: unrolling stack, variable u64 \n");
8418		- label = 637LLU; // continue unrolling stack, delete next variable
	8644	+ label = 671LLU; // continue unrolling stack, delete next variable
8419	8645	break;
8420	8646	}
8421		- case 643LLU: // skipped deleter
	8647	+ case 673LLU: // skipped deleter
8422	8648	{
8423	8649	stack[base + 0] = stack[base + 9]/mutable/;
8424	8650	((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];

		@@ -8426,15 +8652,25 @@
8426	8652	((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
8427	8653	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
8428	8654	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8429		- label = 640LLU; // case complete
	8655	+ label = 669LLU; // case complete
8430	8656	break;
8431	8657	}
8432		- case 641LLU: // try next case
	8658	+ case 671LLU: // copy-back deleter (switch)
8433	8659	{
	8660	+ ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
	8661	+ ((uint64_t **)(stack[base + 5]))[1][3] = stack[base + 9];
	8662	+ ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
	8663	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
	8664	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
	8665	+ label = 666LLU; // continue to unroll stack
	8666	+ break;
	8667	+ }
	8668	+ case 670LLU: // try next case
	8669	+ {
8434	8670	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8435	8671	exit(-1);
8436	8672	}
8437		- case 640LLU: // completed switch
	8673	+ case 669LLU: // completed switch
8438	8674	{
8439	8675
8440	8676	uint64_t newstack = (uint64_t )(stack[base + 5] - sizeof(uint64_t) * 4);

		@@ -8442,14 +8678,14 @@
8442	8678	newstack[0] = (uint64_t)stack; // backup stack location
8443	8679	newstack[1] = 1234567890;
8444	8680	newstack[2] = base;
8445		- newstack[3] = 644LLU;
	8681	+ newstack[3] = 674LLU;
8446	8682	stack = newstack;
8447	8683	// set stack-base & callee-address
8448	8684	base = 4/deloffset/;
8449		- label = 438LLU; // ~letdef
	8685	+ label = 455LLU; // ~letdef
8450	8686	break;
8451	8687	}
8452		- case 644LLU: // return from ~letdef to findletmut
	8688	+ case 674LLU: // return from ~letdef to findletmut
8453	8689	{
8454	8690	stack = (uint64_t *)stack[0];
8455	8691	// releasing toplevel container

		@@ -8460,7 +8696,7 @@
8460	8696	base = stack[base - 2];
8461	8697	break;
8462	8698	}
8463		- case 646LLU: // function assertvar failed
	8699	+ case 676LLU: // function assertvar failed
8464	8700	{
8465	8701	fprintf(stderr, "function assertvar failed\n");
8466	8702	label = stack[base - 3];

		@@ -8467,7 +8703,7 @@
8467	8703	base = stack[base - 2];
8468	8704	break;
8469	8705	}
8470		- case 645LLU: // assertvar
	8706	+ case 675LLU: // assertvar
8471	8707	{
8472	8708	//#define arg0 0
8473	8709	//#define arg1 1

		@@ -8474,9 +8710,9 @@
8474	8710	//#define arg2 2
8475	8711	//#define arg3 3
8476	8712	// call findletidx from assertvar
8477		- stack[base + 5LLU] = 647LLU/throw to this address/;
	8713	+ stack[base + 5LLU] = 677LLU/throw to this address/;
8478	8714	stack[base + 6LLU] = base;
8479		- stack[base + 7LLU] = 648LLU;
	8715	+ stack[base + 7LLU] = 678LLU;
8480	8716	// arguments for call to findletidx
8481	8717	stack[base + 9LLU] = stack[base + 0]/fnid/;
8482	8718	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8484,17 +8720,17 @@
8484	8720	stack[base + 12LLU] = stack[base + 3]/scope/;
8485	8721	// set stack-base & callee-address
8486	8722	base += 8LLU;
8487		- label = 627LLU; // findletidx
	8723	+ label = 655LLU; // findletidx
8488	8724	break;
8489	8725	}
8490		- case 647LLU: // copy-back deleter (findletidx to assertvar)
	8726	+ case 677LLU: // copy-back deleter (findletidx to assertvar)
8491	8727	{
8492	8728	fprintf(stderr, "in function assertvar: unrolling stack, copy-back (findletidx to assertvar)\n");
8493	8729	// copy mutable arguments back from call to findletidx
8494		- label = 646LLU; // continue to roll stack
	8730	+ label = 676LLU; // continue to roll stack
8495	8731	break;
8496	8732	}
8497		- case 648LLU: // return from findletidx to assertvar
	8733	+ case 678LLU: // return from findletidx to assertvar
8498	8734	{
8499	8735	// copy mutable arguments back from call to findletidx
8500	8736	// copy back results provided by call to findletidx

		@@ -8504,7 +8740,7 @@
8504	8740	base = stack[base - 2];
8505	8741	break;
8506	8742	}
8507		- case 650LLU: // function emitindex failed
	8743	+ case 680LLU: // function emitindex failed
8508	8744	{
8509	8745	fprintf(stderr, "function emitindex failed\n");
8510	8746	label = stack[base - 3];

		@@ -8511,7 +8747,7 @@
8511	8747	base = stack[base - 2];
8512	8748	break;
8513	8749	}
8514		- case 649LLU: // emitindex
	8750	+ case 679LLU: // emitindex
8515	8751	{
8516	8752	//#define arg0 0
8517	8753	//#define arg1 1

		@@ -8518,9 +8754,9 @@
8518	8754	//#define arg2 2
8519	8755	//#define arg3 3
8520	8756	// call findletidx from emitindex
8521		- stack[base + 5LLU] = 651LLU/throw to this address/;
	8757	+ stack[base + 5LLU] = 681LLU/throw to this address/;
8522	8758	stack[base + 6LLU] = base;
8523		- stack[base + 7LLU] = 652LLU;
	8759	+ stack[base + 7LLU] = 682LLU;
8524	8760	// arguments for call to findletidx
8525	8761	stack[base + 9LLU] = stack[base + 0]/fnid/;
8526	8762	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8528,25 +8764,25 @@
8528	8764	stack[base + 12LLU] = stack[base + 3]/scope/;
8529	8765	// set stack-base & callee-address
8530	8766	base += 8LLU;
8531		- label = 627LLU; // findletidx
	8767	+ label = 655LLU; // findletidx
8532	8768	break;
8533	8769	}
8534		- case 651LLU: // copy-back deleter (findletidx to emitindex)
	8770	+ case 681LLU: // copy-back deleter (findletidx to emitindex)
8535	8771	{
8536	8772	fprintf(stderr, "in function emitindex: unrolling stack, copy-back (findletidx to emitindex)\n");
8537	8773	// copy mutable arguments back from call to findletidx
8538		- label = 650LLU; // continue to roll stack
	8774	+ label = 680LLU; // continue to roll stack
8539	8775	break;
8540	8776	}
8541		- case 652LLU: // return from findletidx to emitindex
	8777	+ case 682LLU: // return from findletidx to emitindex
8542	8778	{
8543	8779	// copy mutable arguments back from call to findletidx
8544	8780	// copy back results provided by call to findletidx
8545	8781	stack[base + 4] = stack[base + 8LLU];
8546	8782	// call printnr from emitindex
8547		- stack[base + 5LLU] = 653LLU/throw to this address/;
	8783	+ stack[base + 5LLU] = 683LLU/throw to this address/;
8548	8784	stack[base + 6LLU] = base;
8549		- stack[base + 7LLU] = 654LLU;
	8785	+ stack[base + 7LLU] = 684LLU;
8550	8786	// arguments for call to printnr
8551	8787	stack[base + 8LLU] = stack[base + 4]/index/;
8552	8788	// set stack-base & callee-address

		@@ -8554,14 +8790,14 @@
8554	8790	label = 18446744073709551590LLU; // printnr
8555	8791	break;
8556	8792	}
8557		- case 653LLU: // copy-back deleter (printnr to emitindex)
	8793	+ case 683LLU: // copy-back deleter (printnr to emitindex)
8558	8794	{
8559	8795	fprintf(stderr, "in function emitindex: unrolling stack, copy-back (printnr to emitindex)\n");
8560	8796	// copy mutable arguments back from call to printnr
8561		- label = 650LLU; // continue to roll stack
	8797	+ label = 680LLU; // continue to roll stack
8562	8798	break;
8563	8799	}
8564		- case 654LLU: // return from printnr to emitindex
	8800	+ case 684LLU: // return from printnr to emitindex
8565	8801	{
8566	8802	// copy mutable arguments back from call to printnr
8567	8803	// return from emitindex

		@@ -8569,7 +8805,7 @@
8569	8805	base = stack[base - 2];
8570	8806	break;
8571	8807	}
8572		- case 656LLU: // function emitvaridx failed
	8808	+ case 686LLU: // function emitvaridx failed
8573	8809	{
8574	8810	fprintf(stderr, "function emitvaridx failed\n");
8575	8811	label = stack[base - 3];

		@@ -8576,14 +8812,14 @@
8576	8812	base = stack[base - 2];
8577	8813	break;
8578	8814	}
8579		- case 655LLU: // emitvaridx
	8815	+ case 685LLU: // emitvaridx
8580	8816	{
8581	8817	//#define arg0 0
8582	8818	printf("%s", "stack[base + ");
8583	8819	// call printnr from emitvaridx
8584		- stack[base + 1LLU] = 657LLU/throw to this address/;
	8820	+ stack[base + 1LLU] = 687LLU/throw to this address/;
8585	8821	stack[base + 2LLU] = base;
8586		- stack[base + 3LLU] = 658LLU;
	8822	+ stack[base + 3LLU] = 688LLU;
8587	8823	// arguments for call to printnr
8588	8824	stack[base + 4LLU] = stack[base + 0]/index/;
8589	8825	// set stack-base & callee-address

		@@ -8591,14 +8827,14 @@
8591	8827	label = 18446744073709551590LLU; // printnr
8592	8828	break;
8593	8829	}
8594		- case 657LLU: // copy-back deleter (printnr to emitvaridx)
	8830	+ case 687LLU: // copy-back deleter (printnr to emitvaridx)
8595	8831	{
8596	8832	fprintf(stderr, "in function emitvaridx: unrolling stack, copy-back (printnr to emitvaridx)\n");
8597	8833	// copy mutable arguments back from call to printnr
8598		- label = 656LLU; // continue to roll stack
	8834	+ label = 686LLU; // continue to roll stack
8599	8835	break;
8600	8836	}
8601		- case 658LLU: // return from printnr to emitvaridx
	8837	+ case 688LLU: // return from printnr to emitvaridx
8602	8838	{
8603	8839	// copy mutable arguments back from call to printnr
8604	8840	printf("%s", "]");

		@@ -8607,7 +8843,7 @@
8607	8843	base = stack[base - 2];
8608	8844	break;
8609	8845	}
8610		- case 660LLU: // function emitvar failed
	8846	+ case 690LLU: // function emitvar failed
8611	8847	{
8612	8848	fprintf(stderr, "function emitvar failed\n");
8613	8849	label = stack[base - 3];

		@@ -8614,7 +8850,7 @@
8614	8850	base = stack[base - 2];
8615	8851	break;
8616	8852	}
8617		- case 659LLU: // emitvar
	8853	+ case 689LLU: // emitvar
8618	8854	{
8619	8855	//#define arg0 0
8620	8856	//#define arg1 1

		@@ -8621,9 +8857,9 @@
8621	8857	//#define arg2 2
8622	8858	//#define arg3 3
8623	8859	// call findletidx from emitvar
8624		- stack[base + 5LLU] = 661LLU/throw to this address/;
	8860	+ stack[base + 5LLU] = 691LLU/throw to this address/;
8625	8861	stack[base + 6LLU] = base;
8626		- stack[base + 7LLU] = 662LLU;
	8862	+ stack[base + 7LLU] = 692LLU;
8627	8863	// arguments for call to findletidx
8628	8864	stack[base + 9LLU] = stack[base + 0]/fnid/;
8629	8865	stack[base + 10LLU] = stack[base + 1]/id/;

		@@ -8631,47 +8867,47 @@
8631	8867	stack[base + 12LLU] = stack[base + 3]/scope/;
8632	8868	// set stack-base & callee-address
8633	8869	base += 8LLU;
8634		- label = 627LLU; // findletidx
	8870	+ label = 655LLU; // findletidx
8635	8871	break;
8636	8872	}
8637		- case 661LLU: // copy-back deleter (findletidx to emitvar)
	8873	+ case 691LLU: // copy-back deleter (findletidx to emitvar)
8638	8874	{
8639	8875	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (findletidx to emitvar)\n");
8640	8876	// copy mutable arguments back from call to findletidx
8641		- label = 660LLU; // continue to roll stack
	8877	+ label = 690LLU; // continue to roll stack
8642	8878	break;
8643	8879	}
8644		- case 662LLU: // return from findletidx to emitvar
	8880	+ case 692LLU: // return from findletidx to emitvar
8645	8881	{
8646	8882	// copy mutable arguments back from call to findletidx
8647	8883	// copy back results provided by call to findletidx
8648	8884	stack[base + 4] = stack[base + 8LLU];
8649	8885	// call emitvaridx from emitvar
8650		- stack[base + 5LLU] = 663LLU/throw to this address/;
	8886	+ stack[base + 5LLU] = 693LLU/throw to this address/;
8651	8887	stack[base + 6LLU] = base;
8652		- stack[base + 7LLU] = 664LLU;
	8888	+ stack[base + 7LLU] = 694LLU;
8653	8889	// arguments for call to emitvaridx
8654	8890	stack[base + 8LLU] = stack[base + 4]/index/;
8655	8891	// set stack-base & callee-address
8656	8892	base += 8LLU;
8657		- label = 655LLU; // emitvaridx
	8893	+ label = 685LLU; // emitvaridx
8658	8894	break;
8659	8895	}
8660		- case 663LLU: // copy-back deleter (emitvaridx to emitvar)
	8896	+ case 693LLU: // copy-back deleter (emitvaridx to emitvar)
8661	8897	{
8662	8898	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (emitvaridx to emitvar)\n");
8663	8899	// copy mutable arguments back from call to emitvaridx
8664		- label = 660LLU; // continue to roll stack
	8900	+ label = 690LLU; // continue to roll stack
8665	8901	break;
8666	8902	}
8667		- case 664LLU: // return from emitvaridx to emitvar
	8903	+ case 694LLU: // return from emitvaridx to emitvar
8668	8904	{
8669	8905	// copy mutable arguments back from call to emitvaridx
8670	8906	printf("%s", "/*");
8671	8907	// call printid from emitvar
8672		- stack[base + 5LLU] = 665LLU/throw to this address/;
	8908	+ stack[base + 5LLU] = 695LLU/throw to this address/;
8673	8909	stack[base + 6LLU] = base;
8674		- stack[base + 7LLU] = 666LLU;
	8910	+ stack[base + 7LLU] = 696LLU;
8675	8911	// arguments for call to printid
8676	8912	stack[base + 8LLU] = stack[base + 1]/id/;
8677	8913	// set stack-base & callee-address

		@@ -8679,14 +8915,14 @@
8679	8915	label = 18446744073709551587LLU; // printid
8680	8916	break;
8681	8917	}
8682		- case 665LLU: // copy-back deleter (printid to emitvar)
	8918	+ case 695LLU: // copy-back deleter (printid to emitvar)
8683	8919	{
8684	8920	fprintf(stderr, "in function emitvar: unrolling stack, copy-back (printid to emitvar)\n");
8685	8921	// copy mutable arguments back from call to printid
8686		- label = 660LLU; // continue to roll stack
	8922	+ label = 690LLU; // continue to roll stack
8687	8923	break;
8688	8924	}
8689		- case 666LLU: // return from printid to emitvar
	8925	+ case 696LLU: // return from printid to emitvar
8690	8926	{
8691	8927	// copy mutable arguments back from call to printid
8692	8928	printf("%s", "*/");

		@@ -8695,7 +8931,7 @@
8695	8931	base = stack[base - 2];
8696	8932	break;
8697	8933	}
8698		- case 668LLU: // function newvarraw failed
	8934	+ case 698LLU: // function newvarraw failed
8699	8935	{
8700	8936	fprintf(stderr, "function newvarraw failed\n");
8701	8937	label = stack[base - 3];

		@@ -8702,7 +8938,7 @@
8702	8938	base = stack[base - 2];
8703	8939	break;
8704	8940	}
8705		- case 667LLU: // newvarraw
	8941	+ case 697LLU: // newvarraw
8706	8942	{
8707	8943	//#define res0 0
8708	8944	//#define arg0 1

		@@ -8714,28 +8950,28 @@
8714	8950	//#define arg6 7
8715	8951	//#define arg7 8
8716	8952	//#define arg8 9
8717		- label = 670LLU; // skip deleter
	8953	+ label = 700LLU; // skip deleter
8718	8954	break;
8719	8955	}
8720		- case 669LLU: // deleter
	8956	+ case 699LLU: // deleter
8721	8957	{
8722	8958	// throw from newvarraw
8723	8959	if(!stack[base + 10])
8724	8960	{
8725	8961	fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8726		- label = 668LLU; // skip, variable already deleted/unscoped
	8962	+ label = 698LLU; // skip, variable already deleted/unscoped
8727	8963	break;
8728	8964	}
8729	8965	fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
8730		- label = 668LLU; // continue unrolling stack, delete next variable
	8966	+ label = 698LLU; // continue unrolling stack, delete next variable
8731	8967	break;
8732	8968	}
8733		- case 670LLU: // skipped deleter
	8969	+ case 700LLU: // skipped deleter
8734	8970	{
8735	8971	stack[base + 10] = 0;
8736	8972	if(/scope/0 != ((uint64_t )(stack[base + 8]/scope*/))[0])
8737	8973	{
8738		- label = 672LLU; // jump to alternative
	8974	+ label = 702LLU; // jump to alternative
8739	8975	break;
8740	8976	}
8741	8977

		@@ -8743,29 +8979,29 @@
8743	8979	/letdefs/stack[base + 12] = ((uint64_t *)(stack[base + 8]/scope/))[1][1]/letdefs*/;
8744	8980
8745	8981	// case
8746		- label = 674LLU; // skip deleter
	8982	+ label = 705LLU; // skip deleter
8747	8983	break;
8748	8984	}
8749		- case 673LLU: // deleter
	8985	+ case 704LLU: // deleter
8750	8986	{
8751	8987	// throw from newvarraw
8752	8988	if(!stack[base + 13])
8753	8989	{
8754	8990	fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
8755		- label = 669LLU; // skip, variable already deleted/unscoped
	8991	+ label = 703LLU; // skip, variable already deleted/unscoped
8756	8992	break;
8757	8993	}
8758	8994	fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
8759		- label = 669LLU; // continue unrolling stack, delete next variable
	8995	+ label = 703LLU; // continue unrolling stack, delete next variable
8760	8996	break;
8761	8997	}
8762		- case 674LLU: // skipped deleter
	8998	+ case 705LLU: // skipped deleter
8763	8999	{
8764	9000	stack[base + 13] = 0;
8765	9001	// call add from newvarraw
8766		- stack[base + 14LLU] = 675LLU/throw to this address/;
	9002	+ stack[base + 14LLU] = 706LLU/throw to this address/;
8767	9003	stack[base + 15LLU] = base;
8768		- stack[base + 16LLU] = 676LLU;
	9004	+ stack[base + 16LLU] = 707LLU;
8769	9005	// arguments for call to add
8770	9006	stack[base + 18LLU] = stack[base + 4]/fnrescount/;
8771	9007	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -8774,22 +9010,22 @@
8774	9010	label = 18446744073709551605LLU; // add
8775	9011	break;
8776	9012	}
8777		- case 675LLU: // copy-back deleter (add to newvarraw)
	9013	+ case 706LLU: // copy-back deleter (add to newvarraw)
8778	9014	{
8779	9015	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
8780	9016	// copy mutable arguments back from call to add
8781		- label = 673LLU; // continue to roll stack
	9017	+ label = 704LLU; // continue to roll stack
8782	9018	break;
8783	9019	}
8784		- case 676LLU: // return from add to newvarraw
	9020	+ case 707LLU: // return from add to newvarraw
8785	9021	{
8786	9022	// copy mutable arguments back from call to add
8787	9023	// copy back results provided by call to add
8788	9024	stack[base + 13] = stack[base + 17LLU];
8789	9025	// call add from newvarraw
8790		- stack[base + 14LLU] = 677LLU/throw to this address/;
	9026	+ stack[base + 14LLU] = 708LLU/throw to this address/;
8791	9027	stack[base + 15LLU] = base;
8792		- stack[base + 16LLU] = 678LLU;
	9028	+ stack[base + 16LLU] = 709LLU;
8793	9029	// arguments for call to add
8794	9030	stack[base + 18LLU] = stack[base + 5]/fnargcount/;
8795	9031	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -8798,22 +9034,22 @@
8798	9034	label = 18446744073709551605LLU; // add
8799	9035	break;
8800	9036	}
8801		- case 677LLU: // copy-back deleter (add to newvarraw)
	9037	+ case 708LLU: // copy-back deleter (add to newvarraw)
8802	9038	{
8803	9039	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
8804	9040	// copy mutable arguments back from call to add
8805		- label = 673LLU; // continue to roll stack
	9041	+ label = 704LLU; // continue to roll stack
8806	9042	break;
8807	9043	}
8808		- case 678LLU: // return from add to newvarraw
	9044	+ case 709LLU: // return from add to newvarraw
8809	9045	{
8810	9046	// copy mutable arguments back from call to add
8811	9047	// copy back results provided by call to add
8812	9048	stack[base + 13] = stack[base + 17LLU];
8813	9049	// call add from newvarraw
8814		- stack[base + 14LLU] = 679LLU/throw to this address/;
	9050	+ stack[base + 14LLU] = 710LLU/throw to this address/;
8815	9051	stack[base + 15LLU] = base;
8816		- stack[base + 16LLU] = 680LLU;
	9052	+ stack[base + 16LLU] = 711LLU;
8817	9053	// arguments for call to add
8818	9054	stack[base + 18LLU] = stack[base + 7]/varcount/;
8819	9055	stack[base + 19LLU] = stack[base + 13]/sum/;

		@@ -8822,14 +9058,14 @@
8822	9058	label = 18446744073709551605LLU; // add
8823	9059	break;
8824	9060	}
8825		- case 679LLU: // copy-back deleter (add to newvarraw)
	9061	+ case 710LLU: // copy-back deleter (add to newvarraw)
8826	9062	{
8827	9063	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
8828	9064	// copy mutable arguments back from call to add
8829		- label = 673LLU; // continue to roll stack
	9065	+ label = 704LLU; // continue to roll stack
8830	9066	break;
8831	9067	}
8832		- case 680LLU: // return from add to newvarraw
	9068	+ case 711LLU: // return from add to newvarraw
8833	9069	{
8834	9070	// copy mutable arguments back from call to add
8835	9071	// copy back results provided by call to add

		@@ -8838,7 +9074,7 @@
8838	9074	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
8839	9075	if(!newstack)
8840	9076	{
8841		- label = 673LLU; // throw: begin to unroll stack
	9077	+ label = 704LLU; // throw: begin to unroll stack
8842	9078	break;
8843	9079	}
8844	9080

		@@ -8845,18 +9081,18 @@
8845	9081	newstack[15LLU] = 9876543210LLU; // overflow-marker
8846	9082	// call copytype from newvarraw
8847	9083	newstack[0] = (uint64_t)stack; // backup stack location
8848		- newstack[1] = 681LLU;
	9084	+ newstack[1] = 712LLU;
8849	9085	newstack[2] = base;
8850		- newstack[3] = 682LLU;
	9086	+ newstack[3] = 713LLU;
8851	9087	// arguments for call to copytype
8852	9088	newstack[5LLU] = stack[base + 1]/type/;
8853	9089	stack = newstack;
8854	9090	// set stack-base & callee-address
8855	9091	base = 4/deloffset/;
8856		- label = 322LLU; // copytype
	9092	+ label = 326LLU; // copytype
8857	9093	break;
8858	9094	}
8859		- case 681LLU: // copy-back deleter (copytype to newvarraw)
	9095	+ case 712LLU: // copy-back deleter (copytype to newvarraw)
8860	9096	{
8861	9097	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (copytype to newvarraw)\n");
8862	9098	uint64_t oldstack = (uint64_t )stack[0];

		@@ -8868,10 +9104,10 @@
8868	9104	}
8869	9105	Free(15LLU + 1, sizeof(uint64_t), stack);
8870	9106	stack = oldstack;
8871		- label = 673LLU; // continue to unroll stack
	9107	+ label = 704LLU; // continue to unroll stack
8872	9108	break;
8873	9109	}
8874		- case 682LLU: // return from copytype to newvarraw
	9110	+ case 713LLU: // return from copytype to newvarraw
8875	9111	{
8876	9112	uint64_t oldstack = (uint64_t )stack[0];
8877	9113	// copy mutable arguments back from call to copytype

		@@ -8884,16 +9120,16 @@
8884	9120	}
8885	9121	Free(15LLU + 1, sizeof(uint64_t), stack);
8886	9122	stack = oldstack;
8887		- label = 684LLU; // skip deleter
	9123	+ label = 715LLU; // skip deleter
8888	9124	break;
8889	9125	}
8890		- case 683LLU: // deleter
	9126	+ case 714LLU: // deleter
8891	9127	{
8892	9128	// throw from newvarraw
8893	9129	if(!stack[base + 15])
8894	9130	{
8895	9131	fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable letdef \n");
8896		- label = 673LLU; // skip, variable already deleted/unscoped
	9132	+ label = 704LLU; // skip, variable already deleted/unscoped
8897	9133	break;
8898	9134	}
8899	9135	fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef \n");

		@@ -8903,28 +9139,28 @@
8903	9139	newstack[0] = (uint64_t)stack; // backup stack location
8904	9140	newstack[1] = 1234567890;
8905	9141	newstack[2] = base;
8906		- newstack[3] = 685LLU;
	9142	+ newstack[3] = 716LLU;
8907	9143	stack = newstack;
8908	9144	// set stack-base & callee-address
8909	9145	base = 4/deloffset/;
8910		- label = 438LLU; // ~letdef
	9146	+ label = 455LLU; // ~letdef
8911	9147	break;
8912	9148	}
8913		- case 685LLU: // return from ~letdef to newvarraw
	9149	+ case 716LLU: // return from ~letdef to newvarraw
8914	9150	{
8915	9151	stack = (uint64_t *)stack[0];
8916	9152	// releasing toplevel container
8917	9153	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 15] - sizeof(uint64_t) 4));
8918	9154
8919		- label = 673LLU; // continue unrolling stack, delete next variable
	9155	+ label = 704LLU; // continue unrolling stack, delete next variable
8920	9156	break;
8921	9157	}
8922		- case 684LLU: // skipped deleter
	9158	+ case 715LLU: // skipped deleter
8923	9159	{
8924	9160	// construct letdef.letdef
8925	9161	if(!(stack[base + 15] = construct(5)))
8926	9162	{
8927		- label = 673LLU; // throw: begin to unroll stack
	9163	+ label = 704LLU; // throw: begin to unroll stack
8928	9164	break;
8929	9165	}
8930	9166

		@@ -8948,20 +9184,27 @@
8948	9184	}
8949	9185	((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
8950	9186	((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
8951		- label = 671LLU; // case complete
	9187	+ label = 701LLU; // case complete
8952	9188	break;
8953	9189	}
8954		- case 672LLU: // try next case
	9190	+ case 703LLU: // copy-back deleter (switch)
8955	9191	{
	9192	+ ((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
	9193	+ ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
	9194	+ label = 699LLU; // continue to unroll stack
	9195	+ break;
	9196	+ }
	9197	+ case 702LLU: // try next case
	9198	+ {
8956	9199	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
8957	9200	exit(-1);
8958	9201	}
8959		- case 671LLU: // completed switch
	9202	+ case 701LLU: // completed switch
8960	9203	{
8961	9204	// call add from newvarraw
8962		- stack[base + 11LLU] = 686LLU/throw to this address/;
	9205	+ stack[base + 11LLU] = 717LLU/throw to this address/;
8963	9206	stack[base + 12LLU] = base;
8964		- stack[base + 13LLU] = 687LLU;
	9207	+ stack[base + 13LLU] = 718LLU;
8965	9208	// arguments for call to add
8966	9209	stack[base + 15LLU] = 1LLU;
8967	9210	stack[base + 16LLU] = stack[base + 7]/varcount/;

		@@ -8970,22 +9213,22 @@
8970	9213	label = 18446744073709551605LLU; // add
8971	9214	break;
8972	9215	}
8973		- case 686LLU: // copy-back deleter (add to newvarraw)
	9216	+ case 717LLU: // copy-back deleter (add to newvarraw)
8974	9217	{
8975	9218	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
8976	9219	// copy mutable arguments back from call to add
8977		- label = 669LLU; // continue to roll stack
	9220	+ label = 699LLU; // continue to roll stack
8978	9221	break;
8979	9222	}
8980		- case 687LLU: // return from add to newvarraw
	9223	+ case 718LLU: // return from add to newvarraw
8981	9224	{
8982	9225	// copy mutable arguments back from call to add
8983	9226	// copy back results provided by call to add
8984	9227	stack[base + 7] = stack[base + 14LLU];
8985	9228	// call max from newvarraw
8986		- stack[base + 11LLU] = 688LLU/throw to this address/;
	9229	+ stack[base + 11LLU] = 719LLU/throw to this address/;
8987	9230	stack[base + 12LLU] = base;
8988		- stack[base + 13LLU] = 689LLU;
	9231	+ stack[base + 13LLU] = 720LLU;
8989	9232	// arguments for call to max
8990	9233	stack[base + 15LLU] = stack[base + 7]/varcount/;
8991	9234	stack[base + 16LLU] = stack[base + 6]/fnmaxcount/;

		@@ -8994,35 +9237,35 @@
8994	9237	label = 18446744073709551606LLU; // max
8995	9238	break;
8996	9239	}
8997		- case 688LLU: // copy-back deleter (max to newvarraw)
	9240	+ case 719LLU: // copy-back deleter (max to newvarraw)
8998	9241	{
8999	9242	fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (max to newvarraw)\n");
9000	9243	// copy mutable arguments back from call to max
9001		- label = 669LLU; // continue to roll stack
	9244	+ label = 699LLU; // continue to roll stack
9002	9245	break;
9003	9246	}
9004		- case 689LLU: // return from max to newvarraw
	9247	+ case 720LLU: // return from max to newvarraw
9005	9248	{
9006	9249	// copy mutable arguments back from call to max
9007	9250	// copy back results provided by call to max
9008	9251	stack[base + 6] = stack[base + 14LLU];
9009		- label = 691LLU; // skip deleter
	9252	+ label = 722LLU; // skip deleter
9010	9253	break;
9011	9254	}
9012		- case 690LLU: // deleter
	9255	+ case 721LLU: // deleter
9013	9256	{
9014	9257	// throw from newvarraw
9015	9258	if(!stack[base + 0])
9016	9259	{
9017	9260	fprintf(stderr, "in function newvarraw: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9018		- label = 669LLU; // skip, variable already deleted/unscoped
	9261	+ label = 699LLU; // skip, variable already deleted/unscoped
9019	9262	break;
9020	9263	}
9021	9264	fprintf(stderr, "in function newvarraw: unrolling stack, variable u64 \n");
9022		- label = 669LLU; // continue unrolling stack, delete next variable
	9265	+ label = 699LLU; // continue unrolling stack, delete next variable
9023	9266	break;
9024	9267	}
9025		- case 691LLU: // skipped deleter
	9268	+ case 722LLU: // skipped deleter
9026	9269	{
9027	9270	stack[base + 0] = stack[base + 10]/index/;
9028	9271	// return from newvarraw

		@@ -9030,7 +9273,7 @@
9030	9273	base = stack[base - 2];
9031	9274	break;
9032	9275	}
9033		- case 693LLU: // function newvar failed
	9276	+ case 724LLU: // function newvar failed
9034	9277	{
9035	9278	fprintf(stderr, "function newvar failed\n");
9036	9279	label = stack[base - 3];

		@@ -9037,7 +9280,7 @@
9037	9280	base = stack[base - 2];
9038	9281	break;
9039	9282	}
9040		- case 692LLU: // newvar
	9283	+ case 723LLU: // newvar
9041	9284	{
9042	9285	//#define arg0 0
9043	9286	//#define arg1 1

		@@ -9049,9 +9292,9 @@
9049	9292	//#define arg7 7
9050	9293	printf("%s", "\n//#define ");
9051	9294	// call printid from newvar
9052		- stack[base + 8LLU] = 694LLU/throw to this address/;
	9295	+ stack[base + 8LLU] = 725LLU/throw to this address/;
9053	9296	stack[base + 9LLU] = base;
9054		- stack[base + 10LLU] = 695LLU;
	9297	+ stack[base + 10LLU] = 726LLU;
9055	9298	// arguments for call to printid
9056	9299	stack[base + 11LLU] = stack[base + 1]/id/;
9057	9300	// set stack-base & callee-address

		@@ -9059,19 +9302,19 @@
9059	9302	label = 18446744073709551587LLU; // printid
9060	9303	break;
9061	9304	}
9062		- case 694LLU: // copy-back deleter (printid to newvar)
	9305	+ case 725LLU: // copy-back deleter (printid to newvar)
9063	9306	{
9064	9307	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
9065	9308	// copy mutable arguments back from call to printid
9066		- label = 693LLU; // continue to roll stack
	9309	+ label = 724LLU; // continue to roll stack
9067	9310	break;
9068	9311	}
9069		- case 695LLU: // return from printid to newvar
	9312	+ case 726LLU: // return from printid to newvar
9070	9313	{
9071	9314	// copy mutable arguments back from call to printid
9072	9315	if(/scope/0 != ((uint64_t )(stack[base + 7]/scope*/))[0])
9073	9316	{
9074		- label = 697LLU; // jump to alternative
	9317	+ label = 728LLU; // jump to alternative
9075	9318	break;
9076	9319	}
9077	9320

		@@ -9079,29 +9322,29 @@
9079	9322	/letdefs/stack[base + 9] = ((uint64_t *)(stack[base + 7]/scope/))[1][1]/letdefs*/;
9080	9323
9081	9324	// case
9082		- label = 699LLU; // skip deleter
	9325	+ label = 731LLU; // skip deleter
9083	9326	break;
9084	9327	}
9085		- case 698LLU: // deleter
	9328	+ case 730LLU: // deleter
9086	9329	{
9087	9330	// throw from newvar
9088	9331	if(!stack[base + 10])
9089	9332	{
9090	9333	fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9091		- label = 693LLU; // skip, variable already deleted/unscoped
	9334	+ label = 729LLU; // skip, variable already deleted/unscoped
9092	9335	break;
9093	9336	}
9094	9337	fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9095		- label = 693LLU; // continue unrolling stack, delete next variable
	9338	+ label = 729LLU; // continue unrolling stack, delete next variable
9096	9339	break;
9097	9340	}
9098		- case 699LLU: // skipped deleter
	9341	+ case 731LLU: // skipped deleter
9099	9342	{
9100	9343	stack[base + 10] = 0;
9101	9344	// call add from newvar
9102		- stack[base + 11LLU] = 700LLU/throw to this address/;
	9345	+ stack[base + 11LLU] = 732LLU/throw to this address/;
9103	9346	stack[base + 12LLU] = base;
9104		- stack[base + 13LLU] = 701LLU;
	9347	+ stack[base + 13LLU] = 733LLU;
9105	9348	// arguments for call to add
9106	9349	stack[base + 15LLU] = stack[base + 3]/fnrescount/;
9107	9350	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9110,22 +9353,22 @@
9110	9353	label = 18446744073709551605LLU; // add
9111	9354	break;
9112	9355	}
9113		- case 700LLU: // copy-back deleter (add to newvar)
	9356	+ case 732LLU: // copy-back deleter (add to newvar)
9114	9357	{
9115	9358	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9116	9359	// copy mutable arguments back from call to add
9117		- label = 698LLU; // continue to roll stack
	9360	+ label = 730LLU; // continue to roll stack
9118	9361	break;
9119	9362	}
9120		- case 701LLU: // return from add to newvar
	9363	+ case 733LLU: // return from add to newvar
9121	9364	{
9122	9365	// copy mutable arguments back from call to add
9123	9366	// copy back results provided by call to add
9124	9367	stack[base + 10] = stack[base + 14LLU];
9125	9368	// call add from newvar
9126		- stack[base + 11LLU] = 702LLU/throw to this address/;
	9369	+ stack[base + 11LLU] = 734LLU/throw to this address/;
9127	9370	stack[base + 12LLU] = base;
9128		- stack[base + 13LLU] = 703LLU;
	9371	+ stack[base + 13LLU] = 735LLU;
9129	9372	// arguments for call to add
9130	9373	stack[base + 15LLU] = stack[base + 4]/fnargcount/;
9131	9374	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9134,22 +9377,22 @@
9134	9377	label = 18446744073709551605LLU; // add
9135	9378	break;
9136	9379	}
9137		- case 702LLU: // copy-back deleter (add to newvar)
	9380	+ case 734LLU: // copy-back deleter (add to newvar)
9138	9381	{
9139	9382	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9140	9383	// copy mutable arguments back from call to add
9141		- label = 698LLU; // continue to roll stack
	9384	+ label = 730LLU; // continue to roll stack
9142	9385	break;
9143	9386	}
9144		- case 703LLU: // return from add to newvar
	9387	+ case 735LLU: // return from add to newvar
9145	9388	{
9146	9389	// copy mutable arguments back from call to add
9147	9390	// copy back results provided by call to add
9148	9391	stack[base + 10] = stack[base + 14LLU];
9149	9392	// call add from newvar
9150		- stack[base + 11LLU] = 704LLU/throw to this address/;
	9393	+ stack[base + 11LLU] = 736LLU/throw to this address/;
9151	9394	stack[base + 12LLU] = base;
9152		- stack[base + 13LLU] = 705LLU;
	9395	+ stack[base + 13LLU] = 737LLU;
9153	9396	// arguments for call to add
9154	9397	stack[base + 15LLU] = stack[base + 6]/varcount/;
9155	9398	stack[base + 16LLU] = stack[base + 10]/sum/;

		@@ -9158,14 +9401,14 @@
9158	9401	label = 18446744073709551605LLU; // add
9159	9402	break;
9160	9403	}
9161		- case 704LLU: // copy-back deleter (add to newvar)
	9404	+ case 736LLU: // copy-back deleter (add to newvar)
9162	9405	{
9163	9406	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9164	9407	// copy mutable arguments back from call to add
9165		- label = 698LLU; // continue to roll stack
	9408	+ label = 730LLU; // continue to roll stack
9166	9409	break;
9167	9410	}
9168		- case 705LLU: // return from add to newvar
	9411	+ case 737LLU: // return from add to newvar
9169	9412	{
9170	9413	// copy mutable arguments back from call to add
9171	9414	// copy back results provided by call to add

		@@ -9172,9 +9415,9 @@
9172	9415	stack[base + 10] = stack[base + 14LLU];
9173	9416	printf("%s", " ");
9174	9417	// call printnr from newvar
9175		- stack[base + 11LLU] = 706LLU/throw to this address/;
	9418	+ stack[base + 11LLU] = 738LLU/throw to this address/;
9176	9419	stack[base + 12LLU] = base;
9177		- stack[base + 13LLU] = 707LLU;
	9420	+ stack[base + 13LLU] = 739LLU;
9178	9421	// arguments for call to printnr
9179	9422	stack[base + 14LLU] = stack[base + 10]/sum/;
9180	9423	// set stack-base & callee-address

		@@ -9182,20 +9425,20 @@
9182	9425	label = 18446744073709551590LLU; // printnr
9183	9426	break;
9184	9427	}
9185		- case 706LLU: // copy-back deleter (printnr to newvar)
	9428	+ case 738LLU: // copy-back deleter (printnr to newvar)
9186	9429	{
9187	9430	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
9188	9431	// copy mutable arguments back from call to printnr
9189		- label = 698LLU; // continue to roll stack
	9432	+ label = 730LLU; // continue to roll stack
9190	9433	break;
9191	9434	}
9192		- case 707LLU: // return from printnr to newvar
	9435	+ case 739LLU: // return from printnr to newvar
9193	9436	{
9194	9437	// copy mutable arguments back from call to printnr
9195	9438	uint64_t newstack = (uint64_t )Calloc(15LLU + 1, sizeof(uint64_t));
9196	9439	if(!newstack)
9197	9440	{
9198		- label = 698LLU; // throw: begin to unroll stack
	9441	+ label = 730LLU; // throw: begin to unroll stack
9199	9442	break;
9200	9443	}
9201	9444

		@@ -9202,18 +9445,18 @@
9202	9445	newstack[15LLU] = 9876543210LLU; // overflow-marker
9203	9446	// call copytype from newvar
9204	9447	newstack[0] = (uint64_t)stack; // backup stack location
9205		- newstack[1] = 708LLU;
	9448	+ newstack[1] = 740LLU;
9206	9449	newstack[2] = base;
9207		- newstack[3] = 709LLU;
	9450	+ newstack[3] = 741LLU;
9208	9451	// arguments for call to copytype
9209	9452	newstack[5LLU] = stack[base + 0]/type/;
9210	9453	stack = newstack;
9211	9454	// set stack-base & callee-address
9212	9455	base = 4/deloffset/;
9213		- label = 322LLU; // copytype
	9456	+ label = 326LLU; // copytype
9214	9457	break;
9215	9458	}
9216		- case 708LLU: // copy-back deleter (copytype to newvar)
	9459	+ case 740LLU: // copy-back deleter (copytype to newvar)
9217	9460	{
9218	9461	fprintf(stderr, "in function newvar: unrolling stack, copy-back (copytype to newvar)\n");
9219	9462	uint64_t oldstack = (uint64_t )stack[0];

		@@ -9225,10 +9468,10 @@
9225	9468	}
9226	9469	Free(15LLU + 1, sizeof(uint64_t), stack);
9227	9470	stack = oldstack;
9228		- label = 698LLU; // continue to unroll stack
	9471	+ label = 730LLU; // continue to unroll stack
9229	9472	break;
9230	9473	}
9231		- case 709LLU: // return from copytype to newvar
	9474	+ case 741LLU: // return from copytype to newvar
9232	9475	{
9233	9476	uint64_t oldstack = (uint64_t )stack[0];
9234	9477	// copy mutable arguments back from call to copytype

		@@ -9241,35 +9484,35 @@
9241	9484	}
9242	9485	Free(15LLU + 1, sizeof(uint64_t), stack);
9243	9486	stack = oldstack;
9244		- label = 711LLU; // skip deleter
	9487	+ label = 743LLU; // skip deleter
9245	9488	break;
9246	9489	}
9247		- case 710LLU: // deleter
	9490	+ case 742LLU: // deleter
9248	9491	{
9249	9492	// throw from newvar
9250	9493	if(!stack[base + 12])
9251	9494	{
9252	9495	fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9253		- label = 698LLU; // skip, variable already deleted/unscoped
	9496	+ label = 730LLU; // skip, variable already deleted/unscoped
9254	9497	break;
9255	9498	}
9256	9499	fprintf(stderr, "in function newvar: unrolling stack, variable u64 \n");
9257		- label = 698LLU; // continue unrolling stack, delete next variable
	9500	+ label = 730LLU; // continue unrolling stack, delete next variable
9258	9501	break;
9259	9502	}
9260		- case 711LLU: // skipped deleter
	9503	+ case 743LLU: // skipped deleter
9261	9504	{
9262	9505	stack[base + 12] = 0;
9263		- label = 713LLU; // skip deleter
	9506	+ label = 745LLU; // skip deleter
9264	9507	break;
9265	9508	}
9266		- case 712LLU: // deleter
	9509	+ case 744LLU: // deleter
9267	9510	{
9268	9511	// throw from newvar
9269	9512	if(!stack[base + 13])
9270	9513	{
9271	9514	fprintf(stderr, "in function newvar: unrolling stack, skipping already deleted/unscoped variable letdef \n");
9272		- label = 710LLU; // skip, variable already deleted/unscoped
	9515	+ label = 742LLU; // skip, variable already deleted/unscoped
9273	9516	break;
9274	9517	}
9275	9518	fprintf(stderr, "in function newvar: unrolling stack, variable letdef \n");

		@@ -9279,28 +9522,28 @@
9279	9522	newstack[0] = (uint64_t)stack; // backup stack location
9280	9523	newstack[1] = 1234567890;
9281	9524	newstack[2] = base;
9282		- newstack[3] = 714LLU;
	9525	+ newstack[3] = 746LLU;
9283	9526	stack = newstack;
9284	9527	// set stack-base & callee-address
9285	9528	base = 4/deloffset/;
9286		- label = 438LLU; // ~letdef
	9529	+ label = 455LLU; // ~letdef
9287	9530	break;
9288	9531	}
9289		- case 714LLU: // return from ~letdef to newvar
	9532	+ case 746LLU: // return from ~letdef to newvar
9290	9533	{
9291	9534	stack = (uint64_t *)stack[0];
9292	9535	// releasing toplevel container
9293	9536	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 13] - sizeof(uint64_t) 4));
9294	9537
9295		- label = 710LLU; // continue unrolling stack, delete next variable
	9538	+ label = 742LLU; // continue unrolling stack, delete next variable
9296	9539	break;
9297	9540	}
9298		- case 713LLU: // skipped deleter
	9541	+ case 745LLU: // skipped deleter
9299	9542	{
9300	9543	// construct letdef.letdef
9301	9544	if(!(stack[base + 13] = construct(5)))
9302	9545	{
9303		- label = 710LLU; // throw: begin to unroll stack
	9546	+ label = 742LLU; // throw: begin to unroll stack
9304	9547	break;
9305	9548	}
9306	9549

		@@ -9324,9 +9567,9 @@
9324	9567	}
9325	9568	printf("%s", "\n stack[base + ");
9326	9569	// call printnr from newvar
9327		- stack[base + 14LLU] = 715LLU/throw to this address/;
	9570	+ stack[base + 14LLU] = 747LLU/throw to this address/;
9328	9571	stack[base + 15LLU] = base;
9329		- stack[base + 16LLU] = 716LLU;
	9572	+ stack[base + 16LLU] = 748LLU;
9330	9573	// arguments for call to printnr
9331	9574	stack[base + 17LLU] = stack[base + 10]/sum/;
9332	9575	// set stack-base & callee-address

		@@ -9334,21 +9577,21 @@
9334	9577	label = 18446744073709551590LLU; // printnr
9335	9578	break;
9336	9579	}
9337		- case 715LLU: // copy-back deleter (printnr to newvar)
	9580	+ case 747LLU: // copy-back deleter (printnr to newvar)
9338	9581	{
9339	9582	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
9340	9583	// copy mutable arguments back from call to printnr
9341		- label = 712LLU; // continue to roll stack
	9584	+ label = 744LLU; // continue to roll stack
9342	9585	break;
9343	9586	}
9344		- case 716LLU: // return from printnr to newvar
	9587	+ case 748LLU: // return from printnr to newvar
9345	9588	{
9346	9589	// copy mutable arguments back from call to printnr
9347	9590	printf("%s", "/*");
9348	9591	// call printid from newvar
9349		- stack[base + 14LLU] = 717LLU/throw to this address/;
	9592	+ stack[base + 14LLU] = 749LLU/throw to this address/;
9350	9593	stack[base + 15LLU] = base;
9351		- stack[base + 16LLU] = 718LLU;
	9594	+ stack[base + 16LLU] = 750LLU;
9352	9595	// arguments for call to printid
9353	9596	stack[base + 17LLU] = stack[base + 1]/id/;
9354	9597	// set stack-base & callee-address

		@@ -9356,33 +9599,40 @@
9356	9599	label = 18446744073709551587LLU; // printid
9357	9600	break;
9358	9601	}
9359		- case 717LLU: // copy-back deleter (printid to newvar)
	9602	+ case 749LLU: // copy-back deleter (printid to newvar)
9360	9603	{
9361	9604	fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
9362	9605	// copy mutable arguments back from call to printid
9363		- label = 712LLU; // continue to roll stack
	9606	+ label = 744LLU; // continue to roll stack
9364	9607	break;
9365	9608	}
9366		- case 718LLU: // return from printid to newvar
	9609	+ case 750LLU: // return from printid to newvar
9367	9610	{
9368	9611	// copy mutable arguments back from call to printid
9369	9612	printf("%s", "*/] = 0; // init");
9370	9613	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
9371	9614	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
9372		- label = 696LLU; // case complete
	9615	+ label = 727LLU; // case complete
9373	9616	break;
9374	9617	}
9375		- case 697LLU: // try next case
	9618	+ case 729LLU: // copy-back deleter (switch)
9376	9619	{
	9620	+ ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
	9621	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
	9622	+ label = 724LLU; // continue to unroll stack
	9623	+ break;
	9624	+ }
	9625	+ case 728LLU: // try next case
	9626	+ {
9377	9627	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
9378	9628	exit(-1);
9379	9629	}
9380		- case 696LLU: // completed switch
	9630	+ case 727LLU: // completed switch
9381	9631	{
9382	9632	// call add from newvar
9383		- stack[base + 8LLU] = 719LLU/throw to this address/;
	9633	+ stack[base + 8LLU] = 751LLU/throw to this address/;
9384	9634	stack[base + 9LLU] = base;
9385		- stack[base + 10LLU] = 720LLU;
	9635	+ stack[base + 10LLU] = 752LLU;
9386	9636	// arguments for call to add
9387	9637	stack[base + 12LLU] = 1LLU;
9388	9638	stack[base + 13LLU] = stack[base + 6]/varcount/;

		@@ -9391,22 +9641,22 @@
9391	9641	label = 18446744073709551605LLU; // add
9392	9642	break;
9393	9643	}
9394		- case 719LLU: // copy-back deleter (add to newvar)
	9644	+ case 751LLU: // copy-back deleter (add to newvar)
9395	9645	{
9396	9646	fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
9397	9647	// copy mutable arguments back from call to add
9398		- label = 693LLU; // continue to roll stack
	9648	+ label = 724LLU; // continue to roll stack
9399	9649	break;
9400	9650	}
9401		- case 720LLU: // return from add to newvar
	9651	+ case 752LLU: // return from add to newvar
9402	9652	{
9403	9653	// copy mutable arguments back from call to add
9404	9654	// copy back results provided by call to add
9405	9655	stack[base + 6] = stack[base + 11LLU];
9406	9656	// call max from newvar
9407		- stack[base + 8LLU] = 721LLU/throw to this address/;
	9657	+ stack[base + 8LLU] = 753LLU/throw to this address/;
9408	9658	stack[base + 9LLU] = base;
9409		- stack[base + 10LLU] = 722LLU;
	9659	+ stack[base + 10LLU] = 754LLU;
9410	9660	// arguments for call to max
9411	9661	stack[base + 12LLU] = stack[base + 6]/varcount/;
9412	9662	stack[base + 13LLU] = stack[base + 5]/fnmaxcount/;

		@@ -9415,14 +9665,14 @@
9415	9665	label = 18446744073709551606LLU; // max
9416	9666	break;
9417	9667	}
9418		- case 721LLU: // copy-back deleter (max to newvar)
	9668	+ case 753LLU: // copy-back deleter (max to newvar)
9419	9669	{
9420	9670	fprintf(stderr, "in function newvar: unrolling stack, copy-back (max to newvar)\n");
9421	9671	// copy mutable arguments back from call to max
9422		- label = 693LLU; // continue to roll stack
	9672	+ label = 724LLU; // continue to roll stack
9423	9673	break;
9424	9674	}
9425		- case 722LLU: // return from max to newvar
	9675	+ case 754LLU: // return from max to newvar
9426	9676	{
9427	9677	// copy mutable arguments back from call to max
9428	9678	// copy back results provided by call to max

		@@ -9432,7 +9682,7 @@
9432	9682	base = stack[base - 2];
9433	9683	break;
9434	9684	}
9435		- case 724LLU: // function unscopelet failed
	9685	+ case 756LLU: // function unscopelet failed
9436	9686	{
9437	9687	fprintf(stderr, "function unscopelet failed\n");
9438	9688	label = stack[base - 3];

		@@ -9439,7 +9689,7 @@
9439	9689	base = stack[base - 2];
9440	9690	break;
9441	9691	}
9442		- case 723LLU: // unscopelet
	9692	+ case 755LLU: // unscopelet
9443	9693	{
9444	9694	//#define arg0 0
9445	9695	//#define arg1 1

		@@ -9446,7 +9696,7 @@
9446	9696	//#define arg2 2
9447	9697	if(/scope/0 != ((uint64_t )(stack[base + 1]/scope*/))[0])
9448	9698	{
9449		- label = 726LLU; // jump to alternative
	9699	+ label = 758LLU; // jump to alternative
9450	9700	break;
9451	9701	}
9452	9702

		@@ -9454,28 +9704,28 @@
9454	9704	/LETDEFS/stack[base + 4] = ((uint64_t *)(stack[base + 1]/scope/))[1][1]/letdefs*/;
9455	9705
9456	9706	// case
9457		- label = 728LLU; // skip deleter
	9707	+ label = 761LLU; // skip deleter
9458	9708	break;
9459	9709	}
9460		- case 727LLU: // deleter
	9710	+ case 760LLU: // deleter
9461	9711	{
9462	9712	// throw from unscopelet
9463	9713	if(!stack[base + 5])
9464	9714	{
9465	9715	fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable [letdef] \n");
9466		- label = 724LLU; // skip, variable already deleted/unscoped
	9716	+ label = 759LLU; // skip, variable already deleted/unscoped
9467	9717	break;
9468	9718	}
9469	9719	fprintf(stderr, "in function unscopelet: unrolling stack, variable [letdef] \n");
9470	9720	// delete list
9471		- label = 729LLU; // start to repeat
	9721	+ label = 762LLU; // start to repeat
9472	9722	break;
9473	9723	}
9474		- case 729LLU: // repeat from here
	9724	+ case 762LLU: // repeat from here
9475	9725	{
9476	9726	if(!stack[base + 5])
9477	9727	{
9478		- label = 730LLU; // break loop
	9728	+ label = 763LLU; // break loop
9479	9729	break;
9480	9730	}
9481	9731

		@@ -9486,14 +9736,14 @@
9486	9736	newstack[0] = (uint64_t)stack; // backup stack location
9487	9737	newstack[1] = 1234567890;
9488	9738	newstack[2] = base;
9489		- newstack[3] = 731LLU;
	9739	+ newstack[3] = 764LLU;
9490	9740	stack = newstack;
9491	9741	// set stack-base & callee-address
9492	9742	base = 4/deloffset/;
9493		- label = 438LLU; // ~letdef
	9743	+ label = 455LLU; // ~letdef
9494	9744	break;
9495	9745	}
9496		- case 731LLU: // return from ~letdef to unscopelet
	9746	+ case 764LLU: // return from ~letdef to unscopelet
9497	9747	{
9498	9748	stack = (uint64_t *)stack[0];
9499	9749	// releasing toplevel container

		@@ -9504,44 +9754,44 @@
9504	9754	stack[base + 5] = (uint64_t)list->next;
9505	9755	Free(1, sizeof(struct listnode), list);
9506	9756	}
9507		- label = 729LLU; // repeat
	9757	+ label = 762LLU; // repeat
9508	9758	break;
9509	9759	}
9510		- case 730LLU: // loop finished
	9760	+ case 763LLU: // loop finished
9511	9761	{
9512		- label = 724LLU; // continue unrolling stack, delete next variable
	9762	+ label = 759LLU; // continue unrolling stack, delete next variable
9513	9763	break;
9514	9764	}
9515		- case 728LLU: // skipped deleter
	9765	+ case 761LLU: // skipped deleter
9516	9766	{
9517	9767	stack[base + 5] = 0;
9518		- label = 733LLU; // skip deleter
	9768	+ label = 766LLU; // skip deleter
9519	9769	break;
9520	9770	}
9521		- case 732LLU: // deleter
	9771	+ case 765LLU: // deleter
9522	9772	{
9523	9773	// throw from unscopelet
9524	9774	if(!stack[base + 6])
9525	9775	{
9526	9776	fprintf(stderr, "in function unscopelet: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9527		- label = 727LLU; // skip, variable already deleted/unscoped
	9777	+ label = 760LLU; // skip, variable already deleted/unscoped
9528	9778	break;
9529	9779	}
9530	9780	fprintf(stderr, "in function unscopelet: unrolling stack, variable u64 \n");
9531		- label = 727LLU; // continue unrolling stack, delete next variable
	9781	+ label = 760LLU; // continue unrolling stack, delete next variable
9532	9782	break;
9533	9783	}
9534		- case 733LLU: // skipped deleter
	9784	+ case 766LLU: // skipped deleter
9535	9785	{
9536	9786	stack[base + 6] = 0;
9537		- label = 734LLU; // start to repeat
	9787	+ label = 767LLU; // start to repeat
9538	9788	break;
9539	9789	}
9540		- case 734LLU: // repeat from here
	9790	+ case 767LLU: // repeat from here
9541	9791	{
9542	9792	if(!stack[base + 4])
9543	9793	{
9544		- label = 735LLU; // break loop
	9794	+ label = 768LLU; // break loop
9545	9795	break;
9546	9796	}
9547	9797

		@@ -9554,29 +9804,29 @@
9554	9804	}
9555	9805	if(!stack[base + 6]/found/)
9556	9806	{
9557		- label = 736LLU; // jump to alternative
	9807	+ label = 769LLU; // jump to alternative
9558	9808	break;
9559	9809	}
9560	9810
9561	9811	// consequent
9562	9812	// call mkletdummy from unscopelet
9563		- stack[base + 9LLU] = 738LLU/throw to this address/;
	9813	+ stack[base + 9LLU] = 771LLU/throw to this address/;
9564	9814	stack[base + 10LLU] = base;
9565		- stack[base + 11LLU] = 739LLU;
	9815	+ stack[base + 11LLU] = 772LLU;
9566	9816	// arguments for call to mkletdummy
9567	9817	// set stack-base & callee-address
9568	9818	base += 12LLU;
9569		- label = 441LLU; // mkletdummy
	9819	+ label = 458LLU; // mkletdummy
9570	9820	break;
9571	9821	}
9572		- case 738LLU: // copy-back deleter (mkletdummy to unscopelet)
	9822	+ case 771LLU: // copy-back deleter (mkletdummy to unscopelet)
9573	9823	{
9574	9824	fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (mkletdummy to unscopelet)\n");
9575	9825	// copy mutable arguments back from call to mkletdummy
9576		- label = 732LLU; // continue to roll stack
	9826	+ label = 765LLU; // continue to roll stack
9577	9827	break;
9578	9828	}
9579		- case 739LLU: // return from mkletdummy to unscopelet
	9829	+ case 772LLU: // return from mkletdummy to unscopelet
9580	9830	{
9581	9831	// copy mutable arguments back from call to mkletdummy
9582	9832	// copy back results provided by call to mkletdummy

		@@ -9593,14 +9843,14 @@
9593	9843	stack[base + 5]/letdefs/ = (uint64_t)list;
9594	9844	MOVE(&list->data, &stack[base + 8]/tmp/);
9595	9845	}
9596		- label = 737LLU; // consequent complete
	9846	+ label = 770LLU; // consequent complete
9597	9847	break;
9598	9848	}
9599		- case 736LLU: // alternative
	9849	+ case 769LLU: // alternative
9600	9850	{
9601	9851	if(/letdef/0 != ((uint64_t )(stack[base + 7]/letdef*/))[0])
9602	9852	{
9603		- label = 741LLU; // jump to alternative
	9853	+ label = 774LLU; // jump to alternative
9604	9854	break;
9605	9855	}
9606	9856

		@@ -9612,9 +9862,9 @@
9612	9862
9613	9863	// case
9614	9864	// call equ from unscopelet
9615		- stack[base + 13LLU] = 742LLU/throw to this address/;
	9865	+ stack[base + 13LLU] = 776LLU/throw to this address/;
9616	9866	stack[base + 14LLU] = base;
9617		- stack[base + 15LLU] = 743LLU;
	9867	+ stack[base + 15LLU] = 777LLU;
9618	9868	// arguments for call to equ
9619	9869	stack[base + 17LLU] = stack[base + 9]/curid/;
9620	9870	stack[base + 18LLU] = stack[base + 2]/id/;

		@@ -9623,14 +9873,14 @@
9623	9873	label = 18446744073709551600LLU; // equ
9624	9874	break;
9625	9875	}
9626		- case 742LLU: // copy-back deleter (equ to unscopelet)
	9876	+ case 776LLU: // copy-back deleter (equ to unscopelet)
9627	9877	{
9628	9878	fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (equ to unscopelet)\n");
9629	9879	// copy mutable arguments back from call to equ
9630		- label = 732LLU; // continue to roll stack
	9880	+ label = 775LLU; // continue to roll stack
9631	9881	break;
9632	9882	}
9633		- case 743LLU: // return from equ to unscopelet
	9883	+ case 777LLU: // return from equ to unscopelet
9634	9884	{
9635	9885	// copy mutable arguments back from call to equ
9636	9886	// copy back results provided by call to equ

		@@ -9640,46 +9890,56 @@
9640	9890	((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 10];
9641	9891	((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
9642	9892	((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
9643		- label = 740LLU; // case complete
	9893	+ label = 773LLU; // case complete
9644	9894	break;
9645	9895	}
9646		- case 741LLU: // try next case
	9896	+ case 775LLU: // copy-back deleter (switch)
9647	9897	{
	9898	+ ((uint64_t **)(stack[base + 7]))[1][4] = stack[base + 12];
	9899	+ ((uint64_t **)(stack[base + 7]))[1][3] = stack[base + 11];
	9900	+ ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 10];
	9901	+ ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
	9902	+ ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
	9903	+ label = 765LLU; // continue to unroll stack
	9904	+ break;
	9905	+ }
	9906	+ case 774LLU: // try next case
	9907	+ {
9648	9908	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
9649	9909	exit(-1);
9650	9910	}
9651		- case 740LLU: // completed switch
	9911	+ case 773LLU: // completed switch
9652	9912	{
9653	9913	if(!stack[base + 6]/found/)
9654	9914	{
9655		- label = 744LLU; // jump to alternative
	9915	+ label = 778LLU; // jump to alternative
9656	9916	break;
9657	9917	}
9658	9918
9659	9919	// consequent
9660		- label = 745LLU; // consequent complete
	9920	+ label = 779LLU; // consequent complete
9661	9921	break;
9662	9922	}
9663		- case 744LLU: // alternative
	9923	+ case 778LLU: // alternative
9664	9924	{
9665	9925	// call mkletdummy from unscopelet
9666		- stack[base + 9LLU] = 746LLU/throw to this address/;
	9926	+ stack[base + 9LLU] = 780LLU/throw to this address/;
9667	9927	stack[base + 10LLU] = base;
9668		- stack[base + 11LLU] = 747LLU;
	9928	+ stack[base + 11LLU] = 781LLU;
9669	9929	// arguments for call to mkletdummy
9670	9930	// set stack-base & callee-address
9671	9931	base += 12LLU;
9672		- label = 441LLU; // mkletdummy
	9932	+ label = 458LLU; // mkletdummy
9673	9933	break;
9674	9934	}
9675		- case 746LLU: // copy-back deleter (mkletdummy to unscopelet)
	9935	+ case 780LLU: // copy-back deleter (mkletdummy to unscopelet)
9676	9936	{
9677	9937	fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (mkletdummy to unscopelet)\n");
9678	9938	// copy mutable arguments back from call to mkletdummy
9679		- label = 732LLU; // continue to roll stack
	9939	+ label = 765LLU; // continue to roll stack
9680	9940	break;
9681	9941	}
9682		- case 747LLU: // return from mkletdummy to unscopelet
	9942	+ case 781LLU: // return from mkletdummy to unscopelet
9683	9943	{
9684	9944	// copy mutable arguments back from call to mkletdummy
9685	9945	// copy back results provided by call to mkletdummy

		@@ -9696,15 +9956,15 @@
9696	9956	stack[base + 5]/letdefs/ = (uint64_t)list;
9697	9957	MOVE(&list->data, &stack[base + 8]/tmp/);
9698	9958	}
9699		- label = 745LLU; // alternative complete
	9959	+ label = 779LLU; // alternative complete
9700	9960	break;
9701	9961	}
9702		- case 745LLU: // completed if-then-else
	9962	+ case 779LLU: // completed if-then-else
9703	9963	{
9704		- label = 737LLU; // alternative complete
	9964	+ label = 770LLU; // alternative complete
9705	9965	break;
9706	9966	}
9707		- case 737LLU: // completed if-then-else
	9967	+ case 770LLU: // completed if-then-else
9708	9968	{
9709	9969
9710	9970	uint64_t newstack = (uint64_t )(stack[base + 7] - sizeof(uint64_t) * 4);

		@@ -9712,43 +9972,43 @@
9712	9972	newstack[0] = (uint64_t)stack; // backup stack location
9713	9973	newstack[1] = 1234567890;
9714	9974	newstack[2] = base;
9715		- newstack[3] = 748LLU;
	9975	+ newstack[3] = 782LLU;
9716	9976	stack = newstack;
9717	9977	// set stack-base & callee-address
9718	9978	base = 4/deloffset/;
9719		- label = 438LLU; // ~letdef
	9979	+ label = 455LLU; // ~letdef
9720	9980	break;
9721	9981	}
9722		- case 748LLU: // return from ~letdef to unscopelet
	9982	+ case 782LLU: // return from ~letdef to unscopelet
9723	9983	{
9724	9984	stack = (uint64_t *)stack[0];
9725	9985	// releasing toplevel container
9726	9986	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 7] - sizeof(uint64_t) 4));
9727	9987
9728		- label = 734LLU; // repeat
	9988	+ label = 767LLU; // repeat
9729	9989	break;
9730	9990	}
9731		- case 735LLU: // loop finished
	9991	+ case 768LLU: // loop finished
9732	9992	{
9733	9993	list_reverse(((struct listnode *)(&stack[base + 5]/letdefs*/)));
9734	9994	swap(&stack[base + 5], &stack[base + 4]);
9735	9995	if(!stack[base + 6]/found/)
9736	9996	{
9737		- label = 749LLU; // jump to alternative
	9997	+ label = 783LLU; // jump to alternative
9738	9998	break;
9739	9999	}
9740	10000
9741	10001	// consequent
9742		- label = 750LLU; // consequent complete
	10002	+ label = 784LLU; // consequent complete
9743	10003	break;
9744	10004	}
9745		- case 749LLU: // alternative
	10005	+ case 783LLU: // alternative
9746	10006	{
9747	10007	fprintf(stderr, "%s", "in function ");
9748	10008	// call reportid from unscopelet
9749		- stack[base + 8LLU] = 751LLU/throw to this address/;
	10009	+ stack[base + 8LLU] = 785LLU/throw to this address/;
9750	10010	stack[base + 9LLU] = base;
9751		- stack[base + 10LLU] = 752LLU;
	10011	+ stack[base + 10LLU] = 786LLU;
9752	10012	// arguments for call to reportid
9753	10013	stack[base + 11LLU] = stack[base + 0]/fnid/;
9754	10014	// set stack-base & callee-address

		@@ -9756,22 +10016,22 @@
9756	10016	label = 18446744073709551586LLU; // reportid
9757	10017	break;
9758	10018	}
9759		- case 751LLU: // copy-back deleter (reportid to unscopelet)
	10019	+ case 785LLU: // copy-back deleter (reportid to unscopelet)
9760	10020	{
9761	10021	fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (reportid to unscopelet)\n");
9762	10022	// copy mutable arguments back from call to reportid
9763		- label = 732LLU; // continue to roll stack
	10023	+ label = 765LLU; // continue to roll stack
9764	10024	break;
9765	10025	}
9766		- case 752LLU: // return from reportid to unscopelet
	10026	+ case 786LLU: // return from reportid to unscopelet
9767	10027	{
9768	10028	// copy mutable arguments back from call to reportid
9769	10029	fprintf(stderr, "%s", ": ");
9770	10030	fprintf(stderr, "%s", "failed to uninitialize variable ");
9771	10031	// call reportid from unscopelet
9772		- stack[base + 8LLU] = 753LLU/throw to this address/;
	10032	+ stack[base + 8LLU] = 787LLU/throw to this address/;
9773	10033	stack[base + 9LLU] = base;
9774		- stack[base + 10LLU] = 754LLU;
	10034	+ stack[base + 10LLU] = 788LLU;
9775	10035	// arguments for call to reportid
9776	10036	stack[base + 11LLU] = stack[base + 2]/id/;
9777	10037	// set stack-base & callee-address

		@@ -9779,32 +10039,32 @@
9779	10039	label = 18446744073709551586LLU; // reportid
9780	10040	break;
9781	10041	}
9782		- case 753LLU: // copy-back deleter (reportid to unscopelet)
	10042	+ case 787LLU: // copy-back deleter (reportid to unscopelet)
9783	10043	{
9784	10044	fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (reportid to unscopelet)\n");
9785	10045	// copy mutable arguments back from call to reportid
9786		- label = 732LLU; // continue to roll stack
	10046	+ label = 765LLU; // continue to roll stack
9787	10047	break;
9788	10048	}
9789		- case 754LLU: // return from reportid to unscopelet
	10049	+ case 788LLU: // return from reportid to unscopelet
9790	10050	{
9791	10051	// copy mutable arguments back from call to reportid
9792	10052	fprintf(stderr, "%s", " because it is not in scope.\n");
9793	10053	exit(-1);
9794		- label = 750LLU; // alternative complete
	10054	+ label = 784LLU; // alternative complete
9795	10055	break;
9796	10056	}
9797		- case 750LLU: // completed if-then-else
	10057	+ case 784LLU: // completed if-then-else
9798	10058	{
9799	10059	// delete list
9800		- label = 755LLU; // start to repeat
	10060	+ label = 789LLU; // start to repeat
9801	10061	break;
9802	10062	}
9803		- case 755LLU: // repeat from here
	10063	+ case 789LLU: // repeat from here
9804	10064	{
9805	10065	if(!stack[base + 5])
9806	10066	{
9807		- label = 756LLU; // break loop
	10067	+ label = 790LLU; // break loop
9808	10068	break;
9809	10069	}
9810	10070

		@@ -9815,14 +10075,14 @@
9815	10075	newstack[0] = (uint64_t)stack; // backup stack location
9816	10076	newstack[1] = 1234567890;
9817	10077	newstack[2] = base;
9818		- newstack[3] = 757LLU;
	10078	+ newstack[3] = 791LLU;
9819	10079	stack = newstack;
9820	10080	// set stack-base & callee-address
9821	10081	base = 4/deloffset/;
9822		- label = 438LLU; // ~letdef
	10082	+ label = 455LLU; // ~letdef
9823	10083	break;
9824	10084	}
9825		- case 757LLU: // return from ~letdef to unscopelet
	10085	+ case 791LLU: // return from ~letdef to unscopelet
9826	10086	{
9827	10087	stack = (uint64_t *)stack[0];
9828	10088	// releasing toplevel container

		@@ -9833,22 +10093,29 @@
9833	10093	stack[base + 5] = (uint64_t)list->next;
9834	10094	Free(1, sizeof(struct listnode), list);
9835	10095	}
9836		- label = 755LLU; // repeat
	10096	+ label = 789LLU; // repeat
9837	10097	break;
9838	10098	}
9839		- case 756LLU: // loop finished
	10099	+ case 790LLU: // loop finished
9840	10100	{
9841	10101	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
9842	10102	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
9843		- label = 725LLU; // case complete
	10103	+ label = 757LLU; // case complete
9844	10104	break;
9845	10105	}
9846		- case 726LLU: // try next case
	10106	+ case 759LLU: // copy-back deleter (switch)
9847	10107	{
	10108	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
	10109	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
	10110	+ label = 756LLU; // continue to unroll stack
	10111	+ break;
	10112	+ }
	10113	+ case 758LLU: // try next case
	10114	+ {
9848	10115	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
9849	10116	exit(-1);
9850	10117	}
9851		- case 725LLU: // completed switch
	10118	+ case 757LLU: // completed switch
9852	10119	{
9853	10120	// return from unscopelet
9854	10121	label = stack[base - 1];

		@@ -9855,7 +10122,7 @@
9855	10122	base = stack[base - 2];
9856	10123	break;
9857	10124	}
9858		- case 758LLU: // ~idnr
	10125	+ case 792LLU: // ~idnr
9859	10126	{
9860	10127	if(stack[base + 0]/variant-nr/ >= 1)
9861	10128	{

		@@ -9862,10 +10129,10 @@
9862	10129	fprintf(stderr, "in ~idnr: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
9863	10130	exit(-1);
9864	10131	}
9865		- label = 758LLU + 1LLU + stack[base + 0]/variant-nr/;
	10132	+ label = 792LLU + 1LLU + stack[base + 0]/variant-nr/;
9866	10133	break;
9867	10134	}
9868		- case 758LLU + 1LLU + 0LLU: // ~idnr.idnr
	10135	+ case 792LLU + 1LLU + 0LLU: // ~idnr.idnr
9869	10136	{
9870	10137	// release element id
9871	10138	// release element nr

		@@ -9875,7 +10142,7 @@
9875	10142	base = stack[base - 2];
9876	10143	break;
9877	10144	}
9878		- case 761LLU: // function lookidnr failed
	10145	+ case 795LLU: // function lookidnr failed
9879	10146	{
9880	10147	fprintf(stderr, "function lookidnr failed\n");
9881	10148	label = stack[base - 3];

		@@ -9882,39 +10149,39 @@
9882	10149	base = stack[base - 2];
9883	10150	break;
9884	10151	}
9885		- case 760LLU: // lookidnr
	10152	+ case 794LLU: // lookidnr
9886	10153	{
9887	10154	//#define res0 0
9888	10155	//#define arg0 1
9889	10156	//#define arg1 2
9890		- label = 763LLU; // skip deleter
	10157	+ label = 797LLU; // skip deleter
9891	10158	break;
9892	10159	}
9893		- case 762LLU: // deleter
	10160	+ case 796LLU: // deleter
9894	10161	{
9895	10162	// throw from lookidnr
9896	10163	if(!stack[base + 3])
9897	10164	{
9898	10165	fprintf(stderr, "in function lookidnr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
9899		- label = 761LLU; // skip, variable already deleted/unscoped
	10166	+ label = 795LLU; // skip, variable already deleted/unscoped
9900	10167	break;
9901	10168	}
9902	10169	fprintf(stderr, "in function lookidnr: unrolling stack, variable u64 \n");
9903		- label = 761LLU; // continue unrolling stack, delete next variable
	10170	+ label = 795LLU; // continue unrolling stack, delete next variable
9904	10171	break;
9905	10172	}
9906		- case 763LLU: // skipped deleter
	10173	+ case 797LLU: // skipped deleter
9907	10174	{
9908	10175	stack[base + 3] = 0;
9909	10176	flippedassign(stack[base + 1]/idnrs/, &stack[base + 4]);
9910		- label = 764LLU; // start to repeat
	10177	+ label = 798LLU; // start to repeat
9911	10178	break;
9912	10179	}
9913		- case 764LLU: // repeat from here
	10180	+ case 798LLU: // repeat from here
9914	10181	{
9915	10182	if(!stack[base + 4])
9916	10183	{
9917		- label = 765LLU; // break loop
	10184	+ label = 799LLU; // break loop
9918	10185	break;
9919	10186	}
9920	10187

		@@ -9924,19 +10191,19 @@
9924	10191	stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
9925	10192	if(!stack[base + 3]/found/)
9926	10193	{
9927		- label = 766LLU; // jump to alternative
	10194	+ label = 800LLU; // jump to alternative
9928	10195	break;
9929	10196	}
9930	10197
9931	10198	// consequent
9932		- label = 767LLU; // consequent complete
	10199	+ label = 801LLU; // consequent complete
9933	10200	break;
9934	10201	}
9935		- case 766LLU: // alternative
	10202	+ case 800LLU: // alternative
9936	10203	{
9937	10204	if(/idnr/0 != ((uint64_t )(stack[base + 5]/idnr*/))[0])
9938	10205	{
9939		- label = 769LLU; // jump to alternative
	10206	+ label = 803LLU; // jump to alternative
9940	10207	break;
9941	10208	}
9942	10209

		@@ -9945,9 +10212,9 @@
9945	10212
9946	10213	// case
9947	10214	// call equ from lookidnr
9948		- stack[base + 9LLU] = 770LLU/throw to this address/;
	10215	+ stack[base + 9LLU] = 805LLU/throw to this address/;
9949	10216	stack[base + 10LLU] = base;
9950		- stack[base + 11LLU] = 771LLU;
	10217	+ stack[base + 11LLU] = 806LLU;
9951	10218	// arguments for call to equ
9952	10219	stack[base + 13LLU] = stack[base + 7]/id/;
9953	10220	stack[base + 14LLU] = stack[base + 2]/wanted/;

		@@ -9956,14 +10223,14 @@
9956	10223	label = 18446744073709551600LLU; // equ
9957	10224	break;
9958	10225	}
9959		- case 770LLU: // copy-back deleter (equ to lookidnr)
	10226	+ case 805LLU: // copy-back deleter (equ to lookidnr)
9960	10227	{
9961	10228	fprintf(stderr, "in function lookidnr: unrolling stack, copy-back (equ to lookidnr)\n");
9962	10229	// copy mutable arguments back from call to equ
9963		- label = 762LLU; // continue to roll stack
	10230	+ label = 804LLU; // continue to roll stack
9964	10231	break;
9965	10232	}
9966		- case 771LLU: // return from equ to lookidnr
	10233	+ case 806LLU: // return from equ to lookidnr
9967	10234	{
9968	10235	// copy mutable arguments back from call to equ
9969	10236	// copy back results provided by call to equ

		@@ -9970,44 +10237,51 @@
9970	10237	stack[base + 3] = stack[base + 12LLU];
9971	10238	((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
9972	10239	((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
9973		- label = 768LLU; // case complete
	10240	+ label = 802LLU; // case complete
9974	10241	break;
9975	10242	}
9976		- case 769LLU: // try next case
	10243	+ case 804LLU: // copy-back deleter (switch)
9977	10244	{
	10245	+ ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
	10246	+ ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
	10247	+ label = 796LLU; // continue to unroll stack
	10248	+ break;
	10249	+ }
	10250	+ case 803LLU: // try next case
	10251	+ {
9978	10252	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
9979	10253	exit(-1);
9980	10254	}
9981		- case 768LLU: // completed switch
	10255	+ case 802LLU: // completed switch
9982	10256	{
9983		- label = 767LLU; // alternative complete
	10257	+ label = 801LLU; // alternative complete
9984	10258	break;
9985	10259	}
9986		- case 767LLU: // completed if-then-else
	10260	+ case 801LLU: // completed if-then-else
9987	10261	{
9988	10262	((struct listnode )(stack[base + 6]/previous*/))->data = stack[base + 5];
9989		- label = 764LLU; // repeat
	10263	+ label = 798LLU; // repeat
9990	10264	break;
9991	10265	}
9992		- case 765LLU: // loop finished
	10266	+ case 799LLU: // loop finished
9993	10267	{
9994		- label = 773LLU; // skip deleter
	10268	+ label = 808LLU; // skip deleter
9995	10269	break;
9996	10270	}
9997		- case 772LLU: // deleter
	10271	+ case 807LLU: // deleter
9998	10272	{
9999	10273	// throw from lookidnr
10000	10274	if(!stack[base + 0])
10001	10275	{
10002	10276	fprintf(stderr, "in function lookidnr: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10003		- label = 762LLU; // skip, variable already deleted/unscoped
	10277	+ label = 796LLU; // skip, variable already deleted/unscoped
10004	10278	break;
10005	10279	}
10006	10280	fprintf(stderr, "in function lookidnr: unrolling stack, variable u64 \n");
10007		- label = 762LLU; // continue unrolling stack, delete next variable
	10281	+ label = 796LLU; // continue unrolling stack, delete next variable
10008	10282	break;
10009	10283	}
10010		- case 773LLU: // skipped deleter
	10284	+ case 808LLU: // skipped deleter
10011	10285	{
10012	10286	stack[base + 0] = stack[base + 3]/found/;
10013	10287	// return from lookidnr

		@@ -10015,7 +10289,7 @@
10015	10289	base = stack[base - 2];
10016	10290	break;
10017	10291	}
10018		- case 775LLU: // function reportidnr failed
	10292	+ case 810LLU: // function reportidnr failed
10019	10293	{
10020	10294	fprintf(stderr, "function reportidnr failed\n");
10021	10295	label = stack[base - 3];

		@@ -10022,12 +10296,12 @@
10022	10296	base = stack[base - 2];
10023	10297	break;
10024	10298	}
10025		- case 774LLU: // reportidnr
	10299	+ case 809LLU: // reportidnr
10026	10300	{
10027	10301	//#define arg0 0
10028	10302	if(/idnr/0 != ((uint64_t )(stack[base + 0]/idnr*/))[0])
10029	10303	{
10030		- label = 777LLU; // jump to alternative
	10304	+ label = 812LLU; // jump to alternative
10031	10305	break;
10032	10306	}
10033	10307

		@@ -10036,9 +10310,9 @@
10036	10310
10037	10311	// case
10038	10312	// call reportid from reportidnr
10039		- stack[base + 3LLU] = 778LLU/throw to this address/;
	10313	+ stack[base + 3LLU] = 814LLU/throw to this address/;
10040	10314	stack[base + 4LLU] = base;
10041		- stack[base + 5LLU] = 779LLU;
	10315	+ stack[base + 5LLU] = 815LLU;
10042	10316	// arguments for call to reportid
10043	10317	stack[base + 6LLU] = stack[base + 1]/id/;
10044	10318	// set stack-base & callee-address

		@@ -10046,21 +10320,21 @@
10046	10320	label = 18446744073709551586LLU; // reportid
10047	10321	break;
10048	10322	}
10049		- case 778LLU: // copy-back deleter (reportid to reportidnr)
	10323	+ case 814LLU: // copy-back deleter (reportid to reportidnr)
10050	10324	{
10051	10325	fprintf(stderr, "in function reportidnr: unrolling stack, copy-back (reportid to reportidnr)\n");
10052	10326	// copy mutable arguments back from call to reportid
10053		- label = 775LLU; // continue to roll stack
	10327	+ label = 813LLU; // continue to roll stack
10054	10328	break;
10055	10329	}
10056		- case 779LLU: // return from reportid to reportidnr
	10330	+ case 815LLU: // return from reportid to reportidnr
10057	10331	{
10058	10332	// copy mutable arguments back from call to reportid
10059	10333	fprintf(stderr, "%s", " ");
10060	10334	// call reportnr from reportidnr
10061		- stack[base + 3LLU] = 780LLU/throw to this address/;
	10335	+ stack[base + 3LLU] = 816LLU/throw to this address/;
10062	10336	stack[base + 4LLU] = base;
10063		- stack[base + 5LLU] = 781LLU;
	10337	+ stack[base + 5LLU] = 817LLU;
10064	10338	// arguments for call to reportnr
10065	10339	stack[base + 6LLU] = stack[base + 2]/nr/;
10066	10340	// set stack-base & callee-address

		@@ -10068,27 +10342,34 @@
10068	10342	label = 18446744073709551589LLU; // reportnr
10069	10343	break;
10070	10344	}
10071		- case 780LLU: // copy-back deleter (reportnr to reportidnr)
	10345	+ case 816LLU: // copy-back deleter (reportnr to reportidnr)
10072	10346	{
10073	10347	fprintf(stderr, "in function reportidnr: unrolling stack, copy-back (reportnr to reportidnr)\n");
10074	10348	// copy mutable arguments back from call to reportnr
10075		- label = 775LLU; // continue to roll stack
	10349	+ label = 813LLU; // continue to roll stack
10076	10350	break;
10077	10351	}
10078		- case 781LLU: // return from reportnr to reportidnr
	10352	+ case 817LLU: // return from reportnr to reportidnr
10079	10353	{
10080	10354	// copy mutable arguments back from call to reportnr
10081	10355	((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
10082	10356	((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
10083		- label = 776LLU; // case complete
	10357	+ label = 811LLU; // case complete
10084	10358	break;
10085	10359	}
10086		- case 777LLU: // try next case
	10360	+ case 813LLU: // copy-back deleter (switch)
10087	10361	{
	10362	+ ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
	10363	+ ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
	10364	+ label = 810LLU; // continue to unroll stack
	10365	+ break;
	10366	+ }
	10367	+ case 812LLU: // try next case
	10368	+ {
10088	10369	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
10089	10370	exit(-1);
10090	10371	}
10091		- case 776LLU: // completed switch
	10372	+ case 811LLU: // completed switch
10092	10373	{
10093	10374	// return from reportidnr
10094	10375	label = stack[base - 1];

		@@ -10095,7 +10376,7 @@
10095	10376	base = stack[base - 2];
10096	10377	break;
10097	10378	}
10098		- case 782LLU: // ~elcopyback
	10379	+ case 818LLU: // ~elcopyback
10099	10380	{
10100	10381	if(stack[base + 0]/variant-nr/ >= 1)
10101	10382	{

		@@ -10102,10 +10383,10 @@
10102	10383	fprintf(stderr, "in ~elcopyback: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
10103	10384	exit(-1);
10104	10385	}
10105		- label = 782LLU + 1LLU + stack[base + 0]/variant-nr/;
	10386	+ label = 818LLU + 1LLU + stack[base + 0]/variant-nr/;
10106	10387	break;
10107	10388	}
10108		- case 782LLU + 1LLU + 0LLU: // ~elcopyback.elcopyback
	10389	+ case 818LLU + 1LLU + 0LLU: // ~elcopyback.elcopyback
10109	10390	{
10110	10391	// release element aliasindex
10111	10392	// release element dataidx

		@@ -10116,7 +10397,7 @@
10116	10397	base = stack[base - 2];
10117	10398	break;
10118	10399	}
10119		- case 785LLU: // function parsetype failed
	10400	+ case 821LLU: // function parsetype failed
10120	10401	{
10121	10402	fprintf(stderr, "function parsetype failed\n");
10122	10403	label = stack[base - 3];

		@@ -10123,7 +10404,7 @@
10123	10404	base = stack[base - 2];
10124	10405	break;
10125	10406	}
10126		- case 784LLU: // parsetype
	10407	+ case 820LLU: // parsetype
10127	10408	{
10128	10409	//#define res0 0
10129	10410	//#define res1 1

		@@ -10131,29 +10412,29 @@
10131	10412	//#define arg1 3
10132	10413	//#define arg2 4
10133	10414	//#define arg3 5
10134		- label = 787LLU; // skip deleter
	10415	+ label = 823LLU; // skip deleter
10135	10416	break;
10136	10417	}
10137		- case 786LLU: // deleter
	10418	+ case 822LLU: // deleter
10138	10419	{
10139	10420	// throw from parsetype
10140	10421	if(!stack[base + 6])
10141	10422	{
10142	10423	fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10143		- label = 785LLU; // skip, variable already deleted/unscoped
	10424	+ label = 821LLU; // skip, variable already deleted/unscoped
10144	10425	break;
10145	10426	}
10146	10427	fprintf(stderr, "in function parsetype: unrolling stack, variable u64 \n");
10147		- label = 785LLU; // continue unrolling stack, delete next variable
	10428	+ label = 821LLU; // continue unrolling stack, delete next variable
10148	10429	break;
10149	10430	}
10150		- case 787LLU: // skipped deleter
	10431	+ case 823LLU: // skipped deleter
10151	10432	{
10152	10433	stack[base + 6] = 0;
10153	10434	// call equ from parsetype
10154		- stack[base + 7LLU] = 788LLU/throw to this address/;
	10435	+ stack[base + 7LLU] = 824LLU/throw to this address/;
10155	10436	stack[base + 8LLU] = base;
10156		- stack[base + 9LLU] = 789LLU;
	10437	+ stack[base + 9LLU] = 825LLU;
10157	10438	// arguments for call to equ
10158	10439	stack[base + 11LLU] = stack[base + 3]/variant/;
10159	10440	stack[base + 12LLU] = 4LLU;

		@@ -10162,14 +10443,14 @@
10162	10443	label = 18446744073709551600LLU; // equ
10163	10444	break;
10164	10445	}
10165		- case 788LLU: // copy-back deleter (equ to parsetype)
	10446	+ case 824LLU: // copy-back deleter (equ to parsetype)
10166	10447	{
10167	10448	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
10168	10449	// copy mutable arguments back from call to equ
10169		- label = 786LLU; // continue to roll stack
	10450	+ label = 822LLU; // continue to roll stack
10170	10451	break;
10171	10452	}
10172		- case 789LLU: // return from equ to parsetype
	10453	+ case 825LLU: // return from equ to parsetype
10173	10454	{
10174	10455	// copy mutable arguments back from call to equ
10175	10456	// copy back results provided by call to equ

		@@ -10176,21 +10457,21 @@
10176	10457	stack[base + 6] = stack[base + 10LLU];
10177	10458	if(!stack[base + 6]/isequal/)
10178	10459	{
10179		- label = 790LLU; // jump to alternative
	10460	+ label = 826LLU; // jump to alternative
10180	10461	break;
10181	10462	}
10182	10463
10183	10464	// consequent
10184		- label = 793LLU; // skip deleter
	10465	+ label = 829LLU; // skip deleter
10185	10466	break;
10186	10467	}
10187		- case 792LLU: // deleter
	10468	+ case 828LLU: // deleter
10188	10469	{
10189	10470	// throw from parsetype
10190	10471	if(!stack[base + 0])
10191	10472	{
10192	10473	fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable type \n");
10193		- label = 786LLU; // skip, variable already deleted/unscoped
	10474	+ label = 822LLU; // skip, variable already deleted/unscoped
10194	10475	break;
10195	10476	}
10196	10477	fprintf(stderr, "in function parsetype: unrolling stack, variable type \n");

		@@ -10200,7 +10481,7 @@
10200	10481	newstack[0] = (uint64_t)stack; // backup stack location
10201	10482	newstack[1] = 1234567890;
10202	10483	newstack[2] = base;
10203		- newstack[3] = 794LLU;
	10484	+ newstack[3] = 830LLU;
10204	10485	stack = newstack;
10205	10486	// set stack-base & callee-address
10206	10487	base = 4/deloffset/;

		@@ -10207,21 +10488,21 @@
10207	10488	label = 295LLU; // ~type
10208	10489	break;
10209	10490	}
10210		- case 794LLU: // return from ~type to parsetype
	10491	+ case 830LLU: // return from ~type to parsetype
10211	10492	{
10212	10493	stack = (uint64_t *)stack[0];
10213	10494	// releasing toplevel container
10214	10495	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
10215	10496
10216		- label = 786LLU; // continue unrolling stack, delete next variable
	10497	+ label = 822LLU; // continue unrolling stack, delete next variable
10217	10498	break;
10218	10499	}
10219		- case 793LLU: // skipped deleter
	10500	+ case 829LLU: // skipped deleter
10220	10501	{
10221	10502	// construct type.typename
10222	10503	if(!(stack[base + 0] = construct(1)))
10223	10504	{
10224		- label = 786LLU; // throw: begin to unroll stack
	10505	+ label = 822LLU; // throw: begin to unroll stack
10225	10506	break;
10226	10507	}
10227	10508

		@@ -10228,34 +10509,34 @@
10228	10509	// consequent
10229	10510	((uint64_t *)stack[base + 0])[0] = 0;
10230	10511	(((uint64_t *)(stack[base + 0]))[1][0]) = stack[base + 4]/content*/;
10231		- label = 796LLU; // skip deleter
	10512	+ label = 832LLU; // skip deleter
10232	10513	break;
10233	10514	}
10234		- case 795LLU: // deleter
	10515	+ case 831LLU: // deleter
10235	10516	{
10236	10517	// throw from parsetype
10237	10518	if(!stack[base + 1])
10238	10519	{
10239	10520	fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10240		- label = 792LLU; // skip, variable already deleted/unscoped
	10521	+ label = 828LLU; // skip, variable already deleted/unscoped
10241	10522	break;
10242	10523	}
10243	10524	fprintf(stderr, "in function parsetype: unrolling stack, variable u64 \n");
10244		- label = 792LLU; // continue unrolling stack, delete next variable
	10525	+ label = 828LLU; // continue unrolling stack, delete next variable
10245	10526	break;
10246	10527	}
10247		- case 796LLU: // skipped deleter
	10528	+ case 832LLU: // skipped deleter
10248	10529	{
10249	10530	stack[base + 1] = stack[base + 5]/lookahead/;
10250		- label = 791LLU; // consequent complete
	10531	+ label = 827LLU; // consequent complete
10251	10532	break;
10252	10533	}
10253		- case 790LLU: // alternative
	10534	+ case 826LLU: // alternative
10254	10535	{
10255	10536	// call equ from parsetype
10256		- stack[base + 7LLU] = 797LLU/throw to this address/;
	10537	+ stack[base + 7LLU] = 833LLU/throw to this address/;
10257	10538	stack[base + 8LLU] = base;
10258		- stack[base + 9LLU] = 798LLU;
	10539	+ stack[base + 9LLU] = 834LLU;
10259	10540	// arguments for call to equ
10260	10541	stack[base + 11LLU] = stack[base + 3]/variant/;
10261	10542	stack[base + 12LLU] = 0LLU;

		@@ -10264,14 +10545,14 @@
10264	10545	label = 18446744073709551600LLU; // equ
10265	10546	break;
10266	10547	}
10267		- case 797LLU: // copy-back deleter (equ to parsetype)
	10548	+ case 833LLU: // copy-back deleter (equ to parsetype)
10268	10549	{
10269	10550	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
10270	10551	// copy mutable arguments back from call to equ
10271		- label = 786LLU; // continue to roll stack
	10552	+ label = 822LLU; // continue to roll stack
10272	10553	break;
10273	10554	}
10274		- case 798LLU: // return from equ to parsetype
	10555	+ case 834LLU: // return from equ to parsetype
10275	10556	{
10276	10557	// copy mutable arguments back from call to equ
10277	10558	// copy back results provided by call to equ

		@@ -10278,15 +10559,15 @@
10278	10559	stack[base + 6] = stack[base + 10LLU];
10279	10560	if(!stack[base + 6]/isequal/)
10280	10561	{
10281		- label = 799LLU; // jump to alternative
	10562	+ label = 835LLU; // jump to alternative
10282	10563	break;
10283	10564	}
10284	10565
10285	10566	// consequent
10286	10567	// call equ from parsetype
10287		- stack[base + 7LLU] = 801LLU/throw to this address/;
	10568	+ stack[base + 7LLU] = 837LLU/throw to this address/;
10288	10569	stack[base + 8LLU] = base;
10289		- stack[base + 9LLU] = 802LLU;
	10570	+ stack[base + 9LLU] = 838LLU;
10290	10571	// arguments for call to equ
10291	10572	stack[base + 11LLU] = stack[base + 4]/content/;
10292	10573	stack[base + 12LLU] = 91LLU;

		@@ -10295,14 +10576,14 @@
10295	10576	label = 18446744073709551600LLU; // equ
10296	10577	break;
10297	10578	}
10298		- case 801LLU: // copy-back deleter (equ to parsetype)
	10579	+ case 837LLU: // copy-back deleter (equ to parsetype)
10299	10580	{
10300	10581	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
10301	10582	// copy mutable arguments back from call to equ
10302		- label = 786LLU; // continue to roll stack
	10583	+ label = 822LLU; // continue to roll stack
10303	10584	break;
10304	10585	}
10305		- case 802LLU: // return from equ to parsetype
	10586	+ case 838LLU: // return from equ to parsetype
10306	10587	{
10307	10588	// copy mutable arguments back from call to equ
10308	10589	// copy back results provided by call to equ

		@@ -10309,15 +10590,15 @@
10309	10590	stack[base + 6] = stack[base + 10LLU];
10310	10591	if(!stack[base + 6]/isequal/)
10311	10592	{
10312		- label = 803LLU; // jump to alternative
	10593	+ label = 839LLU; // jump to alternative
10313	10594	break;
10314	10595	}
10315	10596
10316	10597	// consequent
10317	10598	// call PARSETOKEN from parsetype
10318		- stack[base + 7LLU] = 805LLU/throw to this address/;
	10599	+ stack[base + 7LLU] = 841LLU/throw to this address/;
10319	10600	stack[base + 8LLU] = base;
10320		- stack[base + 9LLU] = 806LLU;
	10601	+ stack[base + 9LLU] = 842LLU;
10321	10602	// arguments for call to PARSETOKEN
10322	10603	stack[base + 12LLU] = stack[base + 5]/lookahead/;
10323	10604	// set stack-base & callee-address

		@@ -10325,14 +10606,14 @@
10325	10606	label = 18446744073709551584LLU; // PARSETOKEN
10326	10607	break;
10327	10608	}
10328		- case 805LLU: // copy-back deleter (PARSETOKEN to parsetype)
	10609	+ case 841LLU: // copy-back deleter (PARSETOKEN to parsetype)
10329	10610	{
10330	10611	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (PARSETOKEN to parsetype)\n");
10331	10612	// copy mutable arguments back from call to PARSETOKEN
10332		- label = 786LLU; // continue to roll stack
	10613	+ label = 822LLU; // continue to roll stack
10333	10614	break;
10334	10615	}
10335		- case 806LLU: // return from PARSETOKEN to parsetype
	10616	+ case 842LLU: // return from PARSETOKEN to parsetype
10336	10617	{
10337	10618	// copy mutable arguments back from call to PARSETOKEN
10338	10619	// copy back results provided by call to PARSETOKEN

		@@ -10341,7 +10622,7 @@
10341	10622	uint64_t newstack = (uint64_t )Calloc(35LLU + 1, sizeof(uint64_t));
10342	10623	if(!newstack)
10343	10624	{
10344		- label = 786LLU; // throw: begin to unroll stack
	10625	+ label = 822LLU; // throw: begin to unroll stack
10345	10626	break;
10346	10627	}
10347	10628

		@@ -10348,9 +10629,9 @@
10348	10629	newstack[35LLU] = 9876543210LLU; // overflow-marker
10349	10630	// call parsetype from parsetype
10350	10631	newstack[0] = (uint64_t)stack; // backup stack location
10351		- newstack[1] = 807LLU;
	10632	+ newstack[1] = 843LLU;
10352	10633	newstack[2] = base;
10353		- newstack[3] = 808LLU;
	10634	+ newstack[3] = 844LLU;
10354	10635	// arguments for call to parsetype
10355	10636	newstack[6LLU] = stack[base + 2]/fnid/;
10356	10637	newstack[7LLU] = stack[base + 3]/variant/;

		@@ -10359,10 +10640,10 @@
10359	10640	stack = newstack;
10360	10641	// set stack-base & callee-address
10361	10642	base = 4/deloffset/;
10362		- label = 784LLU; // parsetype
	10643	+ label = 820LLU; // parsetype
10363	10644	break;
10364	10645	}
10365		- case 807LLU: // copy-back deleter (parsetype to parsetype)
	10646	+ case 843LLU: // copy-back deleter (parsetype to parsetype)
10366	10647	{
10367	10648	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (parsetype to parsetype)\n");
10368	10649	uint64_t oldstack = (uint64_t )stack[0];

		@@ -10376,10 +10657,10 @@
10376	10657	}
10377	10658	Free(35LLU + 1, sizeof(uint64_t), stack);
10378	10659	stack = oldstack;
10379		- label = 786LLU; // continue to unroll stack
	10660	+ label = 822LLU; // continue to unroll stack
10380	10661	break;
10381	10662	}
10382		- case 808LLU: // return from parsetype to parsetype
	10663	+ case 844LLU: // return from parsetype to parsetype
10383	10664	{
10384	10665	uint64_t oldstack = (uint64_t )stack[0];
10385	10666	// copy mutable arguments back from call to parsetype

		@@ -10396,9 +10677,9 @@
10396	10677	Free(35LLU + 1, sizeof(uint64_t), stack);
10397	10678	stack = oldstack;
10398	10679	// call matchsym from parsetype
10399		- stack[base + 9LLU] = 809LLU/throw to this address/;
	10680	+ stack[base + 9LLU] = 845LLU/throw to this address/;
10400	10681	stack[base + 10LLU] = base;
10401		- stack[base + 11LLU] = 810LLU;
	10682	+ stack[base + 11LLU] = 846LLU;
10402	10683	// arguments for call to matchsym
10403	10684	stack[base + 12LLU] = stack[base + 2]/fnid/;
10404	10685	stack[base + 13LLU] = 93LLU;

		@@ -10408,28 +10689,28 @@
10408	10689	label = 211LLU; // matchsym
10409	10690	break;
10410	10691	}
10411		- case 809LLU: // copy-back deleter (matchsym to parsetype)
	10692	+ case 845LLU: // copy-back deleter (matchsym to parsetype)
10412	10693	{
10413	10694	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (matchsym to parsetype)\n");
10414	10695	// copy mutable arguments back from call to matchsym
10415	10696	stack[base + 8]/lookahead/ = stack[base + 14LLU];
10416		- label = 786LLU; // continue to roll stack
	10697	+ label = 822LLU; // continue to roll stack
10417	10698	break;
10418	10699	}
10419		- case 810LLU: // return from matchsym to parsetype
	10700	+ case 846LLU: // return from matchsym to parsetype
10420	10701	{
10421	10702	// copy mutable arguments back from call to matchsym
10422	10703	stack[base + 8]/lookahead/ = stack[base + 14LLU];
10423		- label = 812LLU; // skip deleter
	10704	+ label = 848LLU; // skip deleter
10424	10705	break;
10425	10706	}
10426		- case 811LLU: // deleter
	10707	+ case 847LLU: // deleter
10427	10708	{
10428	10709	// throw from parsetype
10429	10710	if(!stack[base + 0])
10430	10711	{
10431	10712	fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable type \n");
10432		- label = 786LLU; // skip, variable already deleted/unscoped
	10713	+ label = 822LLU; // skip, variable already deleted/unscoped
10433	10714	break;
10434	10715	}
10435	10716	fprintf(stderr, "in function parsetype: unrolling stack, variable type \n");

		@@ -10439,7 +10720,7 @@
10439	10720	newstack[0] = (uint64_t)stack; // backup stack location
10440	10721	newstack[1] = 1234567890;
10441	10722	newstack[2] = base;
10442		- newstack[3] = 813LLU;
	10723	+ newstack[3] = 849LLU;
10443	10724	stack = newstack;
10444	10725	// set stack-base & callee-address
10445	10726	base = 4/deloffset/;

		@@ -10446,21 +10727,21 @@
10446	10727	label = 295LLU; // ~type
10447	10728	break;
10448	10729	}
10449		- case 813LLU: // return from ~type to parsetype
	10730	+ case 849LLU: // return from ~type to parsetype
10450	10731	{
10451	10732	stack = (uint64_t *)stack[0];
10452	10733	// releasing toplevel container
10453	10734	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
10454	10735
10455		- label = 786LLU; // continue unrolling stack, delete next variable
	10736	+ label = 822LLU; // continue unrolling stack, delete next variable
10456	10737	break;
10457	10738	}
10458		- case 812LLU: // skipped deleter
	10739	+ case 848LLU: // skipped deleter
10459	10740	{
10460	10741	// construct type.typelist
10461	10742	if(!(stack[base + 0] = construct(1)))
10462	10743	{
10463		- label = 786LLU; // throw: begin to unroll stack
	10744	+ label = 822LLU; // throw: begin to unroll stack
10464	10745	break;
10465	10746	}
10466	10747

		@@ -10467,35 +10748,35 @@
10467	10748	// consequent
10468	10749	((uint64_t *)stack[base + 0])[0] = 1;
10469	10750	INIT(&(((uint64_t *)(stack[base + 0]))[1][0]), &stack[base + 7]/subtype*/);
10470		- label = 815LLU; // skip deleter
	10751	+ label = 851LLU; // skip deleter
10471	10752	break;
10472	10753	}
10473		- case 814LLU: // deleter
	10754	+ case 850LLU: // deleter
10474	10755	{
10475	10756	// throw from parsetype
10476	10757	if(!stack[base + 1])
10477	10758	{
10478	10759	fprintf(stderr, "in function parsetype: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10479		- label = 811LLU; // skip, variable already deleted/unscoped
	10760	+ label = 847LLU; // skip, variable already deleted/unscoped
10480	10761	break;
10481	10762	}
10482	10763	fprintf(stderr, "in function parsetype: unrolling stack, variable u64 \n");
10483		- label = 811LLU; // continue unrolling stack, delete next variable
	10764	+ label = 847LLU; // continue unrolling stack, delete next variable
10484	10765	break;
10485	10766	}
10486		- case 815LLU: // skipped deleter
	10767	+ case 851LLU: // skipped deleter
10487	10768	{
10488	10769	stack[base + 1] = stack[base + 8]/lookahead/;
10489		- label = 804LLU; // consequent complete
	10770	+ label = 840LLU; // consequent complete
10490	10771	break;
10491	10772	}
10492		- case 803LLU: // alternative
	10773	+ case 839LLU: // alternative
10493	10774	{
10494	10775	fprintf(stderr, "%s", "parsing type: expected '[' but found ");
10495	10776	// call reporttok from parsetype
10496		- stack[base + 7LLU] = 816LLU/throw to this address/;
	10777	+ stack[base + 7LLU] = 852LLU/throw to this address/;
10497	10778	stack[base + 8LLU] = base;
10498		- stack[base + 9LLU] = 817LLU;
	10779	+ stack[base + 9LLU] = 853LLU;
10499	10780	// arguments for call to reporttok
10500	10781	stack[base + 10LLU] = stack[base + 3]/variant/;
10501	10782	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -10504,33 +10785,33 @@
10504	10785	label = 18446744073709551582LLU; // reporttok
10505	10786	break;
10506	10787	}
10507		- case 816LLU: // copy-back deleter (reporttok to parsetype)
	10788	+ case 852LLU: // copy-back deleter (reporttok to parsetype)
10508	10789	{
10509	10790	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (reporttok to parsetype)\n");
10510	10791	// copy mutable arguments back from call to reporttok
10511		- label = 786LLU; // continue to roll stack
	10792	+ label = 822LLU; // continue to roll stack
10512	10793	break;
10513	10794	}
10514		- case 817LLU: // return from reporttok to parsetype
	10795	+ case 853LLU: // return from reporttok to parsetype
10515	10796	{
10516	10797	// copy mutable arguments back from call to reporttok
10517	10798	fprintf(stderr, "%s", "\n");
10518	10799	exit(-1);
10519		- label = 804LLU; // alternative complete
	10800	+ label = 840LLU; // alternative complete
10520	10801	break;
10521	10802	}
10522		- case 804LLU: // completed if-then-else
	10803	+ case 840LLU: // completed if-then-else
10523	10804	{
10524		- label = 800LLU; // consequent complete
	10805	+ label = 836LLU; // consequent complete
10525	10806	break;
10526	10807	}
10527		- case 799LLU: // alternative
	10808	+ case 835LLU: // alternative
10528	10809	{
10529	10810	fprintf(stderr, "%s", "parsing type: expected identifier but found ");
10530	10811	// call reporttok from parsetype
10531		- stack[base + 7LLU] = 818LLU/throw to this address/;
	10812	+ stack[base + 7LLU] = 854LLU/throw to this address/;
10532	10813	stack[base + 8LLU] = base;
10533		- stack[base + 9LLU] = 819LLU;
	10814	+ stack[base + 9LLU] = 855LLU;
10534	10815	// arguments for call to reporttok
10535	10816	stack[base + 10LLU] = stack[base + 3]/variant/;
10536	10817	stack[base + 11LLU] = stack[base + 4]/content/;

		@@ -10539,27 +10820,27 @@
10539	10820	label = 18446744073709551582LLU; // reporttok
10540	10821	break;
10541	10822	}
10542		- case 818LLU: // copy-back deleter (reporttok to parsetype)
	10823	+ case 854LLU: // copy-back deleter (reporttok to parsetype)
10543	10824	{
10544	10825	fprintf(stderr, "in function parsetype: unrolling stack, copy-back (reporttok to parsetype)\n");
10545	10826	// copy mutable arguments back from call to reporttok
10546		- label = 786LLU; // continue to roll stack
	10827	+ label = 822LLU; // continue to roll stack
10547	10828	break;
10548	10829	}
10549		- case 819LLU: // return from reporttok to parsetype
	10830	+ case 855LLU: // return from reporttok to parsetype
10550	10831	{
10551	10832	// copy mutable arguments back from call to reporttok
10552	10833	fprintf(stderr, "%s", "\n");
10553	10834	exit(-1);
10554		- label = 800LLU; // alternative complete
	10835	+ label = 836LLU; // alternative complete
10555	10836	break;
10556	10837	}
10557		- case 800LLU: // completed if-then-else
	10838	+ case 836LLU: // completed if-then-else
10558	10839	{
10559		- label = 791LLU; // alternative complete
	10840	+ label = 827LLU; // alternative complete
10560	10841	break;
10561	10842	}
10562		- case 791LLU: // completed if-then-else
	10843	+ case 827LLU: // completed if-then-else
10563	10844	{
10564	10845	// return from parsetype
10565	10846	label = stack[base - 1];

		@@ -10566,7 +10847,7 @@
10566	10847	base = stack[base - 2];
10567	10848	break;
10568	10849	}
10569		- case 821LLU: // function PARSETYPE failed
	10850	+ case 857LLU: // function PARSETYPE failed
10570	10851	{
10571	10852	fprintf(stderr, "function PARSETYPE failed\n");
10572	10853	label = stack[base - 3];

		@@ -10573,7 +10854,7 @@
10573	10854	base = stack[base - 2];
10574	10855	break;
10575	10856	}
10576		- case 820LLU: // PARSETYPE
	10857	+ case 856LLU: // PARSETYPE
10577	10858	{
10578	10859	//#define res0 0
10579	10860	//#define arg0 1

		@@ -10583,7 +10864,7 @@
10583	10864	uint64_t newstack = (uint64_t )Calloc(35LLU + 1, sizeof(uint64_t));
10584	10865	if(!newstack)
10585	10866	{
10586		- label = 821LLU; // throw: begin to unroll stack
	10867	+ label = 857LLU; // throw: begin to unroll stack
10587	10868	break;
10588	10869	}
10589	10870

		@@ -10590,9 +10871,9 @@
10590	10871	newstack[35LLU] = 9876543210LLU; // overflow-marker
10591	10872	// call parsetype from PARSETYPE
10592	10873	newstack[0] = (uint64_t)stack; // backup stack location
10593		- newstack[1] = 822LLU;
	10874	+ newstack[1] = 858LLU;
10594	10875	newstack[2] = base;
10595		- newstack[3] = 823LLU;
	10876	+ newstack[3] = 859LLU;
10596	10877	// arguments for call to parsetype
10597	10878	newstack[6LLU] = stack[base + 1]/fnid/;
10598	10879	newstack[7LLU] = stack[base + 2]/variant/;

		@@ -10601,10 +10882,10 @@
10601	10882	stack = newstack;
10602	10883	// set stack-base & callee-address
10603	10884	base = 4/deloffset/;
10604		- label = 784LLU; // parsetype
	10885	+ label = 820LLU; // parsetype
10605	10886	break;
10606	10887	}
10607		- case 822LLU: // copy-back deleter (parsetype to PARSETYPE)
	10888	+ case 858LLU: // copy-back deleter (parsetype to PARSETYPE)
10608	10889	{
10609	10890	fprintf(stderr, "in function PARSETYPE: unrolling stack, copy-back (parsetype to PARSETYPE)\n");
10610	10891	uint64_t oldstack = (uint64_t )stack[0];

		@@ -10618,10 +10899,10 @@
10618	10899	}
10619	10900	Free(35LLU + 1, sizeof(uint64_t), stack);
10620	10901	stack = oldstack;
10621		- label = 821LLU; // continue to unroll stack
	10902	+ label = 857LLU; // continue to unroll stack
10622	10903	break;
10623	10904	}
10624		- case 823LLU: // return from parsetype to PARSETYPE
	10905	+ case 859LLU: // return from parsetype to PARSETYPE
10625	10906	{
10626	10907	uint64_t oldstack = (uint64_t )stack[0];
10627	10908	// copy mutable arguments back from call to parsetype

		@@ -10638,16 +10919,16 @@
10638	10919	Free(35LLU + 1, sizeof(uint64_t), stack);
10639	10920	stack = oldstack;
10640	10921	stack[base + 4]/lookahead/ = stack[base + 6]/LOOKAHEAD/;
10641		- label = 825LLU; // skip deleter
	10922	+ label = 861LLU; // skip deleter
10642	10923	break;
10643	10924	}
10644		- case 824LLU: // deleter
	10925	+ case 860LLU: // deleter
10645	10926	{
10646	10927	// throw from PARSETYPE
10647	10928	if(!stack[base + 0])
10648	10929	{
10649	10930	fprintf(stderr, "in function PARSETYPE: unrolling stack, skipping already deleted/unscoped variable type \n");
10650		- label = 821LLU; // skip, variable already deleted/unscoped
	10931	+ label = 857LLU; // skip, variable already deleted/unscoped
10651	10932	break;
10652	10933	}
10653	10934	fprintf(stderr, "in function PARSETYPE: unrolling stack, variable type \n");

		@@ -10657,7 +10938,7 @@
10657	10938	newstack[0] = (uint64_t)stack; // backup stack location
10658	10939	newstack[1] = 1234567890;
10659	10940	newstack[2] = base;
10660		- newstack[3] = 826LLU;
	10941	+ newstack[3] = 862LLU;
10661	10942	stack = newstack;
10662	10943	// set stack-base & callee-address
10663	10944	base = 4/deloffset/;

		@@ -10664,16 +10945,16 @@
10664	10945	label = 295LLU; // ~type
10665	10946	break;
10666	10947	}
10667		- case 826LLU: // return from ~type to PARSETYPE
	10948	+ case 862LLU: // return from ~type to PARSETYPE
10668	10949	{
10669	10950	stack = (uint64_t *)stack[0];
10670	10951	// releasing toplevel container
10671	10952	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
10672	10953
10673		- label = 821LLU; // continue unrolling stack, delete next variable
	10954	+ label = 857LLU; // continue unrolling stack, delete next variable
10674	10955	break;
10675	10956	}
10676		- case 825LLU: // skipped deleter
	10957	+ case 861LLU: // skipped deleter
10677	10958	{
10678	10959	INIT(&stack[base + 0], &stack[base + 5]/type/);
10679	10960	// return from PARSETYPE

		@@ -10681,7 +10962,7 @@
10681	10962	base = stack[base - 2];
10682	10963	break;
10683	10964	}
10684		- case 827LLU: // ~variant
	10965	+ case 863LLU: // ~variant
10685	10966	{
10686	10967	if(stack[base + 0]/variant-nr/ >= 1)
10687	10968	{

		@@ -10688,23 +10969,23 @@
10688	10969	fprintf(stderr, "in ~variant: unknown variant-nr %d\n", (int)stack[base + 0]/variant-nr/);
10689	10970	exit(-1);
10690	10971	}
10691		- label = 827LLU + 1LLU + stack[base + 0]/variant-nr/;
	10972	+ label = 863LLU + 1LLU + stack[base + 0]/variant-nr/;
10692	10973	break;
10693	10974	}
10694		- case 827LLU + 1LLU + 0LLU: // ~variant.variant
	10975	+ case 863LLU + 1LLU + 0LLU: // ~variant.variant
10695	10976	{
10696	10977	// release element id
10697	10978	// release element elements
10698	10979	stack[base + 0] = ((uint64_t )stack[base + 1]/variant-nr/)[1/element-nr*/];
10699	10980	// delete list
10700		- label = 829LLU; // start to repeat
	10981	+ label = 865LLU; // start to repeat
10701	10982	break;
10702	10983	}
10703		- case 829LLU: // repeat from here
	10984	+ case 865LLU: // repeat from here
10704	10985	{
10705	10986	if(!stack[base + 0])
10706	10987	{
10707		- label = 830LLU; // break loop
	10988	+ label = 866LLU; // break loop
10708	10989	break;
10709	10990	}
10710	10991

		@@ -10715,14 +10996,14 @@
10715	10996	newstack[0] = (uint64_t)stack; // backup stack location
10716	10997	newstack[1] = 1234567890;
10717	10998	newstack[2] = base;
10718		- newstack[3] = 831LLU;
	10999	+ newstack[3] = 867LLU;
10719	11000	stack = newstack;
10720	11001	// set stack-base & callee-address
10721	11002	base = 4/deloffset/;
10722		- label = 346LLU; // ~typeid
	11003	+ label = 354LLU; // ~typeid
10723	11004	break;
10724	11005	}
10725		- case 831LLU: // return from ~typeid to variant
	11006	+ case 867LLU: // return from ~typeid to variant
10726	11007	{
10727	11008	stack = (uint64_t *)stack[0];
10728	11009	// releasing toplevel container

		@@ -10733,10 +11014,10 @@
10733	11014	stack[base + 0] = (uint64_t)list->next;
10734	11015	Free(1, sizeof(struct listnode), list);
10735	11016	}
10736		- label = 829LLU; // repeat
	11017	+ label = 865LLU; // repeat
10737	11018	break;
10738	11019	}
10739		- case 830LLU: // loop finished
	11020	+ case 866LLU: // loop finished
10740	11021	{
10741	11022	// release variant container
10742	11023	Free(2, sizeof(uint64_t), ((uint64_t )stack[base + 1]/variant*/));

		@@ -10744,7 +11025,7 @@
10744	11025	base = stack[base - 2];
10745	11026	break;
10746	11027	}
10747		- case 833LLU: // function mkvariantd failed
	11028	+ case 869LLU: // function mkvariantd failed
10748	11029	{
10749	11030	fprintf(stderr, "function mkvariantd failed\n");
10750	11031	label = stack[base - 3];

		@@ -10751,50 +11032,50 @@
10751	11032	base = stack[base - 2];
10752	11033	break;
10753	11034	}
10754		- case 832LLU: // mkvariantd
	11035	+ case 868LLU: // mkvariantd
10755	11036	{
10756	11037	//#define res0 0
10757		- label = 835LLU; // skip deleter
	11038	+ label = 871LLU; // skip deleter
10758	11039	break;
10759	11040	}
10760		- case 834LLU: // deleter
	11041	+ case 870LLU: // deleter
10761	11042	{
10762	11043	// throw from mkvariantd
10763	11044	if(!stack[base + 1])
10764	11045	{
10765	11046	fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10766		- label = 833LLU; // skip, variable already deleted/unscoped
	11047	+ label = 869LLU; // skip, variable already deleted/unscoped
10767	11048	break;
10768	11049	}
10769	11050	fprintf(stderr, "in function mkvariantd: unrolling stack, variable u64 \n");
10770		- label = 833LLU; // continue unrolling stack, delete next variable
	11051	+ label = 869LLU; // continue unrolling stack, delete next variable
10771	11052	break;
10772	11053	}
10773		- case 835LLU: // skipped deleter
	11054	+ case 871LLU: // skipped deleter
10774	11055	{
10775	11056	stack[base + 1] = 0;
10776		- label = 837LLU; // skip deleter
	11057	+ label = 873LLU; // skip deleter
10777	11058	break;
10778	11059	}
10779		- case 836LLU: // deleter
	11060	+ case 872LLU: // deleter
10780	11061	{
10781	11062	// throw from mkvariantd
10782	11063	if(!stack[base + 2])
10783	11064	{
10784	11065	fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable [typeid] \n");
10785		- label = 834LLU; // skip, variable already deleted/unscoped
	11066	+ label = 870LLU; // skip, variable already deleted/unscoped
10786	11067	break;
10787	11068	}
10788	11069	fprintf(stderr, "in function mkvariantd: unrolling stack, variable [typeid] \n");
10789	11070	// delete list
10790		- label = 838LLU; // start to repeat
	11071	+ label = 874LLU; // start to repeat
10791	11072	break;
10792	11073	}
10793		- case 838LLU: // repeat from here
	11074	+ case 874LLU: // repeat from here
10794	11075	{
10795	11076	if(!stack[base + 2])
10796	11077	{
10797		- label = 839LLU; // break loop
	11078	+ label = 875LLU; // break loop
10798	11079	break;
10799	11080	}
10800	11081

		@@ -10805,14 +11086,14 @@
10805	11086	newstack[0] = (uint64_t)stack; // backup stack location
10806	11087	newstack[1] = 1234567890;
10807	11088	newstack[2] = base;
10808		- newstack[3] = 840LLU;
	11089	+ newstack[3] = 876LLU;
10809	11090	stack = newstack;
10810	11091	// set stack-base & callee-address
10811	11092	base = 4/deloffset/;
10812		- label = 346LLU; // ~typeid
	11093	+ label = 354LLU; // ~typeid
10813	11094	break;
10814	11095	}
10815		- case 840LLU: // return from ~typeid to mkvariantd
	11096	+ case 876LLU: // return from ~typeid to mkvariantd
10816	11097	{
10817	11098	stack = (uint64_t *)stack[0];
10818	11099	// releasing toplevel container

		@@ -10823,27 +11104,27 @@
10823	11104	stack[base + 2] = (uint64_t)list->next;
10824	11105	Free(1, sizeof(struct listnode), list);
10825	11106	}
10826		- label = 838LLU; // repeat
	11107	+ label = 874LLU; // repeat
10827	11108	break;
10828	11109	}
10829		- case 839LLU: // loop finished
	11110	+ case 875LLU: // loop finished
10830	11111	{
10831		- label = 834LLU; // continue unrolling stack, delete next variable
	11112	+ label = 870LLU; // continue unrolling stack, delete next variable
10832	11113	break;
10833	11114	}
10834		- case 837LLU: // skipped deleter
	11115	+ case 873LLU: // skipped deleter
10835	11116	{
10836	11117	stack[base + 2] = 0;
10837		- label = 842LLU; // skip deleter
	11118	+ label = 878LLU; // skip deleter
10838	11119	break;
10839	11120	}
10840		- case 841LLU: // deleter
	11121	+ case 877LLU: // deleter
10841	11122	{
10842	11123	// throw from mkvariantd
10843	11124	if(!stack[base + 0])
10844	11125	{
10845	11126	fprintf(stderr, "in function mkvariantd: unrolling stack, skipping already deleted/unscoped variable variant \n");
10846		- label = 836LLU; // skip, variable already deleted/unscoped
	11127	+ label = 872LLU; // skip, variable already deleted/unscoped
10847	11128	break;
10848	11129	}
10849	11130	fprintf(stderr, "in function mkvariantd: unrolling stack, variable variant \n");

		@@ -10853,28 +11134,28 @@
10853	11134	newstack[0] = (uint64_t)stack; // backup stack location
10854	11135	newstack[1] = 1234567890;
10855	11136	newstack[2] = base;
10856		- newstack[3] = 843LLU;
	11137	+ newstack[3] = 879LLU;
10857	11138	stack = newstack;
10858	11139	// set stack-base & callee-address
10859	11140	base = 4/deloffset/;
10860		- label = 827LLU; // ~variant
	11141	+ label = 863LLU; // ~variant
10861	11142	break;
10862	11143	}
10863		- case 843LLU: // return from ~variant to mkvariantd
	11144	+ case 879LLU: // return from ~variant to mkvariantd
10864	11145	{
10865	11146	stack = (uint64_t *)stack[0];
10866	11147	// releasing toplevel container
10867	11148	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
10868	11149
10869		- label = 836LLU; // continue unrolling stack, delete next variable
	11150	+ label = 872LLU; // continue unrolling stack, delete next variable
10870	11151	break;
10871	11152	}
10872		- case 842LLU: // skipped deleter
	11153	+ case 878LLU: // skipped deleter
10873	11154	{
10874	11155	// construct variant.variant
10875	11156	if(!(stack[base + 0] = construct(2)))
10876	11157	{
10877		- label = 836LLU; // throw: begin to unroll stack
	11158	+ label = 872LLU; // throw: begin to unroll stack
10878	11159	break;
10879	11160	}
10880	11161

		@@ -10887,7 +11168,7 @@
10887	11168	base = stack[base - 2];
10888	11169	break;
10889	11170	}
10890		- case 845LLU: // function cpvariant failed
	11171	+ case 881LLU: // function cpvariant failed
10891	11172	{
10892	11173	fprintf(stderr, "function cpvariant failed\n");
10893	11174	label = stack[base - 3];

		@@ -10894,13 +11175,13 @@
10894	11175	base = stack[base - 2];
10895	11176	break;
10896	11177	}
10897		- case 844LLU: // cpvariant
	11178	+ case 880LLU: // cpvariant
10898	11179	{
10899	11180	//#define res0 0
10900	11181	//#define arg0 1
10901	11182	if(/variant/0 != ((uint64_t )(stack[base + 1]/original*/))[0])
10902	11183	{
10903		- label = 847LLU; // jump to alternative
	11184	+ label = 883LLU; // jump to alternative
10904	11185	break;
10905	11186	}
10906	11187

		@@ -10908,47 +11189,47 @@
10908	11189	/oelements/stack[base + 3] = ((uint64_t *)(stack[base + 1]/original/))[1][1]/elements*/;
10909	11190
10910	11191	// case
10911		- label = 849LLU; // skip deleter
	11192	+ label = 886LLU; // skip deleter
10912	11193	break;
10913	11194	}
10914		- case 848LLU: // deleter
	11195	+ case 885LLU: // deleter
10915	11196	{
10916	11197	// throw from cpvariant
10917	11198	if(!stack[base + 4])
10918	11199	{
10919	11200	fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable u64 \n");
10920		- label = 845LLU; // skip, variable already deleted/unscoped
	11201	+ label = 884LLU; // skip, variable already deleted/unscoped
10921	11202	break;
10922	11203	}
10923	11204	fprintf(stderr, "in function cpvariant: unrolling stack, variable u64 \n");
10924		- label = 845LLU; // continue unrolling stack, delete next variable
	11205	+ label = 884LLU; // continue unrolling stack, delete next variable
10925	11206	break;
10926	11207	}
10927		- case 849LLU: // skipped deleter
	11208	+ case 886LLU: // skipped deleter
10928	11209	{
10929	11210	stack[base + 4] = stack[base + 2]/oid/;
10930		- label = 851LLU; // skip deleter
	11211	+ label = 888LLU; // skip deleter
10931	11212	break;
10932	11213	}
10933		- case 850LLU: // deleter
	11214	+ case 887LLU: // deleter
10934	11215	{
10935	11216	// throw from cpvariant
10936	11217	if(!stack[base + 5])
10937	11218	{
10938	11219	fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable [typeid] \n");
10939		- label = 848LLU; // skip, variable already deleted/unscoped
	11220	+ label = 885LLU; // skip, variable already deleted/unscoped
10940	11221	break;
10941	11222	}
10942	11223	fprintf(stderr, "in function cpvariant: unrolling stack, variable [typeid] \n");
10943	11224	// delete list
10944		- label = 852LLU; // start to repeat
	11225	+ label = 889LLU; // start to repeat
10945	11226	break;
10946	11227	}
10947		- case 852LLU: // repeat from here
	11228	+ case 889LLU: // repeat from here
10948	11229	{
10949	11230	if(!stack[base + 5])
10950	11231	{
10951		- label = 853LLU; // break loop
	11232	+ label = 890LLU; // break loop
10952	11233	break;
10953	11234	}
10954	11235

		@@ -10959,14 +11240,14 @@
10959	11240	newstack[0] = (uint64_t)stack; // backup stack location
10960	11241	newstack[1] = 1234567890;
10961	11242	newstack[2] = base;
10962		- newstack[3] = 854LLU;
	11243	+ newstack[3] = 891LLU;
10963	11244	stack = newstack;
10964	11245	// set stack-base & callee-address
10965	11246	base = 4/deloffset/;
10966		- label = 346LLU; // ~typeid
	11247	+ label = 354LLU; // ~typeid
10967	11248	break;
10968	11249	}
10969		- case 854LLU: // return from ~typeid to cpvariant
	11250	+ case 891LLU: // return from ~typeid to cpvariant
10970	11251	{
10971	11252	stack = (uint64_t *)stack[0];
10972	11253	// releasing toplevel container

		@@ -10977,26 +11258,26 @@
10977	11258	stack[base + 5] = (uint64_t)list->next;
10978	11259	Free(1, sizeof(struct listnode), list);
10979	11260	}
10980		- label = 852LLU; // repeat
	11261	+ label = 889LLU; // repeat
10981	11262	break;
10982	11263	}
10983		- case 853LLU: // loop finished
	11264	+ case 890LLU: // loop finished
10984	11265	{
10985		- label = 848LLU; // continue unrolling stack, delete next variable
	11266	+ label = 885LLU; // continue unrolling stack, delete next variable
10986	11267	break;
10987	11268	}
10988		- case 851LLU: // skipped deleter
	11269	+ case 888LLU: // skipped deleter
10989	11270	{
10990	11271	stack[base + 5] = 0;
10991	11272	flippedassign(stack[base + 3]/oelements/, &stack[base + 6]);
10992		- label = 855LLU; // start to repeat
	11273	+ label = 892LLU; // start to repeat
10993	11274	break;
10994	11275	}
10995		- case 855LLU: // repeat from here
	11276	+ case 892LLU: // repeat from here
10996	11277	{
10997	11278	if(!stack[base + 6])
10998	11279	{
10999		- label = 856LLU; // break loop
	11280	+ label = 893LLU; // break loop
11000	11281	break;
11001	11282	}
11002	11283

		@@ -11005,24 +11286,24 @@
11005	11286	stack[base + 8]/previous/ = stack[base + 6];
11006	11287	stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
11007	11288	// call copytypeid from cpvariant
11008		- stack[base + 10LLU] = 857LLU/throw to this address/;
	11289	+ stack[base + 10LLU] = 894LLU/throw to this address/;
11009	11290	stack[base + 11LLU] = base;
11010		- stack[base + 12LLU] = 858LLU;
	11291	+ stack[base + 12LLU] = 895LLU;
11011	11292	// arguments for call to copytypeid
11012	11293	stack[base + 14LLU] = stack[base + 7]/oelement/;
11013	11294	// set stack-base & callee-address
11014	11295	base += 13LLU;
11015		- label = 349LLU; // copytypeid
	11296	+ label = 357LLU; // copytypeid
11016	11297	break;
11017	11298	}
11018		- case 857LLU: // copy-back deleter (copytypeid to cpvariant)
	11299	+ case 894LLU: // copy-back deleter (copytypeid to cpvariant)
11019	11300	{
11020	11301	fprintf(stderr, "in function cpvariant: unrolling stack, copy-back (copytypeid to cpvariant)\n");
11021	11302	// copy mutable arguments back from call to copytypeid
11022		- label = 850LLU; // continue to roll stack
	11303	+ label = 887LLU; // continue to roll stack
11023	11304	break;
11024	11305	}
11025		- case 858LLU: // return from copytypeid to cpvariant
	11306	+ case 895LLU: // return from copytypeid to cpvariant
11026	11307	{
11027	11308	// copy mutable arguments back from call to copytypeid
11028	11309	// copy back results provided by call to copytypeid

		@@ -11039,22 +11320,22 @@
11039	11320	MOVE(&list->data, &stack[base + 9]/celement/);
11040	11321	}
11041	11322	((struct listnode )(stack[base + 8]/previous*/))->data = stack[base + 7];
11042		- label = 855LLU; // repeat
	11323	+ label = 892LLU; // repeat
11043	11324	break;
11044	11325	}
11045		- case 856LLU: // loop finished
	11326	+ case 893LLU: // loop finished
11046	11327	{
11047	11328	list_reverse(((struct listnode *)(&stack[base + 5]/celements*/)));
11048		- label = 860LLU; // skip deleter
	11329	+ label = 897LLU; // skip deleter
11049	11330	break;
11050	11331	}
11051		- case 859LLU: // deleter
	11332	+ case 896LLU: // deleter
11052	11333	{
11053	11334	// throw from cpvariant
11054	11335	if(!stack[base + 0])
11055	11336	{
11056	11337	fprintf(stderr, "in function cpvariant: unrolling stack, skipping already deleted/unscoped variable variant \n");
11057		- label = 850LLU; // skip, variable already deleted/unscoped
	11338	+ label = 887LLU; // skip, variable already deleted/unscoped
11058	11339	break;
11059	11340	}
11060	11341	fprintf(stderr, "in function cpvariant: unrolling stack, variable variant \n");

		@@ -11064,28 +11345,28 @@
11064	11345	newstack[0] = (uint64_t)stack; // backup stack location
11065	11346	newstack[1] = 1234567890;
11066	11347	newstack[2] = base;
11067		- newstack[3] = 861LLU;
	11348	+ newstack[3] = 898LLU;
11068	11349	stack = newstack;
11069	11350	// set stack-base & callee-address
11070	11351	base = 4/deloffset/;
11071		- label = 827LLU; // ~variant
	11352	+ label = 863LLU; // ~variant
11072	11353	break;
11073	11354	}
11074		- case 861LLU: // return from ~variant to cpvariant
	11355	+ case 898LLU: // return from ~variant to cpvariant
11075	11356	{
11076	11357	stack = (uint64_t *)stack[0];
11077	11358	// releasing toplevel container
11078	11359	Free(2 + 4, sizeof(uint64_t), (uint64_t )(stack[base + 0] - sizeof(uint64_t) 4));
11079	11360
11080		- label = 850LLU; // continue unrolling stack, delete next variable
	11361	+ label = 887LLU; // continue unrolling stack, delete next variable
11081	11362	break;
11082	11363	}
11083		- case 860LLU: // skipped deleter
	11364	+ case 897LLU: // skipped deleter
11084	11365	{
11085	11366	// construct variant.variant
11086	11367	if(!(stack[base + 0] = construct(2)))
11087	11368	{
11088		- label = 850LLU; // throw: begin to unroll stack
	11369	+ label = 887LLU; // throw: begin to unroll stack
11089	11370	break;
11090	11371	}
11091	11372

		@@ -11095,15 +11376,22 @@
11095	11376	INIT(&(((uint64_t *)(stack[base + 0]))[1][1]), &stack[base + 5]/celements*/);
11096	11377	((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
11097	11378	((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
11098		- label = 846LLU; // case complete
	11379	+ label = 882LLU; // case complete
11099	11380	break;
11100	11381	}
11101		- case 847LLU: // try next case
	11382	+ case 884LLU: // copy-back deleter (switch)
11102	11383	{
	11384	+ ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
	11385	+ ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
	11386	+ label = 881LLU; // continue to unroll stack
	11387	+ break;
	11388	+ }
	11389	+ case 883LLU: // try next case
	11390	+ {
11103	11391	fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
11104	11392	exit(-1);
11105	11393	}
11106		- case 846LLU: // completed switch
	11394	+ case 882LLU: // completed switch
11107	11395	{
11108	11396	// return from cpvariant
11109	11397	label = stack[base - 1];

		@@ -11110,7 +11398,7 @@
11110	11398	base = stack[base - 2];
11111	11399	break;
11112	11400	}
11113		- case 863LLU: // function GetVariant failed
	11401	+ case 900LLU: // function GetVariant failed
11114	11402	{
11115	11403	fprintf(stderr, "function GetVariant failed\n");
11116	11