• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revisión1167 (tree)
Tiempo2021-02-24 03:51:26
Autorjakobthomsen

Log Message

fix copy-back on exception in switch

Cambiar Resumen

Diferencia incremental

--- trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1166)
+++ trunk/jpl_compiler_pragmatic/compiler.compiled.c (revision 1167)
@@ -4232,9 +4232,9 @@
42324232
42334233 // case
42344234 // call printid from printtype
4235- stack[base + 2LLU] = 308LLU/*throw to this address*/;
4235+ stack[base + 2LLU] = 309LLU/*throw to this address*/;
42364236 stack[base + 3LLU] = base;
4237- stack[base + 4LLU] = 309LLU;
4237+ stack[base + 4LLU] = 310LLU;
42384238 // arguments for call to printid
42394239 stack[base + 5LLU] = stack[base + 1]/*name*/;
42404240 // set stack-base & callee-address
@@ -4242,14 +4242,14 @@
42424242 label = 18446744073709551587LLU; // printid
42434243 break;
42444244 }
4245- case 308LLU: // copy-back deleter (printid to printtype)
4245+ case 309LLU: // copy-back deleter (printid to printtype)
42464246 {
42474247 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printid to printtype)\n");
42484248 // copy mutable arguments back from call to printid
4249- label = 305LLU; // continue to roll stack
4249+ label = 308LLU; // continue to roll stack
42504250 break;
42514251 }
4252- case 309LLU: // return from printid to printtype
4252+ case 310LLU: // return from printid to printtype
42534253 {
42544254 // copy mutable arguments back from call to printid
42554255 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
@@ -4256,11 +4256,17 @@
42564256 label = 306LLU; // case complete
42574257 break;
42584258 }
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+ }
42594265 case 307LLU: // try next case
42604266 {
42614267 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
42624268 {
4263- label = 310LLU; // jump to alternative
4269+ label = 311LLU; // jump to alternative
42644270 break;
42654271 }
42664272
@@ -4271,7 +4277,7 @@
42714277 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
42724278 if(!newstack)
42734279 {
4274- label = 305LLU; // throw: begin to unroll stack
4280+ label = 312LLU; // throw: begin to unroll stack
42754281 break;
42764282 }
42774283
@@ -4278,9 +4284,9 @@
42784284 newstack[10LLU] = 9876543210LLU; // overflow-marker
42794285 // call printtype from printtype
42804286 newstack[0] = (uint64_t)stack; // backup stack location
4281- newstack[1] = 311LLU;
4287+ newstack[1] = 313LLU;
42824288 newstack[2] = base;
4283- newstack[3] = 312LLU;
4289+ newstack[3] = 314LLU;
42844290 // arguments for call to printtype
42854291 newstack[4LLU] = stack[base + 1]/*subtype*/;
42864292 stack = newstack;
@@ -4289,7 +4295,7 @@
42894295 label = 304LLU; // printtype
42904296 break;
42914297 }
4292- case 311LLU: // copy-back deleter (printtype to printtype)
4298+ case 313LLU: // copy-back deleter (printtype to printtype)
42934299 {
42944300 fprintf(stderr, "in function printtype: unrolling stack, copy-back (printtype to printtype)\n");
42954301 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4301,10 +4307,10 @@
43014307 }
43024308 Free(10LLU + 1, sizeof(uint64_t), stack);
43034309 stack = oldstack;
4304- label = 305LLU; // continue to unroll stack
4310+ label = 312LLU; // continue to unroll stack
43054311 break;
43064312 }
4307- case 312LLU: // return from printtype to printtype
4313+ case 314LLU: // return from printtype to printtype
43084314 {
43094315 uint64_t *oldstack = (uint64_t *)stack[0];
43104316 // copy mutable arguments back from call to printtype
@@ -4320,8 +4326,14 @@
43204326 label = 306LLU; // case complete
43214327 break;
43224328 }
4323- case 310LLU: // try next case
4329+ case 312LLU: // copy-back deleter (switch)
43244330 {
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+ {
43254337 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
43264338 exit(-1);
43274339 }
@@ -4332,7 +4344,7 @@
43324344 base = stack[base - 2];
43334345 break;
43344346 }
4335- case 314LLU: // function reporttype failed
4347+ case 316LLU: // function reporttype failed
43364348 {
43374349 fprintf(stderr, "function reporttype failed\n");
43384350 label = stack[base - 3];
@@ -4339,12 +4351,12 @@
43394351 base = stack[base - 2];
43404352 break;
43414353 }
4342- case 313LLU: // reporttype
4354+ case 315LLU: // reporttype
43434355 {
43444356 //#define arg0 0
43454357 if(/*typename*/0 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
43464358 {
4347- label = 316LLU; // jump to alternative
4359+ label = 318LLU; // jump to alternative
43484360 break;
43494361 }
43504362
@@ -4352,9 +4364,9 @@
43524364
43534365 // case
43544366 // call reportid from reporttype
4355- stack[base + 2LLU] = 317LLU/*throw to this address*/;
4367+ stack[base + 2LLU] = 320LLU/*throw to this address*/;
43564368 stack[base + 3LLU] = base;
4357- stack[base + 4LLU] = 318LLU;
4369+ stack[base + 4LLU] = 321LLU;
43584370 // arguments for call to reportid
43594371 stack[base + 5LLU] = stack[base + 1]/*name*/;
43604372 // set stack-base & callee-address
@@ -4362,25 +4374,31 @@
43624374 label = 18446744073709551586LLU; // reportid
43634375 break;
43644376 }
4365- case 317LLU: // copy-back deleter (reportid to reporttype)
4377+ case 320LLU: // copy-back deleter (reportid to reporttype)
43664378 {
43674379 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reportid to reporttype)\n");
43684380 // copy mutable arguments back from call to reportid
4369- label = 314LLU; // continue to roll stack
4381+ label = 319LLU; // continue to roll stack
43704382 break;
43714383 }
4372- case 318LLU: // return from reportid to reporttype
4384+ case 321LLU: // return from reportid to reporttype
43734385 {
43744386 // copy mutable arguments back from call to reportid
43754387 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4376- label = 315LLU; // case complete
4388+ label = 317LLU; // case complete
43774389 break;
43784390 }
4379- case 316LLU: // try next case
4391+ case 319LLU: // copy-back deleter (switch)
43804392 {
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+ {
43814399 if(/*typelist*/1 != ((uint64_t *)(stack[base + 0]/*type*/))[0])
43824400 {
4383- label = 319LLU; // jump to alternative
4401+ label = 322LLU; // jump to alternative
43844402 break;
43854403 }
43864404
@@ -4391,7 +4409,7 @@
43914409 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
43924410 if(!newstack)
43934411 {
4394- label = 314LLU; // throw: begin to unroll stack
4412+ label = 323LLU; // throw: begin to unroll stack
43954413 break;
43964414 }
43974415
@@ -4398,18 +4416,18 @@
43984416 newstack[10LLU] = 9876543210LLU; // overflow-marker
43994417 // call reporttype from reporttype
44004418 newstack[0] = (uint64_t)stack; // backup stack location
4401- newstack[1] = 320LLU;
4419+ newstack[1] = 324LLU;
44024420 newstack[2] = base;
4403- newstack[3] = 321LLU;
4421+ newstack[3] = 325LLU;
44044422 // arguments for call to reporttype
44054423 newstack[4LLU] = stack[base + 1]/*subtype*/;
44064424 stack = newstack;
44074425 // set stack-base & callee-address
44084426 base = 4/*deloffset*/;
4409- label = 313LLU; // reporttype
4427+ label = 315LLU; // reporttype
44104428 break;
44114429 }
4412- case 320LLU: // copy-back deleter (reporttype to reporttype)
4430+ case 324LLU: // copy-back deleter (reporttype to reporttype)
44134431 {
44144432 fprintf(stderr, "in function reporttype: unrolling stack, copy-back (reporttype to reporttype)\n");
44154433 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4421,10 +4439,10 @@
44214439 }
44224440 Free(10LLU + 1, sizeof(uint64_t), stack);
44234441 stack = oldstack;
4424- label = 314LLU; // continue to unroll stack
4442+ label = 323LLU; // continue to unroll stack
44254443 break;
44264444 }
4427- case 321LLU: // return from reporttype to reporttype
4445+ case 325LLU: // return from reporttype to reporttype
44284446 {
44294447 uint64_t *oldstack = (uint64_t *)stack[0];
44304448 // copy mutable arguments back from call to reporttype
@@ -4437,15 +4455,21 @@
44374455 stack = oldstack;
44384456 fprintf(stderr, "%s", "]");
44394457 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
4440- label = 315LLU; // case complete
4458+ label = 317LLU; // case complete
44414459 break;
44424460 }
4443- case 319LLU: // try next case
4461+ case 323LLU: // copy-back deleter (switch)
44444462 {
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+ {
44454469 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
44464470 exit(-1);
44474471 }
4448- case 315LLU: // completed switch
4472+ case 317LLU: // completed switch
44494473 {
44504474 // return from reporttype
44514475 label = stack[base - 1];
@@ -4452,7 +4476,7 @@
44524476 base = stack[base - 2];
44534477 break;
44544478 }
4455- case 323LLU: // function copytype failed
4479+ case 327LLU: // function copytype failed
44564480 {
44574481 fprintf(stderr, "function copytype failed\n");
44584482 label = stack[base - 3];
@@ -4459,13 +4483,13 @@
44594483 base = stack[base - 2];
44604484 break;
44614485 }
4462- case 322LLU: // copytype
4486+ case 326LLU: // copytype
44634487 {
44644488 //#define res0 0
44654489 //#define arg0 1
44664490 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
44674491 {
4468- label = 325LLU; // jump to alternative
4492+ label = 329LLU; // jump to alternative
44694493 break;
44704494 }
44714495
@@ -4472,16 +4496,16 @@
44724496 /*name*/stack[base + 2] = ((uint64_t **)(stack[base + 1]/*type*/))[1][0]/*name*/;
44734497
44744498 // case
4475- label = 327LLU; // skip deleter
4499+ label = 332LLU; // skip deleter
44764500 break;
44774501 }
4478- case 326LLU: // deleter
4502+ case 331LLU: // deleter
44794503 {
44804504 // throw from copytype
44814505 if(!stack[base + 0])
44824506 {
44834507 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
44854509 break;
44864510 }
44874511 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4491,7 +4515,7 @@
44914515 newstack[0] = (uint64_t)stack; // backup stack location
44924516 newstack[1] = 1234567890;
44934517 newstack[2] = base;
4494- newstack[3] = 328LLU;
4518+ newstack[3] = 333LLU;
44954519 stack = newstack;
44964520 // set stack-base & callee-address
44974521 base = 4/*deloffset*/;
@@ -4498,21 +4522,21 @@
44984522 label = 295LLU; // ~type
44994523 break;
45004524 }
4501- case 328LLU: // return from ~type to copytype
4525+ case 333LLU: // return from ~type to copytype
45024526 {
45034527 stack = (uint64_t *)stack[0];
45044528 // releasing toplevel container
45054529 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
45064530
4507- label = 323LLU; // continue unrolling stack, delete next variable
4531+ label = 330LLU; // continue unrolling stack, delete next variable
45084532 break;
45094533 }
4510- case 327LLU: // skipped deleter
4534+ case 332LLU: // skipped deleter
45114535 {
45124536 // construct type.typename
45134537 if(!(stack[base + 0] = construct(1)))
45144538 {
4515- label = 323LLU; // throw: begin to unroll stack
4539+ label = 330LLU; // throw: begin to unroll stack
45164540 break;
45174541 }
45184542
@@ -4520,14 +4544,20 @@
45204544 ((uint64_t *)stack[base + 0])[0] = 0;
45214545 (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 2]/*name*/;
45224546 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4523- label = 324LLU; // case complete
4547+ label = 328LLU; // case complete
45244548 break;
45254549 }
4526- case 325LLU: // try next case
4550+ case 330LLU: // copy-back deleter (switch)
45274551 {
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+ {
45284558 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*type*/))[0])
45294559 {
4530- label = 329LLU; // jump to alternative
4560+ label = 334LLU; // jump to alternative
45314561 break;
45324562 }
45334563
@@ -4537,7 +4567,7 @@
45374567 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
45384568 if(!newstack)
45394569 {
4540- label = 323LLU; // throw: begin to unroll stack
4570+ label = 335LLU; // throw: begin to unroll stack
45414571 break;
45424572 }
45434573
@@ -4544,18 +4574,18 @@
45444574 newstack[15LLU] = 9876543210LLU; // overflow-marker
45454575 // call copytype from copytype
45464576 newstack[0] = (uint64_t)stack; // backup stack location
4547- newstack[1] = 330LLU;
4577+ newstack[1] = 336LLU;
45484578 newstack[2] = base;
4549- newstack[3] = 331LLU;
4579+ newstack[3] = 337LLU;
45504580 // arguments for call to copytype
45514581 newstack[5LLU] = stack[base + 2]/*original*/;
45524582 stack = newstack;
45534583 // set stack-base & callee-address
45544584 base = 4/*deloffset*/;
4555- label = 322LLU; // copytype
4585+ label = 326LLU; // copytype
45564586 break;
45574587 }
4558- case 330LLU: // copy-back deleter (copytype to copytype)
4588+ case 336LLU: // copy-back deleter (copytype to copytype)
45594589 {
45604590 fprintf(stderr, "in function copytype: unrolling stack, copy-back (copytype to copytype)\n");
45614591 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4567,10 +4597,10 @@
45674597 }
45684598 Free(15LLU + 1, sizeof(uint64_t), stack);
45694599 stack = oldstack;
4570- label = 323LLU; // continue to unroll stack
4600+ label = 335LLU; // continue to unroll stack
45714601 break;
45724602 }
4573- case 331LLU: // return from copytype to copytype
4603+ case 337LLU: // return from copytype to copytype
45744604 {
45754605 uint64_t *oldstack = (uint64_t *)stack[0];
45764606 // copy mutable arguments back from call to copytype
@@ -4583,16 +4613,16 @@
45834613 }
45844614 Free(15LLU + 1, sizeof(uint64_t), stack);
45854615 stack = oldstack;
4586- label = 333LLU; // skip deleter
4616+ label = 339LLU; // skip deleter
45874617 break;
45884618 }
4589- case 332LLU: // deleter
4619+ case 338LLU: // deleter
45904620 {
45914621 // throw from copytype
45924622 if(!stack[base + 0])
45934623 {
45944624 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
45964626 break;
45974627 }
45984628 fprintf(stderr, "in function copytype: unrolling stack, variable type \n");
@@ -4602,7 +4632,7 @@
46024632 newstack[0] = (uint64_t)stack; // backup stack location
46034633 newstack[1] = 1234567890;
46044634 newstack[2] = base;
4605- newstack[3] = 334LLU;
4635+ newstack[3] = 340LLU;
46064636 stack = newstack;
46074637 // set stack-base & callee-address
46084638 base = 4/*deloffset*/;
@@ -4609,21 +4639,21 @@
46094639 label = 295LLU; // ~type
46104640 break;
46114641 }
4612- case 334LLU: // return from ~type to copytype
4642+ case 340LLU: // return from ~type to copytype
46134643 {
46144644 stack = (uint64_t *)stack[0];
46154645 // releasing toplevel container
46164646 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
46174647
4618- label = 323LLU; // continue unrolling stack, delete next variable
4648+ label = 335LLU; // continue unrolling stack, delete next variable
46194649 break;
46204650 }
4621- case 333LLU: // skipped deleter
4651+ case 339LLU: // skipped deleter
46224652 {
46234653 // construct type.typelist
46244654 if(!(stack[base + 0] = construct(1)))
46254655 {
4626- label = 323LLU; // throw: begin to unroll stack
4656+ label = 335LLU; // throw: begin to unroll stack
46274657 break;
46284658 }
46294659
@@ -4631,15 +4661,21 @@
46314661 ((uint64_t *)stack[base + 0])[0] = 1;
46324662 INIT(&(((uint64_t **)(stack[base + 0]))[1][0]), &stack[base + 3]/*copy*/);
46334663 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4634- label = 324LLU; // case complete
4664+ label = 328LLU; // case complete
46354665 break;
46364666 }
4637- case 329LLU: // try next case
4667+ case 335LLU: // copy-back deleter (switch)
46384668 {
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+ {
46394675 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
46404676 exit(-1);
46414677 }
4642- case 324LLU: // completed switch
4678+ case 328LLU: // completed switch
46434679 {
46444680 // return from copytype
46454681 label = stack[base - 1];
@@ -4646,7 +4682,7 @@
46464682 base = stack[base - 2];
46474683 break;
46484684 }
4649- case 336LLU: // function equtype failed
4685+ case 342LLU: // function equtype failed
46504686 {
46514687 fprintf(stderr, "function equtype failed\n");
46524688 label = stack[base - 3];
@@ -4653,7 +4689,7 @@
46534689 base = stack[base - 2];
46544690 break;
46554691 }
4656- case 335LLU: // equtype
4692+ case 341LLU: // equtype
46574693 {
46584694 //#define res0 0
46594695 //#define arg0 1
@@ -4660,7 +4696,7 @@
46604696 //#define arg1 2
46614697 if(/*typename*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
46624698 {
4663- label = 338LLU; // jump to alternative
4699+ label = 344LLU; // jump to alternative
46644700 break;
46654701 }
46664702
@@ -4668,7 +4704,7 @@
46684704
46694705 if(/*typename*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
46704706 {
4671- label = 338LLU; // jump to alternative
4707+ label = 344LLU; // jump to alternative
46724708 break;
46734709 }
46744710
@@ -4676,9 +4712,9 @@
46764712
46774713 // case
46784714 // call equ from equtype
4679- stack[base + 5LLU] = 339LLU/*throw to this address*/;
4715+ stack[base + 5LLU] = 346LLU/*throw to this address*/;
46804716 stack[base + 6LLU] = base;
4681- stack[base + 7LLU] = 340LLU;
4717+ stack[base + 7LLU] = 347LLU;
46824718 // arguments for call to equ
46834719 stack[base + 9LLU] = stack[base + 3]/*xname*/;
46844720 stack[base + 10LLU] = stack[base + 4]/*yname*/;
@@ -4687,14 +4723,14 @@
46874723 label = 18446744073709551600LLU; // equ
46884724 break;
46894725 }
4690- case 339LLU: // copy-back deleter (equ to equtype)
4726+ case 346LLU: // copy-back deleter (equ to equtype)
46914727 {
46924728 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equ to equtype)\n");
46934729 // copy mutable arguments back from call to equ
4694- label = 336LLU; // continue to roll stack
4730+ label = 345LLU; // continue to roll stack
46954731 break;
46964732 }
4697- case 340LLU: // return from equ to equtype
4733+ case 347LLU: // return from equ to equtype
46984734 {
46994735 // copy mutable arguments back from call to equ
47004736 // copy back results provided by call to equ
@@ -4701,14 +4737,21 @@
47014737 stack[base + 0] = stack[base + 8LLU];
47024738 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47034739 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4704- label = 337LLU; // case complete
4740+ label = 343LLU; // case complete
47054741 break;
47064742 }
4707- case 338LLU: // try next case
4743+ case 345LLU: // copy-back deleter (switch)
47084744 {
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+ {
47094752 if(/*typelist*/1 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
47104753 {
4711- label = 341LLU; // jump to alternative
4754+ label = 348LLU; // jump to alternative
47124755 break;
47134756 }
47144757
@@ -4716,7 +4759,7 @@
47164759
47174760 if(/*typelist*/1 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
47184761 {
4719- label = 341LLU; // jump to alternative
4762+ label = 348LLU; // jump to alternative
47204763 break;
47214764 }
47224765
@@ -4726,7 +4769,7 @@
47264769 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
47274770 if(!newstack)
47284771 {
4729- label = 336LLU; // throw: begin to unroll stack
4772+ label = 349LLU; // throw: begin to unroll stack
47304773 break;
47314774 }
47324775
@@ -4733,9 +4776,9 @@
47334776 newstack[15LLU] = 9876543210LLU; // overflow-marker
47344777 // call equtype from equtype
47354778 newstack[0] = (uint64_t)stack; // backup stack location
4736- newstack[1] = 342LLU;
4779+ newstack[1] = 350LLU;
47374780 newstack[2] = base;
4738- newstack[3] = 343LLU;
4781+ newstack[3] = 351LLU;
47394782 // arguments for call to equtype
47404783 newstack[5LLU] = stack[base + 3]/*xsubtype*/;
47414784 newstack[6LLU] = stack[base + 4]/*ysubtype*/;
@@ -4742,10 +4785,10 @@
47424785 stack = newstack;
47434786 // set stack-base & callee-address
47444787 base = 4/*deloffset*/;
4745- label = 335LLU; // equtype
4788+ label = 341LLU; // equtype
47464789 break;
47474790 }
4748- case 342LLU: // copy-back deleter (equtype to equtype)
4791+ case 350LLU: // copy-back deleter (equtype to equtype)
47494792 {
47504793 fprintf(stderr, "in function equtype: unrolling stack, copy-back (equtype to equtype)\n");
47514794 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4757,10 +4800,10 @@
47574800 }
47584801 Free(15LLU + 1, sizeof(uint64_t), stack);
47594802 stack = oldstack;
4760- label = 336LLU; // continue to unroll stack
4803+ label = 349LLU; // continue to unroll stack
47614804 break;
47624805 }
4763- case 343LLU: // return from equtype to equtype
4806+ case 351LLU: // return from equtype to equtype
47644807 {
47654808 uint64_t *oldstack = (uint64_t *)stack[0];
47664809 // copy mutable arguments back from call to equtype
@@ -4775,35 +4818,42 @@
47754818 stack = oldstack;
47764819 ((uint64_t **)(stack[base + 2]))[1][0] = stack[base + 4];
47774820 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
4778- label = 337LLU; // case complete
4821+ label = 343LLU; // case complete
47794822 break;
47804823 }
4781- case 341LLU: // try next case
4824+ case 349LLU: // copy-back deleter (switch)
47824825 {
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+ {
47834833 // default
4784- label = 345LLU; // skip deleter
4834+ label = 353LLU; // skip deleter
47854835 break;
47864836 }
4787- case 344LLU: // deleter
4837+ case 352LLU: // deleter
47884838 {
47894839 // throw from equtype
47904840 if(!stack[base + 0])
47914841 {
47924842 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
47944844 break;
47954845 }
47964846 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
47984848 break;
47994849 }
4800- case 345LLU: // skipped deleter
4850+ case 353LLU: // skipped deleter
48014851 {
48024852 stack[base + 0] = 0;
4803- label = 337LLU; // default complete
4853+ label = 343LLU; // default complete
48044854 break;
48054855 }
4806- case 337LLU: // completed switch
4856+ case 343LLU: // completed switch
48074857 {
48084858 // return from equtype
48094859 label = stack[base - 1];
@@ -4810,7 +4860,7 @@
48104860 base = stack[base - 2];
48114861 break;
48124862 }
4813- case 346LLU: // ~typeid
4863+ case 354LLU: // ~typeid
48144864 {
48154865 if(stack[base + 0]/*variant-nr*/ >= 1)
48164866 {
@@ -4817,10 +4867,10 @@
48174867 fprintf(stderr, "in ~typeid: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
48184868 exit(-1);
48194869 }
4820- label = 346LLU + 1LLU + stack[base + 0]/*variant-nr*/;
4870+ label = 354LLU + 1LLU + stack[base + 0]/*variant-nr*/;
48214871 break;
48224872 }
4823- case 346LLU + 1LLU + 0LLU: // ~typeid.typeid
4873+ case 354LLU + 1LLU + 0LLU: // ~typeid.typeid
48244874 {
48254875 // release element type
48264876 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -4830,7 +4880,7 @@
48304880 newstack[0] = (uint64_t)stack; // backup stack location
48314881 newstack[1] = 1234567890;
48324882 newstack[2] = base;
4833- newstack[3] = 348LLU;
4883+ newstack[3] = 356LLU;
48344884 stack = newstack;
48354885 // set stack-base & callee-address
48364886 base = 4/*deloffset*/;
@@ -4837,7 +4887,7 @@
48374887 label = 295LLU; // ~type
48384888 break;
48394889 }
4840- case 348LLU: // return from ~type to typeid
4890+ case 356LLU: // return from ~type to typeid
48414891 {
48424892 stack = (uint64_t *)stack[0];
48434893 // releasing toplevel container
@@ -4850,7 +4900,7 @@
48504900 base = stack[base - 2];
48514901 break;
48524902 }
4853- case 350LLU: // function copytypeid failed
4903+ case 358LLU: // function copytypeid failed
48544904 {
48554905 fprintf(stderr, "function copytypeid failed\n");
48564906 label = stack[base - 3];
@@ -4857,13 +4907,13 @@
48574907 base = stack[base - 2];
48584908 break;
48594909 }
4860- case 349LLU: // copytypeid
4910+ case 357LLU: // copytypeid
48614911 {
48624912 //#define res0 0
48634913 //#define arg0 1
48644914 if(/*typeid*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
48654915 {
4866- label = 352LLU; // jump to alternative
4916+ label = 360LLU; // jump to alternative
48674917 break;
48684918 }
48694919
@@ -4874,7 +4924,7 @@
48744924 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
48754925 if(!newstack)
48764926 {
4877- label = 350LLU; // throw: begin to unroll stack
4927+ label = 361LLU; // throw: begin to unroll stack
48784928 break;
48794929 }
48804930
@@ -4881,18 +4931,18 @@
48814931 newstack[15LLU] = 9876543210LLU; // overflow-marker
48824932 // call copytype from copytypeid
48834933 newstack[0] = (uint64_t)stack; // backup stack location
4884- newstack[1] = 353LLU;
4934+ newstack[1] = 362LLU;
48854935 newstack[2] = base;
4886- newstack[3] = 354LLU;
4936+ newstack[3] = 363LLU;
48874937 // arguments for call to copytype
48884938 newstack[5LLU] = stack[base + 2]/*origtype*/;
48894939 stack = newstack;
48904940 // set stack-base & callee-address
48914941 base = 4/*deloffset*/;
4892- label = 322LLU; // copytype
4942+ label = 326LLU; // copytype
48934943 break;
48944944 }
4895- case 353LLU: // copy-back deleter (copytype to copytypeid)
4945+ case 362LLU: // copy-back deleter (copytype to copytypeid)
48964946 {
48974947 fprintf(stderr, "in function copytypeid: unrolling stack, copy-back (copytype to copytypeid)\n");
48984948 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -4904,10 +4954,10 @@
49044954 }
49054955 Free(15LLU + 1, sizeof(uint64_t), stack);
49064956 stack = oldstack;
4907- label = 350LLU; // continue to unroll stack
4957+ label = 361LLU; // continue to unroll stack
49084958 break;
49094959 }
4910- case 354LLU: // return from copytype to copytypeid
4960+ case 363LLU: // return from copytype to copytypeid
49114961 {
49124962 uint64_t *oldstack = (uint64_t *)stack[0];
49134963 // copy mutable arguments back from call to copytype
@@ -4920,35 +4970,35 @@
49204970 }
49214971 Free(15LLU + 1, sizeof(uint64_t), stack);
49224972 stack = oldstack;
4923- label = 356LLU; // skip deleter
4973+ label = 365LLU; // skip deleter
49244974 break;
49254975 }
4926- case 355LLU: // deleter
4976+ case 364LLU: // deleter
49274977 {
49284978 // throw from copytypeid
49294979 if(!stack[base + 5])
49304980 {
49314981 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
49334983 break;
49344984 }
49354985 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
49374987 break;
49384988 }
4939- case 356LLU: // skipped deleter
4989+ case 365LLU: // skipped deleter
49404990 {
49414991 stack[base + 5] = stack[base + 3]/*origid*/;
4942- label = 358LLU; // skip deleter
4992+ label = 367LLU; // skip deleter
49434993 break;
49444994 }
4945- case 357LLU: // deleter
4995+ case 366LLU: // deleter
49464996 {
49474997 // throw from copytypeid
49484998 if(!stack[base + 0])
49494999 {
49505000 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
49525002 break;
49535003 }
49545004 fprintf(stderr, "in function copytypeid: unrolling stack, variable typeid \n");
@@ -4958,28 +5008,28 @@
49585008 newstack[0] = (uint64_t)stack; // backup stack location
49595009 newstack[1] = 1234567890;
49605010 newstack[2] = base;
4961- newstack[3] = 359LLU;
5011+ newstack[3] = 368LLU;
49625012 stack = newstack;
49635013 // set stack-base & callee-address
49645014 base = 4/*deloffset*/;
4965- label = 346LLU; // ~typeid
5015+ label = 354LLU; // ~typeid
49665016 break;
49675017 }
4968- case 359LLU: // return from ~typeid to copytypeid
5018+ case 368LLU: // return from ~typeid to copytypeid
49695019 {
49705020 stack = (uint64_t *)stack[0];
49715021 // releasing toplevel container
49725022 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
49735023
4974- label = 355LLU; // continue unrolling stack, delete next variable
5024+ label = 364LLU; // continue unrolling stack, delete next variable
49755025 break;
49765026 }
4977- case 358LLU: // skipped deleter
5027+ case 367LLU: // skipped deleter
49785028 {
49795029 // construct typeid.typeid
49805030 if(!(stack[base + 0] = construct(2)))
49815031 {
4982- label = 355LLU; // throw: begin to unroll stack
5032+ label = 364LLU; // throw: begin to unroll stack
49835033 break;
49845034 }
49855035
@@ -4989,15 +5039,22 @@
49895039 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copyid*/;
49905040 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
49915041 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
4992- label = 351LLU; // case complete
5042+ label = 359LLU; // case complete
49935043 break;
49945044 }
4995- case 352LLU: // try next case
5045+ case 361LLU: // copy-back deleter (switch)
49965046 {
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+ {
49975054 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
49985055 exit(-1);
49995056 }
5000- case 351LLU: // completed switch
5057+ case 359LLU: // completed switch
50015058 {
50025059 // return from copytypeid
50035060 label = stack[base - 1];
@@ -5004,7 +5061,7 @@
50045061 base = stack[base - 2];
50055062 break;
50065063 }
5007- case 361LLU: // function reportti failed
5064+ case 370LLU: // function reportti failed
50085065 {
50095066 fprintf(stderr, "function reportti failed\n");
50105067 label = stack[base - 3];
@@ -5011,12 +5068,12 @@
50115068 base = stack[base - 2];
50125069 break;
50135070 }
5014- case 360LLU: // reportti
5071+ case 369LLU: // reportti
50155072 {
50165073 //#define arg0 0
50175074 if(/*typeid*/0 != ((uint64_t *)(stack[base + 0]/*typeid*/))[0])
50185075 {
5019- label = 363LLU; // jump to alternative
5076+ label = 372LLU; // jump to alternative
50205077 break;
50215078 }
50225079
@@ -5027,7 +5084,7 @@
50275084 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
50285085 if(!newstack)
50295086 {
5030- label = 361LLU; // throw: begin to unroll stack
5087+ label = 373LLU; // throw: begin to unroll stack
50315088 break;
50325089 }
50335090
@@ -5034,18 +5091,18 @@
50345091 newstack[10LLU] = 9876543210LLU; // overflow-marker
50355092 // call reporttype from reportti
50365093 newstack[0] = (uint64_t)stack; // backup stack location
5037- newstack[1] = 364LLU;
5094+ newstack[1] = 374LLU;
50385095 newstack[2] = base;
5039- newstack[3] = 365LLU;
5096+ newstack[3] = 375LLU;
50405097 // arguments for call to reporttype
50415098 newstack[4LLU] = stack[base + 1]/*type*/;
50425099 stack = newstack;
50435100 // set stack-base & callee-address
50445101 base = 4/*deloffset*/;
5045- label = 313LLU; // reporttype
5102+ label = 315LLU; // reporttype
50465103 break;
50475104 }
5048- case 364LLU: // copy-back deleter (reporttype to reportti)
5105+ case 374LLU: // copy-back deleter (reporttype to reportti)
50495106 {
50505107 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reporttype to reportti)\n");
50515108 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5057,10 +5114,10 @@
50575114 }
50585115 Free(10LLU + 1, sizeof(uint64_t), stack);
50595116 stack = oldstack;
5060- label = 361LLU; // continue to unroll stack
5117+ label = 373LLU; // continue to unroll stack
50615118 break;
50625119 }
5063- case 365LLU: // return from reporttype to reportti
5120+ case 375LLU: // return from reporttype to reportti
50645121 {
50655122 uint64_t *oldstack = (uint64_t *)stack[0];
50665123 // copy mutable arguments back from call to reporttype
@@ -5073,9 +5130,9 @@
50735130 stack = oldstack;
50745131 fprintf(stderr, "%s", " ");
50755132 // call reportid from reportti
5076- stack[base + 3LLU] = 366LLU/*throw to this address*/;
5133+ stack[base + 3LLU] = 376LLU/*throw to this address*/;
50775134 stack[base + 4LLU] = base;
5078- stack[base + 5LLU] = 367LLU;
5135+ stack[base + 5LLU] = 377LLU;
50795136 // arguments for call to reportid
50805137 stack[base + 6LLU] = stack[base + 2]/*id*/;
50815138 // set stack-base & callee-address
@@ -5083,27 +5140,34 @@
50835140 label = 18446744073709551586LLU; // reportid
50845141 break;
50855142 }
5086- case 366LLU: // copy-back deleter (reportid to reportti)
5143+ case 376LLU: // copy-back deleter (reportid to reportti)
50875144 {
50885145 fprintf(stderr, "in function reportti: unrolling stack, copy-back (reportid to reportti)\n");
50895146 // copy mutable arguments back from call to reportid
5090- label = 361LLU; // continue to roll stack
5147+ label = 373LLU; // continue to roll stack
50915148 break;
50925149 }
5093- case 367LLU: // return from reportid to reportti
5150+ case 377LLU: // return from reportid to reportti
50945151 {
50955152 // copy mutable arguments back from call to reportid
50965153 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
50975154 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5098- label = 362LLU; // case complete
5155+ label = 371LLU; // case complete
50995156 break;
51005157 }
5101- case 363LLU: // try next case
5158+ case 373LLU: // copy-back deleter (switch)
51025159 {
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+ {
51035167 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
51045168 exit(-1);
51055169 }
5106- case 362LLU: // completed switch
5170+ case 371LLU: // completed switch
51075171 {
51085172 // return from reportti
51095173 label = stack[base - 1];
@@ -5110,7 +5174,7 @@
51105174 base = stack[base - 2];
51115175 break;
51125176 }
5113- case 368LLU: // ~typeidx
5177+ case 378LLU: // ~typeidx
51145178 {
51155179 if(stack[base + 0]/*variant-nr*/ >= 1)
51165180 {
@@ -5117,10 +5181,10 @@
51175181 fprintf(stderr, "in ~typeidx: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
51185182 exit(-1);
51195183 }
5120- label = 368LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5184+ label = 378LLU + 1LLU + stack[base + 0]/*variant-nr*/;
51215185 break;
51225186 }
5123- case 368LLU + 1LLU + 0LLU: // ~typeidx.typeidx
5187+ case 378LLU + 1LLU + 0LLU: // ~typeidx.typeidx
51245188 {
51255189 // release element type
51265190 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5130,7 +5194,7 @@
51305194 newstack[0] = (uint64_t)stack; // backup stack location
51315195 newstack[1] = 1234567890;
51325196 newstack[2] = base;
5133- newstack[3] = 370LLU;
5197+ newstack[3] = 380LLU;
51345198 stack = newstack;
51355199 // set stack-base & callee-address
51365200 base = 4/*deloffset*/;
@@ -5137,7 +5201,7 @@
51375201 label = 295LLU; // ~type
51385202 break;
51395203 }
5140- case 370LLU: // return from ~type to typeidx
5204+ case 380LLU: // return from ~type to typeidx
51415205 {
51425206 stack = (uint64_t *)stack[0];
51435207 // releasing toplevel container
@@ -5150,7 +5214,7 @@
51505214 base = stack[base - 2];
51515215 break;
51525216 }
5153- case 372LLU: // function cptypeidx failed
5217+ case 382LLU: // function cptypeidx failed
51545218 {
51555219 fprintf(stderr, "function cptypeidx failed\n");
51565220 label = stack[base - 3];
@@ -5157,13 +5221,13 @@
51575221 base = stack[base - 2];
51585222 break;
51595223 }
5160- case 371LLU: // cptypeidx
5224+ case 381LLU: // cptypeidx
51615225 {
51625226 //#define res0 0
51635227 //#define arg0 1
51645228 if(/*typeidx*/0 != ((uint64_t *)(stack[base + 1]/*orig*/))[0])
51655229 {
5166- label = 374LLU; // jump to alternative
5230+ label = 384LLU; // jump to alternative
51675231 break;
51685232 }
51695233
@@ -5174,7 +5238,7 @@
51745238 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
51755239 if(!newstack)
51765240 {
5177- label = 372LLU; // throw: begin to unroll stack
5241+ label = 385LLU; // throw: begin to unroll stack
51785242 break;
51795243 }
51805244
@@ -5181,18 +5245,18 @@
51815245 newstack[15LLU] = 9876543210LLU; // overflow-marker
51825246 // call copytype from cptypeidx
51835247 newstack[0] = (uint64_t)stack; // backup stack location
5184- newstack[1] = 375LLU;
5248+ newstack[1] = 386LLU;
51855249 newstack[2] = base;
5186- newstack[3] = 376LLU;
5250+ newstack[3] = 387LLU;
51875251 // arguments for call to copytype
51885252 newstack[5LLU] = stack[base + 2]/*otype*/;
51895253 stack = newstack;
51905254 // set stack-base & callee-address
51915255 base = 4/*deloffset*/;
5192- label = 322LLU; // copytype
5256+ label = 326LLU; // copytype
51935257 break;
51945258 }
5195- case 375LLU: // copy-back deleter (copytype to cptypeidx)
5259+ case 386LLU: // copy-back deleter (copytype to cptypeidx)
51965260 {
51975261 fprintf(stderr, "in function cptypeidx: unrolling stack, copy-back (copytype to cptypeidx)\n");
51985262 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5204,10 +5268,10 @@
52045268 }
52055269 Free(15LLU + 1, sizeof(uint64_t), stack);
52065270 stack = oldstack;
5207- label = 372LLU; // continue to unroll stack
5271+ label = 385LLU; // continue to unroll stack
52085272 break;
52095273 }
5210- case 376LLU: // return from copytype to cptypeidx
5274+ case 387LLU: // return from copytype to cptypeidx
52115275 {
52125276 uint64_t *oldstack = (uint64_t *)stack[0];
52135277 // copy mutable arguments back from call to copytype
@@ -5220,35 +5284,35 @@
52205284 }
52215285 Free(15LLU + 1, sizeof(uint64_t), stack);
52225286 stack = oldstack;
5223- label = 378LLU; // skip deleter
5287+ label = 389LLU; // skip deleter
52245288 break;
52255289 }
5226- case 377LLU: // deleter
5290+ case 388LLU: // deleter
52275291 {
52285292 // throw from cptypeidx
52295293 if(!stack[base + 5])
52305294 {
52315295 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
52335297 break;
52345298 }
52355299 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
52375301 break;
52385302 }
5239- case 378LLU: // skipped deleter
5303+ case 389LLU: // skipped deleter
52405304 {
52415305 stack[base + 5] = stack[base + 3]/*oidx*/;
5242- label = 380LLU; // skip deleter
5306+ label = 391LLU; // skip deleter
52435307 break;
52445308 }
5245- case 379LLU: // deleter
5309+ case 390LLU: // deleter
52465310 {
52475311 // throw from cptypeidx
52485312 if(!stack[base + 0])
52495313 {
52505314 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
52525316 break;
52535317 }
52545318 fprintf(stderr, "in function cptypeidx: unrolling stack, variable typeidx \n");
@@ -5258,28 +5322,28 @@
52585322 newstack[0] = (uint64_t)stack; // backup stack location
52595323 newstack[1] = 1234567890;
52605324 newstack[2] = base;
5261- newstack[3] = 381LLU;
5325+ newstack[3] = 392LLU;
52625326 stack = newstack;
52635327 // set stack-base & callee-address
52645328 base = 4/*deloffset*/;
5265- label = 368LLU; // ~typeidx
5329+ label = 378LLU; // ~typeidx
52665330 break;
52675331 }
5268- case 381LLU: // return from ~typeidx to cptypeidx
5332+ case 392LLU: // return from ~typeidx to cptypeidx
52695333 {
52705334 stack = (uint64_t *)stack[0];
52715335 // releasing toplevel container
52725336 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
52735337
5274- label = 377LLU; // continue unrolling stack, delete next variable
5338+ label = 388LLU; // continue unrolling stack, delete next variable
52755339 break;
52765340 }
5277- case 380LLU: // skipped deleter
5341+ case 391LLU: // skipped deleter
52785342 {
52795343 // construct typeidx.typeidx
52805344 if(!(stack[base + 0] = construct(2)))
52815345 {
5282- label = 377LLU; // throw: begin to unroll stack
5346+ label = 388LLU; // throw: begin to unroll stack
52835347 break;
52845348 }
52855349
@@ -5289,15 +5353,22 @@
52895353 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*cidx*/;
52905354 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
52915355 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5292- label = 373LLU; // case complete
5356+ label = 383LLU; // case complete
52935357 break;
52945358 }
5295- case 374LLU: // try next case
5359+ case 385LLU: // copy-back deleter (switch)
52965360 {
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+ {
52975368 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
52985369 exit(-1);
52995370 }
5300- case 373LLU: // completed switch
5371+ case 383LLU: // completed switch
53015372 {
53025373 // return from cptypeidx
53035374 label = stack[base - 1];
@@ -5304,7 +5375,7 @@
53045375 base = stack[base - 2];
53055376 break;
53065377 }
5307- case 382LLU: // ~result
5378+ case 393LLU: // ~result
53085379 {
53095380 if(stack[base + 0]/*variant-nr*/ >= 1)
53105381 {
@@ -5311,10 +5382,10 @@
53115382 fprintf(stderr, "in ~result: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
53125383 exit(-1);
53135384 }
5314- label = 382LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5385+ label = 393LLU + 1LLU + stack[base + 0]/*variant-nr*/;
53155386 break;
53165387 }
5317- case 382LLU + 1LLU + 0LLU: // ~result.result
5388+ case 393LLU + 1LLU + 0LLU: // ~result.result
53185389 {
53195390 // release element type
53205391 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5324,7 +5395,7 @@
53245395 newstack[0] = (uint64_t)stack; // backup stack location
53255396 newstack[1] = 1234567890;
53265397 newstack[2] = base;
5327- newstack[3] = 384LLU;
5398+ newstack[3] = 395LLU;
53285399 stack = newstack;
53295400 // set stack-base & callee-address
53305401 base = 4/*deloffset*/;
@@ -5331,7 +5402,7 @@
53315402 label = 295LLU; // ~type
53325403 break;
53335404 }
5334- case 384LLU: // return from ~type to result
5405+ case 395LLU: // return from ~type to result
53355406 {
53365407 stack = (uint64_t *)stack[0];
53375408 // releasing toplevel container
@@ -5344,7 +5415,7 @@
53445415 base = stack[base - 2];
53455416 break;
53465417 }
5347- case 386LLU: // function copyresult failed
5418+ case 397LLU: // function copyresult failed
53485419 {
53495420 fprintf(stderr, "function copyresult failed\n");
53505421 label = stack[base - 3];
@@ -5351,13 +5422,13 @@
53515422 base = stack[base - 2];
53525423 break;
53535424 }
5354- case 385LLU: // copyresult
5425+ case 396LLU: // copyresult
53555426 {
53565427 //#define res0 0
53575428 //#define arg0 1
53585429 if(/*result*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
53595430 {
5360- label = 388LLU; // jump to alternative
5431+ label = 399LLU; // jump to alternative
53615432 break;
53625433 }
53635434
@@ -5368,7 +5439,7 @@
53685439 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
53695440 if(!newstack)
53705441 {
5371- label = 386LLU; // throw: begin to unroll stack
5442+ label = 400LLU; // throw: begin to unroll stack
53725443 break;
53735444 }
53745445
@@ -5375,18 +5446,18 @@
53755446 newstack[15LLU] = 9876543210LLU; // overflow-marker
53765447 // call copytype from copyresult
53775448 newstack[0] = (uint64_t)stack; // backup stack location
5378- newstack[1] = 389LLU;
5449+ newstack[1] = 401LLU;
53795450 newstack[2] = base;
5380- newstack[3] = 390LLU;
5451+ newstack[3] = 402LLU;
53815452 // arguments for call to copytype
53825453 newstack[5LLU] = stack[base + 2]/*origtype*/;
53835454 stack = newstack;
53845455 // set stack-base & callee-address
53855456 base = 4/*deloffset*/;
5386- label = 322LLU; // copytype
5457+ label = 326LLU; // copytype
53875458 break;
53885459 }
5389- case 389LLU: // copy-back deleter (copytype to copyresult)
5460+ case 401LLU: // copy-back deleter (copytype to copyresult)
53905461 {
53915462 fprintf(stderr, "in function copyresult: unrolling stack, copy-back (copytype to copyresult)\n");
53925463 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5398,10 +5469,10 @@
53985469 }
53995470 Free(15LLU + 1, sizeof(uint64_t), stack);
54005471 stack = oldstack;
5401- label = 386LLU; // continue to unroll stack
5472+ label = 400LLU; // continue to unroll stack
54025473 break;
54035474 }
5404- case 390LLU: // return from copytype to copyresult
5475+ case 402LLU: // return from copytype to copyresult
54055476 {
54065477 uint64_t *oldstack = (uint64_t *)stack[0];
54075478 // copy mutable arguments back from call to copytype
@@ -5414,16 +5485,16 @@
54145485 }
54155486 Free(15LLU + 1, sizeof(uint64_t), stack);
54165487 stack = oldstack;
5417- label = 392LLU; // skip deleter
5488+ label = 404LLU; // skip deleter
54185489 break;
54195490 }
5420- case 391LLU: // deleter
5491+ case 403LLU: // deleter
54215492 {
54225493 // throw from copyresult
54235494 if(!stack[base + 0])
54245495 {
54255496 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
54275498 break;
54285499 }
54295500 fprintf(stderr, "in function copyresult: unrolling stack, variable result \n");
@@ -5433,28 +5504,28 @@
54335504 newstack[0] = (uint64_t)stack; // backup stack location
54345505 newstack[1] = 1234567890;
54355506 newstack[2] = base;
5436- newstack[3] = 393LLU;
5507+ newstack[3] = 405LLU;
54375508 stack = newstack;
54385509 // set stack-base & callee-address
54395510 base = 4/*deloffset*/;
5440- label = 382LLU; // ~result
5511+ label = 393LLU; // ~result
54415512 break;
54425513 }
5443- case 393LLU: // return from ~result to copyresult
5514+ case 405LLU: // return from ~result to copyresult
54445515 {
54455516 stack = (uint64_t *)stack[0];
54465517 // releasing toplevel container
54475518 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
54485519
5449- label = 386LLU; // continue unrolling stack, delete next variable
5520+ label = 400LLU; // continue unrolling stack, delete next variable
54505521 break;
54515522 }
5452- case 392LLU: // skipped deleter
5523+ case 404LLU: // skipped deleter
54535524 {
54545525 // construct result.result
54555526 if(!(stack[base + 0] = construct(2)))
54565527 {
5457- label = 386LLU; // throw: begin to unroll stack
5528+ label = 400LLU; // throw: begin to unroll stack
54585529 break;
54595530 }
54605531
@@ -5464,15 +5535,22 @@
54645535 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 3]/*RESERVED*/;
54655536 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
54665537 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5467- label = 387LLU; // case complete
5538+ label = 398LLU; // case complete
54685539 break;
54695540 }
5470- case 388LLU: // try next case
5541+ case 400LLU: // copy-back deleter (switch)
54715542 {
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+ {
54725550 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
54735551 exit(-1);
54745552 }
5475- case 387LLU: // completed switch
5553+ case 398LLU: // completed switch
54765554 {
54775555 // return from copyresult
54785556 label = stack[base - 1];
@@ -5479,7 +5557,7 @@
54795557 base = stack[base - 2];
54805558 break;
54815559 }
5482- case 395LLU: // function represult failed
5560+ case 407LLU: // function represult failed
54835561 {
54845562 fprintf(stderr, "function represult failed\n");
54855563 label = stack[base - 3];
@@ -5486,12 +5564,12 @@
54865564 base = stack[base - 2];
54875565 break;
54885566 }
5489- case 394LLU: // represult
5567+ case 406LLU: // represult
54905568 {
54915569 //#define arg0 0
54925570 if(/*result*/0 != ((uint64_t *)(stack[base + 0]/*result*/))[0])
54935571 {
5494- label = 397LLU; // jump to alternative
5572+ label = 409LLU; // jump to alternative
54955573 break;
54965574 }
54975575
@@ -5502,7 +5580,7 @@
55025580 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
55035581 if(!newstack)
55045582 {
5505- label = 395LLU; // throw: begin to unroll stack
5583+ label = 410LLU; // throw: begin to unroll stack
55065584 break;
55075585 }
55085586
@@ -5509,18 +5587,18 @@
55095587 newstack[10LLU] = 9876543210LLU; // overflow-marker
55105588 // call reporttype from represult
55115589 newstack[0] = (uint64_t)stack; // backup stack location
5512- newstack[1] = 398LLU;
5590+ newstack[1] = 411LLU;
55135591 newstack[2] = base;
5514- newstack[3] = 399LLU;
5592+ newstack[3] = 412LLU;
55155593 // arguments for call to reporttype
55165594 newstack[4LLU] = stack[base + 1]/*type*/;
55175595 stack = newstack;
55185596 // set stack-base & callee-address
55195597 base = 4/*deloffset*/;
5520- label = 313LLU; // reporttype
5598+ label = 315LLU; // reporttype
55215599 break;
55225600 }
5523- case 398LLU: // copy-back deleter (reporttype to represult)
5601+ case 411LLU: // copy-back deleter (reporttype to represult)
55245602 {
55255603 fprintf(stderr, "in function represult: unrolling stack, copy-back (reporttype to represult)\n");
55265604 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -5532,10 +5610,10 @@
55325610 }
55335611 Free(10LLU + 1, sizeof(uint64_t), stack);
55345612 stack = oldstack;
5535- label = 395LLU; // continue to unroll stack
5613+ label = 410LLU; // continue to unroll stack
55365614 break;
55375615 }
5538- case 399LLU: // return from reporttype to represult
5616+ case 412LLU: // return from reporttype to represult
55395617 {
55405618 uint64_t *oldstack = (uint64_t *)stack[0];
55415619 // copy mutable arguments back from call to reporttype
@@ -5548,15 +5626,22 @@
55485626 stack = oldstack;
55495627 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
55505628 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5551- label = 396LLU; // case complete
5629+ label = 408LLU; // case complete
55525630 break;
55535631 }
5554- case 397LLU: // try next case
5632+ case 410LLU: // copy-back deleter (switch)
55555633 {
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+ {
55565641 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
55575642 exit(-1);
55585643 }
5559- case 396LLU: // completed switch
5644+ case 408LLU: // completed switch
55605645 {
55615646 // return from represult
55625647 label = stack[base - 1];
@@ -5563,7 +5648,7 @@
55635648 base = stack[base - 2];
55645649 break;
55655650 }
5566- case 400LLU: // ~param
5651+ case 413LLU: // ~param
55675652 {
55685653 if(stack[base + 0]/*variant-nr*/ >= 1)
55695654 {
@@ -5570,10 +5655,10 @@
55705655 fprintf(stderr, "in ~param: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
55715656 exit(-1);
55725657 }
5573- label = 400LLU + 1LLU + stack[base + 0]/*variant-nr*/;
5658+ label = 413LLU + 1LLU + stack[base + 0]/*variant-nr*/;
55745659 break;
55755660 }
5576- case 400LLU + 1LLU + 0LLU: // ~param.param
5661+ case 413LLU + 1LLU + 0LLU: // ~param.param
55775662 {
55785663 // release element typeid
55795664 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5583,14 +5668,14 @@
55835668 newstack[0] = (uint64_t)stack; // backup stack location
55845669 newstack[1] = 1234567890;
55855670 newstack[2] = base;
5586- newstack[3] = 402LLU;
5671+ newstack[3] = 415LLU;
55875672 stack = newstack;
55885673 // set stack-base & callee-address
55895674 base = 4/*deloffset*/;
5590- label = 346LLU; // ~typeid
5675+ label = 354LLU; // ~typeid
55915676 break;
55925677 }
5593- case 402LLU: // return from ~typeid to param
5678+ case 415LLU: // return from ~typeid to param
55945679 {
55955680 stack = (uint64_t *)stack[0];
55965681 // releasing toplevel container
@@ -5603,7 +5688,7 @@
56035688 base = stack[base - 2];
56045689 break;
56055690 }
5606- case 404LLU: // function copyparam failed
5691+ case 417LLU: // function copyparam failed
56075692 {
56085693 fprintf(stderr, "function copyparam failed\n");
56095694 label = stack[base - 3];
@@ -5610,13 +5695,13 @@
56105695 base = stack[base - 2];
56115696 break;
56125697 }
5613- case 403LLU: // copyparam
5698+ case 416LLU: // copyparam
56145699 {
56155700 //#define res0 0
56165701 //#define arg0 1
56175702 if(/*param*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
56185703 {
5619- label = 406LLU; // jump to alternative
5704+ label = 419LLU; // jump to alternative
56205705 break;
56215706 }
56225707
@@ -5625,57 +5710,57 @@
56255710
56265711 // case
56275712 // call copytypeid from copyparam
5628- stack[base + 5LLU] = 407LLU/*throw to this address*/;
5713+ stack[base + 5LLU] = 421LLU/*throw to this address*/;
56295714 stack[base + 6LLU] = base;
5630- stack[base + 7LLU] = 408LLU;
5715+ stack[base + 7LLU] = 422LLU;
56315716 // arguments for call to copytypeid
56325717 stack[base + 9LLU] = stack[base + 2]/*origtypeid*/;
56335718 // set stack-base & callee-address
56345719 base += 8LLU;
5635- label = 349LLU; // copytypeid
5720+ label = 357LLU; // copytypeid
56365721 break;
56375722 }
5638- case 407LLU: // copy-back deleter (copytypeid to copyparam)
5723+ case 421LLU: // copy-back deleter (copytypeid to copyparam)
56395724 {
56405725 fprintf(stderr, "in function copyparam: unrolling stack, copy-back (copytypeid to copyparam)\n");
56415726 // copy mutable arguments back from call to copytypeid
5642- label = 404LLU; // continue to roll stack
5727+ label = 420LLU; // continue to roll stack
56435728 break;
56445729 }
5645- case 408LLU: // return from copytypeid to copyparam
5730+ case 422LLU: // return from copytypeid to copyparam
56465731 {
56475732 // copy mutable arguments back from call to copytypeid
56485733 // copy back results provided by call to copytypeid
56495734 stack[base + 4] = stack[base + 8LLU];
5650- label = 410LLU; // skip deleter
5735+ label = 424LLU; // skip deleter
56515736 break;
56525737 }
5653- case 409LLU: // deleter
5738+ case 423LLU: // deleter
56545739 {
56555740 // throw from copyparam
56565741 if(!stack[base + 5])
56575742 {
56585743 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
56605745 break;
56615746 }
56625747 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
56645749 break;
56655750 }
5666- case 410LLU: // skipped deleter
5751+ case 424LLU: // skipped deleter
56675752 {
56685753 stack[base + 5] = stack[base + 3]/*origmut*/;
5669- label = 412LLU; // skip deleter
5754+ label = 426LLU; // skip deleter
56705755 break;
56715756 }
5672- case 411LLU: // deleter
5757+ case 425LLU: // deleter
56735758 {
56745759 // throw from copyparam
56755760 if(!stack[base + 0])
56765761 {
56775762 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
56795764 break;
56805765 }
56815766 fprintf(stderr, "in function copyparam: unrolling stack, variable param \n");
@@ -5685,28 +5770,28 @@
56855770 newstack[0] = (uint64_t)stack; // backup stack location
56865771 newstack[1] = 1234567890;
56875772 newstack[2] = base;
5688- newstack[3] = 413LLU;
5773+ newstack[3] = 427LLU;
56895774 stack = newstack;
56905775 // set stack-base & callee-address
56915776 base = 4/*deloffset*/;
5692- label = 400LLU; // ~param
5777+ label = 413LLU; // ~param
56935778 break;
56945779 }
5695- case 413LLU: // return from ~param to copyparam
5780+ case 427LLU: // return from ~param to copyparam
56965781 {
56975782 stack = (uint64_t *)stack[0];
56985783 // releasing toplevel container
56995784 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
57005785
5701- label = 409LLU; // continue unrolling stack, delete next variable
5786+ label = 423LLU; // continue unrolling stack, delete next variable
57025787 break;
57035788 }
5704- case 412LLU: // skipped deleter
5789+ case 426LLU: // skipped deleter
57055790 {
57065791 // construct param.param
57075792 if(!(stack[base + 0] = construct(2)))
57085793 {
5709- label = 409LLU; // throw: begin to unroll stack
5794+ label = 423LLU; // throw: begin to unroll stack
57105795 break;
57115796 }
57125797
@@ -5716,15 +5801,22 @@
57165801 (((uint64_t **)(stack[base + 0]))[1][1]) = stack[base + 5]/*copymut*/;
57175802 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
57185803 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
5719- label = 405LLU; // case complete
5804+ label = 418LLU; // case complete
57205805 break;
57215806 }
5722- case 406LLU: // try next case
5807+ case 420LLU: // copy-back deleter (switch)
57235808 {
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+ {
57245816 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
57255817 exit(-1);
57265818 }
5727- case 405LLU: // completed switch
5819+ case 418LLU: // completed switch
57285820 {
57295821 // return from copyparam
57305822 label = stack[base - 1];
@@ -5731,7 +5823,7 @@
57315823 base = stack[base - 2];
57325824 break;
57335825 }
5734- case 415LLU: // function repparam failed
5826+ case 429LLU: // function repparam failed
57355827 {
57365828 fprintf(stderr, "function repparam failed\n");
57375829 label = stack[base - 3];
@@ -5738,12 +5830,12 @@
57385830 base = stack[base - 2];
57395831 break;
57405832 }
5741- case 414LLU: // repparam
5833+ case 428LLU: // repparam
57425834 {
57435835 //#define arg0 0
57445836 if(/*param*/0 != ((uint64_t *)(stack[base + 0]/*param*/))[0])
57455837 {
5746- label = 417LLU; // jump to alternative
5838+ label = 431LLU; // jump to alternative
57475839 break;
57485840 }
57495841
@@ -5753,54 +5845,61 @@
57535845 // case
57545846 if(!stack[base + 2]/*mutable*/)
57555847 {
5756- label = 418LLU; // jump to alternative
5848+ label = 433LLU; // jump to alternative
57575849 break;
57585850 }
57595851
57605852 // consequent
57615853 fprintf(stderr, "%s", "mut ");
5762- label = 419LLU; // consequent complete
5854+ label = 434LLU; // consequent complete
57635855 break;
57645856 }
5765- case 418LLU: // alternative
5857+ case 433LLU: // alternative
57665858 {
5767- label = 419LLU; // alternative complete
5859+ label = 434LLU; // alternative complete
57685860 break;
57695861 }
5770- case 419LLU: // completed if-then-else
5862+ case 434LLU: // completed if-then-else
57715863 {
57725864 // call reportti from repparam
5773- stack[base + 3LLU] = 420LLU/*throw to this address*/;
5865+ stack[base + 3LLU] = 435LLU/*throw to this address*/;
57745866 stack[base + 4LLU] = base;
5775- stack[base + 5LLU] = 421LLU;
5867+ stack[base + 5LLU] = 436LLU;
57765868 // arguments for call to reportti
57775869 stack[base + 6LLU] = stack[base + 1]/*typeid*/;
57785870 // set stack-base & callee-address
57795871 base += 6LLU;
5780- label = 360LLU; // reportti
5872+ label = 369LLU; // reportti
57815873 break;
57825874 }
5783- case 420LLU: // copy-back deleter (reportti to repparam)
5875+ case 435LLU: // copy-back deleter (reportti to repparam)
57845876 {
57855877 fprintf(stderr, "in function repparam: unrolling stack, copy-back (reportti to repparam)\n");
57865878 // copy mutable arguments back from call to reportti
5787- label = 415LLU; // continue to roll stack
5879+ label = 432LLU; // continue to roll stack
57885880 break;
57895881 }
5790- case 421LLU: // return from reportti to repparam
5882+ case 436LLU: // return from reportti to repparam
57915883 {
57925884 // copy mutable arguments back from call to reportti
57935885 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
57945886 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
5795- label = 416LLU; // case complete
5887+ label = 430LLU; // case complete
57965888 break;
57975889 }
5798- case 417LLU: // try next case
5890+ case 432LLU: // copy-back deleter (switch)
57995891 {
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+ {
58005899 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
58015900 exit(-1);
58025901 }
5803- case 416LLU: // completed switch
5902+ case 430LLU: // completed switch
58045903 {
58055904 // return from repparam
58065905 label = stack[base - 1];
@@ -5807,7 +5906,7 @@
58075906 base = stack[base - 2];
58085907 break;
58095908 }
5810- case 423LLU: // function lookparam failed
5909+ case 438LLU: // function lookparam failed
58115910 {
58125911 fprintf(stderr, "function lookparam failed\n");
58135912 label = stack[base - 3];
@@ -5814,39 +5913,39 @@
58145913 base = stack[base - 2];
58155914 break;
58165915 }
5817- case 422LLU: // lookparam
5916+ case 437LLU: // lookparam
58185917 {
58195918 //#define res0 0
58205919 //#define arg0 1
58215920 //#define arg1 2
5822- label = 425LLU; // skip deleter
5921+ label = 440LLU; // skip deleter
58235922 break;
58245923 }
5825- case 424LLU: // deleter
5924+ case 439LLU: // deleter
58265925 {
58275926 // throw from lookparam
58285927 if(!stack[base + 3])
58295928 {
58305929 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
58325931 break;
58335932 }
58345933 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
58365935 break;
58375936 }
5838- case 425LLU: // skipped deleter
5937+ case 440LLU: // skipped deleter
58395938 {
58405939 stack[base + 3] = 0;
58415940 flippedassign(stack[base + 1]/*params*/, &stack[base + 4]);
5842- label = 426LLU; // start to repeat
5941+ label = 441LLU; // start to repeat
58435942 break;
58445943 }
5845- case 426LLU: // repeat from here
5944+ case 441LLU: // repeat from here
58465945 {
58475946 if(!stack[base + 4])
58485947 {
5849- label = 427LLU; // break loop
5948+ label = 442LLU; // break loop
58505949 break;
58515950 }
58525951
@@ -5856,19 +5955,19 @@
58565955 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
58575956 if(!stack[base + 3]/*found*/)
58585957 {
5859- label = 428LLU; // jump to alternative
5958+ label = 443LLU; // jump to alternative
58605959 break;
58615960 }
58625961
58635962 // consequent
5864- label = 429LLU; // consequent complete
5963+ label = 444LLU; // consequent complete
58655964 break;
58665965 }
5867- case 428LLU: // alternative
5966+ case 443LLU: // alternative
58685967 {
58695968 if(/*param*/0 != ((uint64_t *)(stack[base + 5]/*param*/))[0])
58705969 {
5871- label = 431LLU; // jump to alternative
5970+ label = 446LLU; // jump to alternative
58725971 break;
58735972 }
58745973
@@ -5878,7 +5977,7 @@
58785977 // case
58795978 if(/*typeid*/0 != ((uint64_t *)(stack[base + 7]/*typeid*/))[0])
58805979 {
5881- label = 433LLU; // jump to alternative
5980+ label = 449LLU; // jump to alternative
58825981 break;
58835982 }
58845983
@@ -5887,9 +5986,9 @@
58875986
58885987 // case
58895988 // call equ from lookparam
5890- stack[base + 11LLU] = 434LLU/*throw to this address*/;
5989+ stack[base + 11LLU] = 451LLU/*throw to this address*/;
58915990 stack[base + 12LLU] = base;
5892- stack[base + 13LLU] = 435LLU;
5991+ stack[base + 13LLU] = 452LLU;
58935992 // arguments for call to equ
58945993 stack[base + 15LLU] = stack[base + 10]/*id*/;
58955994 stack[base + 16LLU] = stack[base + 2]/*wanted*/;
@@ -5898,14 +5997,14 @@
58985997 label = 18446744073709551600LLU; // equ
58995998 break;
59005999 }
5901- case 434LLU: // copy-back deleter (equ to lookparam)
6000+ case 451LLU: // copy-back deleter (equ to lookparam)
59026001 {
59036002 fprintf(stderr, "in function lookparam: unrolling stack, copy-back (equ to lookparam)\n");
59046003 // copy mutable arguments back from call to equ
5905- label = 424LLU; // continue to roll stack
6004+ label = 450LLU; // continue to roll stack
59066005 break;
59076006 }
5908- case 435LLU: // return from equ to lookparam
6007+ case 452LLU: // return from equ to lookparam
59096008 {
59106009 // copy mutable arguments back from call to equ
59116010 // copy back results provided by call to equ
@@ -5912,56 +6011,70 @@
59126011 stack[base + 3] = stack[base + 14LLU];
59136012 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 10];
59146013 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 9];
5915- label = 432LLU; // case complete
6014+ label = 448LLU; // case complete
59166015 break;
59176016 }
5918- case 433LLU: // try next case
6017+ case 450LLU: // copy-back deleter (switch)
59196018 {
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+ {
59206026 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
59216027 exit(-1);
59226028 }
5923- case 432LLU: // completed switch
6029+ case 448LLU: // completed switch
59246030 {
59256031 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
59266032 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
5927- label = 430LLU; // case complete
6033+ label = 445LLU; // case complete
59286034 break;
59296035 }
5930- case 431LLU: // try next case
6036+ case 447LLU: // copy-back deleter (switch)
59316037 {
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+ {
59326045 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
59336046 exit(-1);
59346047 }
5935- case 430LLU: // completed switch
6048+ case 445LLU: // completed switch
59366049 {
5937- label = 429LLU; // alternative complete
6050+ label = 444LLU; // alternative complete
59386051 break;
59396052 }
5940- case 429LLU: // completed if-then-else
6053+ case 444LLU: // completed if-then-else
59416054 {
59426055 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
5943- label = 426LLU; // repeat
6056+ label = 441LLU; // repeat
59446057 break;
59456058 }
5946- case 427LLU: // loop finished
6059+ case 442LLU: // loop finished
59476060 {
5948- label = 437LLU; // skip deleter
6061+ label = 454LLU; // skip deleter
59496062 break;
59506063 }
5951- case 436LLU: // deleter
6064+ case 453LLU: // deleter
59526065 {
59536066 // throw from lookparam
59546067 if(!stack[base + 0])
59556068 {
59566069 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
59586071 break;
59596072 }
59606073 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
59626075 break;
59636076 }
5964- case 437LLU: // skipped deleter
6077+ case 454LLU: // skipped deleter
59656078 {
59666079 stack[base + 0] = stack[base + 3]/*found*/;
59676080 // return from lookparam
@@ -5969,7 +6082,7 @@
59696082 base = stack[base - 2];
59706083 break;
59716084 }
5972- case 438LLU: // ~letdef
6085+ case 455LLU: // ~letdef
59736086 {
59746087 if(stack[base + 0]/*variant-nr*/ >= 1)
59756088 {
@@ -5976,10 +6089,10 @@
59766089 fprintf(stderr, "in ~letdef: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
59776090 exit(-1);
59786091 }
5979- label = 438LLU + 1LLU + stack[base + 0]/*variant-nr*/;
6092+ label = 455LLU + 1LLU + stack[base + 0]/*variant-nr*/;
59806093 break;
59816094 }
5982- case 438LLU + 1LLU + 0LLU: // ~letdef.letdef
6095+ case 455LLU + 1LLU + 0LLU: // ~letdef.letdef
59836096 {
59846097 // release element type
59856098 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[0/*element-nr*/];
@@ -5989,7 +6102,7 @@
59896102 newstack[0] = (uint64_t)stack; // backup stack location
59906103 newstack[1] = 1234567890;
59916104 newstack[2] = base;
5992- newstack[3] = 440LLU;
6105+ newstack[3] = 457LLU;
59936106 stack = newstack;
59946107 // set stack-base & callee-address
59956108 base = 4/*deloffset*/;
@@ -5996,7 +6109,7 @@
59966109 label = 295LLU; // ~type
59976110 break;
59986111 }
5999- case 440LLU: // return from ~type to letdef
6112+ case 457LLU: // return from ~type to letdef
60006113 {
60016114 stack = (uint64_t *)stack[0];
60026115 // releasing toplevel container
@@ -6012,7 +6125,7 @@
60126125 base = stack[base - 2];
60136126 break;
60146127 }
6015- case 442LLU: // function mkletdummy failed
6128+ case 459LLU: // function mkletdummy failed
60166129 {
60176130 fprintf(stderr, "function mkletdummy failed\n");
60186131 label = stack[base - 3];
@@ -6019,38 +6132,38 @@
60196132 base = stack[base - 2];
60206133 break;
60216134 }
6022- case 441LLU: // mkletdummy
6135+ case 458LLU: // mkletdummy
60236136 {
60246137 //#define res0 0
6025- label = 444LLU; // skip deleter
6138+ label = 461LLU; // skip deleter
60266139 break;
60276140 }
6028- case 443LLU: // deleter
6141+ case 460LLU: // deleter
60296142 {
60306143 // throw from mkletdummy
60316144 if(!stack[base + 1])
60326145 {
60336146 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
60356148 break;
60366149 }
60376150 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
60396152 break;
60406153 }
6041- case 444LLU: // skipped deleter
6154+ case 461LLU: // skipped deleter
60426155 {
60436156 stack[base + 1] = 78026663350239232;
6044- label = 446LLU; // skip deleter
6157+ label = 463LLU; // skip deleter
60456158 break;
60466159 }
6047- case 445LLU: // deleter
6160+ case 462LLU: // deleter
60486161 {
60496162 // throw from mkletdummy
60506163 if(!stack[base + 2])
60516164 {
60526165 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
60546167 break;
60556168 }
60566169 fprintf(stderr, "in function mkletdummy: unrolling stack, variable type \n");
@@ -6060,7 +6173,7 @@
60606173 newstack[0] = (uint64_t)stack; // backup stack location
60616174 newstack[1] = 1234567890;
60626175 newstack[2] = base;
6063- newstack[3] = 447LLU;
6176+ newstack[3] = 464LLU;
60646177 stack = newstack;
60656178 // set stack-base & callee-address
60666179 base = 4/*deloffset*/;
@@ -6067,21 +6180,21 @@
60676180 label = 295LLU; // ~type
60686181 break;
60696182 }
6070- case 447LLU: // return from ~type to mkletdummy
6183+ case 464LLU: // return from ~type to mkletdummy
60716184 {
60726185 stack = (uint64_t *)stack[0];
60736186 // releasing toplevel container
60746187 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 2] - sizeof(uint64_t) * 4));
60756188
6076- label = 443LLU; // continue unrolling stack, delete next variable
6189+ label = 460LLU; // continue unrolling stack, delete next variable
60776190 break;
60786191 }
6079- case 446LLU: // skipped deleter
6192+ case 463LLU: // skipped deleter
60806193 {
60816194 // construct type.typename
60826195 if(!(stack[base + 2] = construct(1)))
60836196 {
6084- label = 443LLU; // throw: begin to unroll stack
6197+ label = 460LLU; // throw: begin to unroll stack
60856198 break;
60866199 }
60876200
@@ -6088,73 +6201,73 @@
60886201 // consequent
60896202 ((uint64_t *)stack[base + 2])[0] = 0;
60906203 (((uint64_t **)(stack[base + 2]))[1][0]) = stack[base + 1]/*newid*/;
6091- label = 449LLU; // skip deleter
6204+ label = 466LLU; // skip deleter
60926205 break;
60936206 }
6094- case 448LLU: // deleter
6207+ case 465LLU: // deleter
60956208 {
60966209 // throw from mkletdummy
60976210 if(!stack[base + 3])
60986211 {
60996212 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
61016214 break;
61026215 }
61036216 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
61056218 break;
61066219 }
6107- case 449LLU: // skipped deleter
6220+ case 466LLU: // skipped deleter
61086221 {
61096222 stack[base + 3] = 0;
6110- label = 451LLU; // skip deleter
6223+ label = 468LLU; // skip deleter
61116224 break;
61126225 }
6113- case 450LLU: // deleter
6226+ case 467LLU: // deleter
61146227 {
61156228 // throw from mkletdummy
61166229 if(!stack[base + 4])
61176230 {
61186231 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
61206233 break;
61216234 }
61226235 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
61246237 break;
61256238 }
6126- case 451LLU: // skipped deleter
6239+ case 468LLU: // skipped deleter
61276240 {
61286241 stack[base + 4] = 0;
6129- label = 453LLU; // skip deleter
6242+ label = 470LLU; // skip deleter
61306243 break;
61316244 }
6132- case 452LLU: // deleter
6245+ case 469LLU: // deleter
61336246 {
61346247 // throw from mkletdummy
61356248 if(!stack[base + 5])
61366249 {
61376250 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
61396252 break;
61406253 }
61416254 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
61436256 break;
61446257 }
6145- case 453LLU: // skipped deleter
6258+ case 470LLU: // skipped deleter
61466259 {
61476260 stack[base + 5] = 0;
6148- label = 455LLU; // skip deleter
6261+ label = 472LLU; // skip deleter
61496262 break;
61506263 }
6151- case 454LLU: // deleter
6264+ case 471LLU: // deleter
61526265 {
61536266 // throw from mkletdummy
61546267 if(!stack[base + 0])
61556268 {
61566269 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
61586271 break;
61596272 }
61606273 fprintf(stderr, "in function mkletdummy: unrolling stack, variable letdef \n");
@@ -6164,28 +6277,28 @@
61646277 newstack[0] = (uint64_t)stack; // backup stack location
61656278 newstack[1] = 1234567890;
61666279 newstack[2] = base;
6167- newstack[3] = 456LLU;
6280+ newstack[3] = 473LLU;
61686281 stack = newstack;
61696282 // set stack-base & callee-address
61706283 base = 4/*deloffset*/;
6171- label = 438LLU; // ~letdef
6284+ label = 455LLU; // ~letdef
61726285 break;
61736286 }
6174- case 456LLU: // return from ~letdef to mkletdummy
6287+ case 473LLU: // return from ~letdef to mkletdummy
61756288 {
61766289 stack = (uint64_t *)stack[0];
61776290 // releasing toplevel container
61786291 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
61796292
6180- label = 452LLU; // continue unrolling stack, delete next variable
6293+ label = 469LLU; // continue unrolling stack, delete next variable
61816294 break;
61826295 }
6183- case 455LLU: // skipped deleter
6296+ case 472LLU: // skipped deleter
61846297 {
61856298 // construct letdef.letdef
61866299 if(!(stack[base + 0] = construct(5)))
61876300 {
6188- label = 452LLU; // throw: begin to unroll stack
6301+ label = 469LLU; // throw: begin to unroll stack
61896302 break;
61906303 }
61916304
@@ -6201,7 +6314,7 @@
62016314 base = stack[base - 2];
62026315 break;
62036316 }
6204- case 458LLU: // function reportlet failed
6317+ case 475LLU: // function reportlet failed
62056318 {
62066319 fprintf(stderr, "function reportlet failed\n");
62076320 label = stack[base - 3];
@@ -6208,12 +6321,12 @@
62086321 base = stack[base - 2];
62096322 break;
62106323 }
6211- case 457LLU: // reportlet
6324+ case 474LLU: // reportlet
62126325 {
62136326 //#define arg0 0
62146327 if(/*letdef*/0 != ((uint64_t *)(stack[base + 0]/*letdef*/))[0])
62156328 {
6216- label = 460LLU; // jump to alternative
6329+ label = 477LLU; // jump to alternative
62176330 break;
62186331 }
62196332
@@ -6226,26 +6339,26 @@
62266339 // case
62276340 if(!stack[base + 4]/*mutable*/)
62286341 {
6229- label = 461LLU; // jump to alternative
6342+ label = 479LLU; // jump to alternative
62306343 break;
62316344 }
62326345
62336346 // consequent
62346347 fprintf(stderr, "%s", "mut ");
6235- label = 462LLU; // consequent complete
6348+ label = 480LLU; // consequent complete
62366349 break;
62376350 }
6238- case 461LLU: // alternative
6351+ case 479LLU: // alternative
62396352 {
6240- label = 462LLU; // alternative complete
6353+ label = 480LLU; // alternative complete
62416354 break;
62426355 }
6243- case 462LLU: // completed if-then-else
6356+ case 480LLU: // completed if-then-else
62446357 {
62456358 uint64_t *newstack = (uint64_t *)Calloc(10LLU + 1, sizeof(uint64_t));
62466359 if(!newstack)
62476360 {
6248- label = 458LLU; // throw: begin to unroll stack
6361+ label = 478LLU; // throw: begin to unroll stack
62496362 break;
62506363 }
62516364
@@ -6252,18 +6365,18 @@
62526365 newstack[10LLU] = 9876543210LLU; // overflow-marker
62536366 // call reporttype from reportlet
62546367 newstack[0] = (uint64_t)stack; // backup stack location
6255- newstack[1] = 463LLU;
6368+ newstack[1] = 481LLU;
62566369 newstack[2] = base;
6257- newstack[3] = 464LLU;
6370+ newstack[3] = 482LLU;
62586371 // arguments for call to reporttype
62596372 newstack[4LLU] = stack[base + 1]/*type*/;
62606373 stack = newstack;
62616374 // set stack-base & callee-address
62626375 base = 4/*deloffset*/;
6263- label = 313LLU; // reporttype
6376+ label = 315LLU; // reporttype
62646377 break;
62656378 }
6266- case 463LLU: // copy-back deleter (reporttype to reportlet)
6379+ case 481LLU: // copy-back deleter (reporttype to reportlet)
62676380 {
62686381 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reporttype to reportlet)\n");
62696382 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6275,10 +6388,10 @@
62756388 }
62766389 Free(10LLU + 1, sizeof(uint64_t), stack);
62776390 stack = oldstack;
6278- label = 458LLU; // continue to unroll stack
6391+ label = 478LLU; // continue to unroll stack
62796392 break;
62806393 }
6281- case 464LLU: // return from reporttype to reportlet
6394+ case 482LLU: // return from reporttype to reportlet
62826395 {
62836396 uint64_t *oldstack = (uint64_t *)stack[0];
62846397 // copy mutable arguments back from call to reporttype
@@ -6291,9 +6404,9 @@
62916404 stack = oldstack;
62926405 fprintf(stderr, "%s", " ");
62936406 // call reportid from reportlet
6294- stack[base + 6LLU] = 465LLU/*throw to this address*/;
6407+ stack[base + 6LLU] = 483LLU/*throw to this address*/;
62956408 stack[base + 7LLU] = base;
6296- stack[base + 8LLU] = 466LLU;
6409+ stack[base + 8LLU] = 484LLU;
62976410 // arguments for call to reportid
62986411 stack[base + 9LLU] = stack[base + 2]/*id*/;
62996412 // set stack-base & callee-address
@@ -6301,21 +6414,21 @@
63016414 label = 18446744073709551586LLU; // reportid
63026415 break;
63036416 }
6304- case 465LLU: // copy-back deleter (reportid to reportlet)
6417+ case 483LLU: // copy-back deleter (reportid to reportlet)
63056418 {
63066419 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportid to reportlet)\n");
63076420 // copy mutable arguments back from call to reportid
6308- label = 458LLU; // continue to roll stack
6421+ label = 478LLU; // continue to roll stack
63096422 break;
63106423 }
6311- case 466LLU: // return from reportid to reportlet
6424+ case 484LLU: // return from reportid to reportlet
63126425 {
63136426 // copy mutable arguments back from call to reportid
63146427 fprintf(stderr, "%s", " ");
63156428 // call reportnr from reportlet
6316- stack[base + 6LLU] = 467LLU/*throw to this address*/;
6429+ stack[base + 6LLU] = 485LLU/*throw to this address*/;
63176430 stack[base + 7LLU] = base;
6318- stack[base + 8LLU] = 468LLU;
6431+ stack[base + 8LLU] = 486LLU;
63196432 // arguments for call to reportnr
63206433 stack[base + 9LLU] = stack[base + 3]/*index*/;
63216434 // set stack-base & callee-address
@@ -6323,14 +6436,14 @@
63236436 label = 18446744073709551589LLU; // reportnr
63246437 break;
63256438 }
6326- case 467LLU: // copy-back deleter (reportnr to reportlet)
6439+ case 485LLU: // copy-back deleter (reportnr to reportlet)
63276440 {
63286441 fprintf(stderr, "in function reportlet: unrolling stack, copy-back (reportnr to reportlet)\n");
63296442 // copy mutable arguments back from call to reportnr
6330- label = 458LLU; // continue to roll stack
6443+ label = 478LLU; // continue to roll stack
63316444 break;
63326445 }
6333- case 468LLU: // return from reportnr to reportlet
6446+ case 486LLU: // return from reportnr to reportlet
63346447 {
63356448 // copy mutable arguments back from call to reportnr
63366449 ((uint64_t **)(stack[base + 0]))[1][4] = stack[base + 5];
@@ -6338,15 +6451,25 @@
63386451 ((uint64_t **)(stack[base + 0]))[1][2] = stack[base + 3];
63396452 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
63406453 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
6341- label = 459LLU; // case complete
6454+ label = 476LLU; // case complete
63426455 break;
63436456 }
6344- case 460LLU: // try next case
6457+ case 478LLU: // copy-back deleter (switch)
63456458 {
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+ {
63466469 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
63476470 exit(-1);
63486471 }
6349- case 459LLU: // completed switch
6472+ case 476LLU: // completed switch
63506473 {
63516474 // return from reportlet
63526475 label = stack[base - 1];
@@ -6353,7 +6476,7 @@
63536476 base = stack[base - 2];
63546477 break;
63556478 }
6356- case 470LLU: // function equletdef failed
6479+ case 488LLU: // function equletdef failed
63576480 {
63586481 fprintf(stderr, "function equletdef failed\n");
63596482 label = stack[base - 3];
@@ -6360,7 +6483,7 @@
63606483 base = stack[base - 2];
63616484 break;
63626485 }
6363- case 469LLU: // equletdef
6486+ case 487LLU: // equletdef
63646487 {
63656488 //#define res0 0
63666489 //#define arg0 1
@@ -6367,7 +6490,7 @@
63676490 //#define arg1 2
63686491 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*x*/))[0])
63696492 {
6370- label = 472LLU; // jump to alternative
6493+ label = 490LLU; // jump to alternative
63716494 break;
63726495 }
63736496
@@ -6379,7 +6502,7 @@
63796502
63806503 if(/*letdef*/0 != ((uint64_t *)(stack[base + 2]/*y*/))[0])
63816504 {
6382- label = 472LLU; // jump to alternative
6505+ label = 490LLU; // jump to alternative
63836506 break;
63846507 }
63856508
@@ -6390,48 +6513,48 @@
63906513 /*ysubstruct*/stack[base + 12] = ((uint64_t **)(stack[base + 2]/*y*/))[1][4]/*substruct*/;
63916514
63926515 // case
6393- label = 474LLU; // skip deleter
6516+ label = 493LLU; // skip deleter
63946517 break;
63956518 }
6396- case 473LLU: // deleter
6519+ case 492LLU: // deleter
63976520 {
63986521 // throw from equletdef
63996522 if(!stack[base + 13])
64006523 {
64016524 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
64036526 break;
64046527 }
64056528 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
64076530 break;
64086531 }
6409- case 474LLU: // skipped deleter
6532+ case 493LLU: // skipped deleter
64106533 {
64116534 stack[base + 13] = 1;
6412- label = 476LLU; // skip deleter
6535+ label = 495LLU; // skip deleter
64136536 break;
64146537 }
6415- case 475LLU: // deleter
6538+ case 494LLU: // deleter
64166539 {
64176540 // throw from equletdef
64186541 if(!stack[base + 14])
64196542 {
64206543 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
64226545 break;
64236546 }
64246547 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
64266549 break;
64276550 }
6428- case 476LLU: // skipped deleter
6551+ case 495LLU: // skipped deleter
64296552 {
64306553 stack[base + 14] = 0;
64316554 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
64326555 if(!newstack)
64336556 {
6434- label = 475LLU; // throw: begin to unroll stack
6557+ label = 494LLU; // throw: begin to unroll stack
64356558 break;
64366559 }
64376560
@@ -6438,9 +6561,9 @@
64386561 newstack[15LLU] = 9876543210LLU; // overflow-marker
64396562 // call equtype from equletdef
64406563 newstack[0] = (uint64_t)stack; // backup stack location
6441- newstack[1] = 477LLU;
6564+ newstack[1] = 496LLU;
64426565 newstack[2] = base;
6443- newstack[3] = 478LLU;
6566+ newstack[3] = 497LLU;
64446567 // arguments for call to equtype
64456568 newstack[5LLU] = stack[base + 3]/*xtype*/;
64466569 newstack[6LLU] = stack[base + 8]/*ytype*/;
@@ -6447,10 +6570,10 @@
64476570 stack = newstack;
64486571 // set stack-base & callee-address
64496572 base = 4/*deloffset*/;
6450- label = 335LLU; // equtype
6573+ label = 341LLU; // equtype
64516574 break;
64526575 }
6453- case 477LLU: // copy-back deleter (equtype to equletdef)
6576+ case 496LLU: // copy-back deleter (equtype to equletdef)
64546577 {
64556578 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equtype to equletdef)\n");
64566579 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6462,10 +6585,10 @@
64626585 }
64636586 Free(15LLU + 1, sizeof(uint64_t), stack);
64646587 stack = oldstack;
6465- label = 475LLU; // continue to unroll stack
6588+ label = 494LLU; // continue to unroll stack
64666589 break;
64676590 }
6468- case 478LLU: // return from equtype to equletdef
6591+ case 497LLU: // return from equtype to equletdef
64696592 {
64706593 uint64_t *oldstack = (uint64_t *)stack[0];
64716594 // copy mutable arguments back from call to equtype
@@ -6479,9 +6602,9 @@
64796602 Free(15LLU + 1, sizeof(uint64_t), stack);
64806603 stack = oldstack;
64816604 // call and from equletdef
6482- stack[base + 15LLU] = 479LLU/*throw to this address*/;
6605+ stack[base + 15LLU] = 498LLU/*throw to this address*/;
64836606 stack[base + 16LLU] = base;
6484- stack[base + 17LLU] = 480LLU;
6607+ stack[base + 17LLU] = 499LLU;
64856608 // arguments for call to and
64866609 stack[base + 19LLU] = stack[base + 13]/*result*/;
64876610 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6490,22 +6613,22 @@
64906613 label = 18446744073709551613LLU; // and
64916614 break;
64926615 }
6493- case 479LLU: // copy-back deleter (and to equletdef)
6616+ case 498LLU: // copy-back deleter (and to equletdef)
64946617 {
64956618 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
64966619 // copy mutable arguments back from call to and
6497- label = 475LLU; // continue to roll stack
6620+ label = 494LLU; // continue to roll stack
64986621 break;
64996622 }
6500- case 480LLU: // return from and to equletdef
6623+ case 499LLU: // return from and to equletdef
65016624 {
65026625 // copy mutable arguments back from call to and
65036626 // copy back results provided by call to and
65046627 stack[base + 13] = stack[base + 18LLU];
65056628 // call equ from equletdef
6506- stack[base + 15LLU] = 481LLU/*throw to this address*/;
6629+ stack[base + 15LLU] = 500LLU/*throw to this address*/;
65076630 stack[base + 16LLU] = base;
6508- stack[base + 17LLU] = 482LLU;
6631+ stack[base + 17LLU] = 501LLU;
65096632 // arguments for call to equ
65106633 stack[base + 19LLU] = stack[base + 4]/*xid*/;
65116634 stack[base + 20LLU] = stack[base + 9]/*yid*/;
@@ -6514,22 +6637,22 @@
65146637 label = 18446744073709551600LLU; // equ
65156638 break;
65166639 }
6517- case 481LLU: // copy-back deleter (equ to equletdef)
6640+ case 500LLU: // copy-back deleter (equ to equletdef)
65186641 {
65196642 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
65206643 // copy mutable arguments back from call to equ
6521- label = 475LLU; // continue to roll stack
6644+ label = 494LLU; // continue to roll stack
65226645 break;
65236646 }
6524- case 482LLU: // return from equ to equletdef
6647+ case 501LLU: // return from equ to equletdef
65256648 {
65266649 // copy mutable arguments back from call to equ
65276650 // copy back results provided by call to equ
65286651 stack[base + 14] = stack[base + 18LLU];
65296652 // call and from equletdef
6530- stack[base + 15LLU] = 483LLU/*throw to this address*/;
6653+ stack[base + 15LLU] = 502LLU/*throw to this address*/;
65316654 stack[base + 16LLU] = base;
6532- stack[base + 17LLU] = 484LLU;
6655+ stack[base + 17LLU] = 503LLU;
65336656 // arguments for call to and
65346657 stack[base + 19LLU] = stack[base + 13]/*result*/;
65356658 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6538,22 +6661,22 @@
65386661 label = 18446744073709551613LLU; // and
65396662 break;
65406663 }
6541- case 483LLU: // copy-back deleter (and to equletdef)
6664+ case 502LLU: // copy-back deleter (and to equletdef)
65426665 {
65436666 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
65446667 // copy mutable arguments back from call to and
6545- label = 475LLU; // continue to roll stack
6668+ label = 494LLU; // continue to roll stack
65466669 break;
65476670 }
6548- case 484LLU: // return from and to equletdef
6671+ case 503LLU: // return from and to equletdef
65496672 {
65506673 // copy mutable arguments back from call to and
65516674 // copy back results provided by call to and
65526675 stack[base + 13] = stack[base + 18LLU];
65536676 // call equ from equletdef
6554- stack[base + 15LLU] = 485LLU/*throw to this address*/;
6677+ stack[base + 15LLU] = 504LLU/*throw to this address*/;
65556678 stack[base + 16LLU] = base;
6556- stack[base + 17LLU] = 486LLU;
6679+ stack[base + 17LLU] = 505LLU;
65576680 // arguments for call to equ
65586681 stack[base + 19LLU] = stack[base + 5]/*xindex*/;
65596682 stack[base + 20LLU] = stack[base + 10]/*yindex*/;
@@ -6562,22 +6685,22 @@
65626685 label = 18446744073709551600LLU; // equ
65636686 break;
65646687 }
6565- case 485LLU: // copy-back deleter (equ to equletdef)
6688+ case 504LLU: // copy-back deleter (equ to equletdef)
65666689 {
65676690 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
65686691 // copy mutable arguments back from call to equ
6569- label = 475LLU; // continue to roll stack
6692+ label = 494LLU; // continue to roll stack
65706693 break;
65716694 }
6572- case 486LLU: // return from equ to equletdef
6695+ case 505LLU: // return from equ to equletdef
65736696 {
65746697 // copy mutable arguments back from call to equ
65756698 // copy back results provided by call to equ
65766699 stack[base + 14] = stack[base + 18LLU];
65776700 // call and from equletdef
6578- stack[base + 15LLU] = 487LLU/*throw to this address*/;
6701+ stack[base + 15LLU] = 506LLU/*throw to this address*/;
65796702 stack[base + 16LLU] = base;
6580- stack[base + 17LLU] = 488LLU;
6703+ stack[base + 17LLU] = 507LLU;
65816704 // arguments for call to and
65826705 stack[base + 19LLU] = stack[base + 13]/*result*/;
65836706 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6586,22 +6709,22 @@
65866709 label = 18446744073709551613LLU; // and
65876710 break;
65886711 }
6589- case 487LLU: // copy-back deleter (and to equletdef)
6712+ case 506LLU: // copy-back deleter (and to equletdef)
65906713 {
65916714 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
65926715 // copy mutable arguments back from call to and
6593- label = 475LLU; // continue to roll stack
6716+ label = 494LLU; // continue to roll stack
65946717 break;
65956718 }
6596- case 488LLU: // return from and to equletdef
6719+ case 507LLU: // return from and to equletdef
65976720 {
65986721 // copy mutable arguments back from call to and
65996722 // copy back results provided by call to and
66006723 stack[base + 13] = stack[base + 18LLU];
66016724 // call equ from equletdef
6602- stack[base + 15LLU] = 489LLU/*throw to this address*/;
6725+ stack[base + 15LLU] = 508LLU/*throw to this address*/;
66036726 stack[base + 16LLU] = base;
6604- stack[base + 17LLU] = 490LLU;
6727+ stack[base + 17LLU] = 509LLU;
66056728 // arguments for call to equ
66066729 stack[base + 19LLU] = stack[base + 6]/*xmutable*/;
66076730 stack[base + 20LLU] = stack[base + 11]/*ymutable*/;
@@ -6610,22 +6733,22 @@
66106733 label = 18446744073709551600LLU; // equ
66116734 break;
66126735 }
6613- case 489LLU: // copy-back deleter (equ to equletdef)
6736+ case 508LLU: // copy-back deleter (equ to equletdef)
66146737 {
66156738 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
66166739 // copy mutable arguments back from call to equ
6617- label = 475LLU; // continue to roll stack
6740+ label = 494LLU; // continue to roll stack
66186741 break;
66196742 }
6620- case 490LLU: // return from equ to equletdef
6743+ case 509LLU: // return from equ to equletdef
66216744 {
66226745 // copy mutable arguments back from call to equ
66236746 // copy back results provided by call to equ
66246747 stack[base + 14] = stack[base + 18LLU];
66256748 // call and from equletdef
6626- stack[base + 15LLU] = 491LLU/*throw to this address*/;
6749+ stack[base + 15LLU] = 510LLU/*throw to this address*/;
66276750 stack[base + 16LLU] = base;
6628- stack[base + 17LLU] = 492LLU;
6751+ stack[base + 17LLU] = 511LLU;
66296752 // arguments for call to and
66306753 stack[base + 19LLU] = stack[base + 13]/*result*/;
66316754 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6634,22 +6757,22 @@
66346757 label = 18446744073709551613LLU; // and
66356758 break;
66366759 }
6637- case 491LLU: // copy-back deleter (and to equletdef)
6760+ case 510LLU: // copy-back deleter (and to equletdef)
66386761 {
66396762 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66406763 // copy mutable arguments back from call to and
6641- label = 475LLU; // continue to roll stack
6764+ label = 494LLU; // continue to roll stack
66426765 break;
66436766 }
6644- case 492LLU: // return from and to equletdef
6767+ case 511LLU: // return from and to equletdef
66456768 {
66466769 // copy mutable arguments back from call to and
66476770 // copy back results provided by call to and
66486771 stack[base + 13] = stack[base + 18LLU];
66496772 // call equ from equletdef
6650- stack[base + 15LLU] = 493LLU/*throw to this address*/;
6773+ stack[base + 15LLU] = 512LLU/*throw to this address*/;
66516774 stack[base + 16LLU] = base;
6652- stack[base + 17LLU] = 494LLU;
6775+ stack[base + 17LLU] = 513LLU;
66536776 // arguments for call to equ
66546777 stack[base + 19LLU] = stack[base + 7]/*xsubstruct*/;
66556778 stack[base + 20LLU] = stack[base + 12]/*ysubstruct*/;
@@ -6658,22 +6781,22 @@
66586781 label = 18446744073709551600LLU; // equ
66596782 break;
66606783 }
6661- case 493LLU: // copy-back deleter (equ to equletdef)
6784+ case 512LLU: // copy-back deleter (equ to equletdef)
66626785 {
66636786 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (equ to equletdef)\n");
66646787 // copy mutable arguments back from call to equ
6665- label = 475LLU; // continue to roll stack
6788+ label = 494LLU; // continue to roll stack
66666789 break;
66676790 }
6668- case 494LLU: // return from equ to equletdef
6791+ case 513LLU: // return from equ to equletdef
66696792 {
66706793 // copy mutable arguments back from call to equ
66716794 // copy back results provided by call to equ
66726795 stack[base + 14] = stack[base + 18LLU];
66736796 // call and from equletdef
6674- stack[base + 15LLU] = 495LLU/*throw to this address*/;
6797+ stack[base + 15LLU] = 514LLU/*throw to this address*/;
66756798 stack[base + 16LLU] = base;
6676- stack[base + 17LLU] = 496LLU;
6799+ stack[base + 17LLU] = 515LLU;
66776800 // arguments for call to and
66786801 stack[base + 19LLU] = stack[base + 13]/*result*/;
66796802 stack[base + 20LLU] = stack[base + 14]/*isequal*/;
@@ -6682,35 +6805,35 @@
66826805 label = 18446744073709551613LLU; // and
66836806 break;
66846807 }
6685- case 495LLU: // copy-back deleter (and to equletdef)
6808+ case 514LLU: // copy-back deleter (and to equletdef)
66866809 {
66876810 fprintf(stderr, "in function equletdef: unrolling stack, copy-back (and to equletdef)\n");
66886811 // copy mutable arguments back from call to and
6689- label = 475LLU; // continue to roll stack
6812+ label = 494LLU; // continue to roll stack
66906813 break;
66916814 }
6692- case 496LLU: // return from and to equletdef
6815+ case 515LLU: // return from and to equletdef
66936816 {
66946817 // copy mutable arguments back from call to and
66956818 // copy back results provided by call to and
66966819 stack[base + 13] = stack[base + 18LLU];
6697- label = 498LLU; // skip deleter
6820+ label = 517LLU; // skip deleter
66986821 break;
66996822 }
6700- case 497LLU: // deleter
6823+ case 516LLU: // deleter
67016824 {
67026825 // throw from equletdef
67036826 if(!stack[base + 0])
67046827 {
67056828 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
67076830 break;
67086831 }
67096832 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
67116834 break;
67126835 }
6713- case 498LLU: // skipped deleter
6836+ case 517LLU: // skipped deleter
67146837 {
67156838 stack[base + 0] = stack[base + 13]/*result*/;
67166839 ((uint64_t **)(stack[base + 2]))[1][4] = stack[base + 12];
@@ -6723,15 +6846,30 @@
67236846 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 5];
67246847 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
67256848 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
6726- label = 471LLU; // case complete
6849+ label = 489LLU; // case complete
67276850 break;
67286851 }
6729- case 472LLU: // try next case
6852+ case 491LLU: // copy-back deleter (switch)
67306853 {
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+ {
67316869 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
67326870 exit(-1);
67336871 }
6734- case 471LLU: // completed switch
6872+ case 489LLU: // completed switch
67356873 {
67366874 // return from equletdef
67376875 label = stack[base - 1];
@@ -6738,7 +6876,7 @@
67386876 base = stack[base - 2];
67396877 break;
67406878 }
6741- case 500LLU: // function copyletdef failed
6879+ case 519LLU: // function copyletdef failed
67426880 {
67436881 fprintf(stderr, "function copyletdef failed\n");
67446882 label = stack[base - 3];
@@ -6745,13 +6883,13 @@
67456883 base = stack[base - 2];
67466884 break;
67476885 }
6748- case 499LLU: // copyletdef
6886+ case 518LLU: // copyletdef
67496887 {
67506888 //#define res0 0
67516889 //#define arg0 1
67526890 if(/*letdef*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
67536891 {
6754- label = 502LLU; // jump to alternative
6892+ label = 521LLU; // jump to alternative
67556893 break;
67566894 }
67576895
@@ -6765,7 +6903,7 @@
67656903 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
67666904 if(!newstack)
67676905 {
6768- label = 500LLU; // throw: begin to unroll stack
6906+ label = 522LLU; // throw: begin to unroll stack
67696907 break;
67706908 }
67716909
@@ -6772,18 +6910,18 @@
67726910 newstack[15LLU] = 9876543210LLU; // overflow-marker
67736911 // call copytype from copyletdef
67746912 newstack[0] = (uint64_t)stack; // backup stack location
6775- newstack[1] = 503LLU;
6913+ newstack[1] = 523LLU;
67766914 newstack[2] = base;
6777- newstack[3] = 504LLU;
6915+ newstack[3] = 524LLU;
67786916 // arguments for call to copytype
67796917 newstack[5LLU] = stack[base + 2]/*type*/;
67806918 stack = newstack;
67816919 // set stack-base & callee-address
67826920 base = 4/*deloffset*/;
6783- label = 322LLU; // copytype
6921+ label = 326LLU; // copytype
67846922 break;
67856923 }
6786- case 503LLU: // copy-back deleter (copytype to copyletdef)
6924+ case 523LLU: // copy-back deleter (copytype to copyletdef)
67876925 {
67886926 fprintf(stderr, "in function copyletdef: unrolling stack, copy-back (copytype to copyletdef)\n");
67896927 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -6795,10 +6933,10 @@
67956933 }
67966934 Free(15LLU + 1, sizeof(uint64_t), stack);
67976935 stack = oldstack;
6798- label = 500LLU; // continue to unroll stack
6936+ label = 522LLU; // continue to unroll stack
67996937 break;
68006938 }
6801- case 504LLU: // return from copytype to copyletdef
6939+ case 524LLU: // return from copytype to copyletdef
68026940 {
68036941 uint64_t *oldstack = (uint64_t *)stack[0];
68046942 // copy mutable arguments back from call to copytype
@@ -6811,16 +6949,16 @@
68116949 }
68126950 Free(15LLU + 1, sizeof(uint64_t), stack);
68136951 stack = oldstack;
6814- label = 506LLU; // skip deleter
6952+ label = 526LLU; // skip deleter
68156953 break;
68166954 }
6817- case 505LLU: // deleter
6955+ case 525LLU: // deleter
68186956 {
68196957 // throw from copyletdef
68206958 if(!stack[base + 0])
68216959 {
68226960 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
68246962 break;
68256963 }
68266964 fprintf(stderr, "in function copyletdef: unrolling stack, variable letdef \n");
@@ -6830,28 +6968,28 @@
68306968 newstack[0] = (uint64_t)stack; // backup stack location
68316969 newstack[1] = 1234567890;
68326970 newstack[2] = base;
6833- newstack[3] = 507LLU;
6971+ newstack[3] = 527LLU;
68346972 stack = newstack;
68356973 // set stack-base & callee-address
68366974 base = 4/*deloffset*/;
6837- label = 438LLU; // ~letdef
6975+ label = 455LLU; // ~letdef
68386976 break;
68396977 }
6840- case 507LLU: // return from ~letdef to copyletdef
6978+ case 527LLU: // return from ~letdef to copyletdef
68416979 {
68426980 stack = (uint64_t *)stack[0];
68436981 // releasing toplevel container
68446982 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
68456983
6846- label = 500LLU; // continue unrolling stack, delete next variable
6984+ label = 522LLU; // continue unrolling stack, delete next variable
68476985 break;
68486986 }
6849- case 506LLU: // skipped deleter
6987+ case 526LLU: // skipped deleter
68506988 {
68516989 // construct letdef.letdef
68526990 if(!(stack[base + 0] = construct(5)))
68536991 {
6854- label = 500LLU; // throw: begin to unroll stack
6992+ label = 522LLU; // throw: begin to unroll stack
68556993 break;
68566994 }
68576995
@@ -6867,15 +7005,25 @@
68677005 ((uint64_t **)(stack[base + 1]))[1][2] = stack[base + 4];
68687006 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
68697007 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
6870- label = 501LLU; // case complete
7008+ label = 520LLU; // case complete
68717009 break;
68727010 }
6873- case 502LLU: // try next case
7011+ case 522LLU: // copy-back deleter (switch)
68747012 {
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+ {
68757023 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
68767024 exit(-1);
68777025 }
6878- case 501LLU: // completed switch
7026+ case 520LLU: // completed switch
68797027 {
68807028 // return from copyletdef
68817029 label = stack[base - 1];
@@ -6882,7 +7030,7 @@
68827030 base = stack[base - 2];
68837031 break;
68847032 }
6885- case 508LLU: // ~scope
7033+ case 528LLU: // ~scope
68867034 {
68877035 if(stack[base + 0]/*variant-nr*/ >= 1)
68887036 {
@@ -6889,23 +7037,23 @@
68897037 fprintf(stderr, "in ~scope: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
68907038 exit(-1);
68917039 }
6892- label = 508LLU + 1LLU + stack[base + 0]/*variant-nr*/;
7040+ label = 528LLU + 1LLU + stack[base + 0]/*variant-nr*/;
68937041 break;
68947042 }
6895- case 508LLU + 1LLU + 0LLU: // ~scope.scope
7043+ case 528LLU + 1LLU + 0LLU: // ~scope.scope
68967044 {
68977045 // release element deleteaddr
68987046 // release element letdefs
68997047 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[1/*element-nr*/];
69007048 // delete list
6901- label = 510LLU; // start to repeat
7049+ label = 530LLU; // start to repeat
69027050 break;
69037051 }
6904- case 510LLU: // repeat from here
7052+ case 530LLU: // repeat from here
69057053 {
69067054 if(!stack[base + 0])
69077055 {
6908- label = 511LLU; // break loop
7056+ label = 531LLU; // break loop
69097057 break;
69107058 }
69117059
@@ -6916,14 +7064,14 @@
69167064 newstack[0] = (uint64_t)stack; // backup stack location
69177065 newstack[1] = 1234567890;
69187066 newstack[2] = base;
6919- newstack[3] = 512LLU;
7067+ newstack[3] = 532LLU;
69207068 stack = newstack;
69217069 // set stack-base & callee-address
69227070 base = 4/*deloffset*/;
6923- label = 438LLU; // ~letdef
7071+ label = 455LLU; // ~letdef
69247072 break;
69257073 }
6926- case 512LLU: // return from ~letdef to scope
7074+ case 532LLU: // return from ~letdef to scope
69277075 {
69287076 stack = (uint64_t *)stack[0];
69297077 // releasing toplevel container
@@ -6934,10 +7082,10 @@
69347082 stack[base + 0] = (uint64_t)list->next;
69357083 Free(1, sizeof(struct listnode), list);
69367084 }
6937- label = 510LLU; // repeat
7085+ label = 530LLU; // repeat
69387086 break;
69397087 }
6940- case 511LLU: // loop finished
7088+ case 531LLU: // loop finished
69417089 {
69427090 // release variant container
69437091 Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
@@ -6945,7 +7093,7 @@
69457093 base = stack[base - 2];
69467094 break;
69477095 }
6948- case 514LLU: // function emptyscope failed
7096+ case 534LLU: // function emptyscope failed
69497097 {
69507098 fprintf(stderr, "function emptyscope failed\n");
69517099 label = stack[base - 3];
@@ -6952,50 +7100,50 @@
69527100 base = stack[base - 2];
69537101 break;
69547102 }
6955- case 513LLU: // emptyscope
7103+ case 533LLU: // emptyscope
69567104 {
69577105 //#define res0 0
6958- label = 516LLU; // skip deleter
7106+ label = 536LLU; // skip deleter
69597107 break;
69607108 }
6961- case 515LLU: // deleter
7109+ case 535LLU: // deleter
69627110 {
69637111 // throw from emptyscope
69647112 if(!stack[base + 1])
69657113 {
69667114 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
69687116 break;
69697117 }
69707118 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
69727120 break;
69737121 }
6974- case 516LLU: // skipped deleter
7122+ case 536LLU: // skipped deleter
69757123 {
69767124 stack[base + 1] = 1234567890;
6977- label = 518LLU; // skip deleter
7125+ label = 538LLU; // skip deleter
69787126 break;
69797127 }
6980- case 517LLU: // deleter
7128+ case 537LLU: // deleter
69817129 {
69827130 // throw from emptyscope
69837131 if(!stack[base + 2])
69847132 {
69857133 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
69877135 break;
69887136 }
69897137 fprintf(stderr, "in function emptyscope: unrolling stack, variable [letdef] \n");
69907138 // delete list
6991- label = 519LLU; // start to repeat
7139+ label = 539LLU; // start to repeat
69927140 break;
69937141 }
6994- case 519LLU: // repeat from here
7142+ case 539LLU: // repeat from here
69957143 {
69967144 if(!stack[base + 2])
69977145 {
6998- label = 520LLU; // break loop
7146+ label = 540LLU; // break loop
69997147 break;
70007148 }
70017149
@@ -7006,14 +7154,14 @@
70067154 newstack[0] = (uint64_t)stack; // backup stack location
70077155 newstack[1] = 1234567890;
70087156 newstack[2] = base;
7009- newstack[3] = 521LLU;
7157+ newstack[3] = 541LLU;
70107158 stack = newstack;
70117159 // set stack-base & callee-address
70127160 base = 4/*deloffset*/;
7013- label = 438LLU; // ~letdef
7161+ label = 455LLU; // ~letdef
70147162 break;
70157163 }
7016- case 521LLU: // return from ~letdef to emptyscope
7164+ case 541LLU: // return from ~letdef to emptyscope
70177165 {
70187166 stack = (uint64_t *)stack[0];
70197167 // releasing toplevel container
@@ -7024,27 +7172,27 @@
70247172 stack[base + 2] = (uint64_t)list->next;
70257173 Free(1, sizeof(struct listnode), list);
70267174 }
7027- label = 519LLU; // repeat
7175+ label = 539LLU; // repeat
70287176 break;
70297177 }
7030- case 520LLU: // loop finished
7178+ case 540LLU: // loop finished
70317179 {
7032- label = 515LLU; // continue unrolling stack, delete next variable
7180+ label = 535LLU; // continue unrolling stack, delete next variable
70337181 break;
70347182 }
7035- case 518LLU: // skipped deleter
7183+ case 538LLU: // skipped deleter
70367184 {
70377185 stack[base + 2] = 0;
7038- label = 523LLU; // skip deleter
7186+ label = 543LLU; // skip deleter
70397187 break;
70407188 }
7041- case 522LLU: // deleter
7189+ case 542LLU: // deleter
70427190 {
70437191 // throw from emptyscope
70447192 if(!stack[base + 0])
70457193 {
70467194 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
70487196 break;
70497197 }
70507198 fprintf(stderr, "in function emptyscope: unrolling stack, variable scope \n");
@@ -7054,28 +7202,28 @@
70547202 newstack[0] = (uint64_t)stack; // backup stack location
70557203 newstack[1] = 1234567890;
70567204 newstack[2] = base;
7057- newstack[3] = 524LLU;
7205+ newstack[3] = 544LLU;
70587206 stack = newstack;
70597207 // set stack-base & callee-address
70607208 base = 4/*deloffset*/;
7061- label = 508LLU; // ~scope
7209+ label = 528LLU; // ~scope
70627210 break;
70637211 }
7064- case 524LLU: // return from ~scope to emptyscope
7212+ case 544LLU: // return from ~scope to emptyscope
70657213 {
70667214 stack = (uint64_t *)stack[0];
70677215 // releasing toplevel container
70687216 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
70697217
7070- label = 517LLU; // continue unrolling stack, delete next variable
7218+ label = 537LLU; // continue unrolling stack, delete next variable
70717219 break;
70727220 }
7073- case 523LLU: // skipped deleter
7221+ case 543LLU: // skipped deleter
70747222 {
70757223 // construct scope.scope
70767224 if(!(stack[base + 0] = construct(2)))
70777225 {
7078- label = 517LLU; // throw: begin to unroll stack
7226+ label = 537LLU; // throw: begin to unroll stack
70797227 break;
70807228 }
70817229
@@ -7088,7 +7236,7 @@
70887236 base = stack[base - 2];
70897237 break;
70907238 }
7091- case 526LLU: // function chainscope failed
7239+ case 546LLU: // function chainscope failed
70927240 {
70937241 fprintf(stderr, "function chainscope failed\n");
70947242 label = stack[base - 3];
@@ -7095,32 +7243,32 @@
70957243 base = stack[base - 2];
70967244 break;
70977245 }
7098- case 525LLU: // chainscope
7246+ case 545LLU: // chainscope
70997247 {
71007248 //#define res0 0
71017249 //#define arg0 1
7102- label = 528LLU; // skip deleter
7250+ label = 548LLU; // skip deleter
71037251 break;
71047252 }
7105- case 527LLU: // deleter
7253+ case 547LLU: // deleter
71067254 {
71077255 // throw from chainscope
71087256 if(!stack[base + 2])
71097257 {
71107258 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
71127260 break;
71137261 }
71147262 fprintf(stderr, "in function chainscope: unrolling stack, variable [letdef] \n");
71157263 // delete list
7116- label = 529LLU; // start to repeat
7264+ label = 549LLU; // start to repeat
71177265 break;
71187266 }
7119- case 529LLU: // repeat from here
7267+ case 549LLU: // repeat from here
71207268 {
71217269 if(!stack[base + 2])
71227270 {
7123- label = 530LLU; // break loop
7271+ label = 550LLU; // break loop
71247272 break;
71257273 }
71267274
@@ -7131,14 +7279,14 @@
71317279 newstack[0] = (uint64_t)stack; // backup stack location
71327280 newstack[1] = 1234567890;
71337281 newstack[2] = base;
7134- newstack[3] = 531LLU;
7282+ newstack[3] = 551LLU;
71357283 stack = newstack;
71367284 // set stack-base & callee-address
71377285 base = 4/*deloffset*/;
7138- label = 438LLU; // ~letdef
7286+ label = 455LLU; // ~letdef
71397287 break;
71407288 }
7141- case 531LLU: // return from ~letdef to chainscope
7289+ case 551LLU: // return from ~letdef to chainscope
71427290 {
71437291 stack = (uint64_t *)stack[0];
71447292 // releasing toplevel container
@@ -7149,27 +7297,27 @@
71497297 stack[base + 2] = (uint64_t)list->next;
71507298 Free(1, sizeof(struct listnode), list);
71517299 }
7152- label = 529LLU; // repeat
7300+ label = 549LLU; // repeat
71537301 break;
71547302 }
7155- case 530LLU: // loop finished
7303+ case 550LLU: // loop finished
71567304 {
7157- label = 526LLU; // continue unrolling stack, delete next variable
7305+ label = 546LLU; // continue unrolling stack, delete next variable
71587306 break;
71597307 }
7160- case 528LLU: // skipped deleter
7308+ case 548LLU: // skipped deleter
71617309 {
71627310 stack[base + 2] = 0;
7163- label = 533LLU; // skip deleter
7311+ label = 553LLU; // skip deleter
71647312 break;
71657313 }
7166- case 532LLU: // deleter
7314+ case 552LLU: // deleter
71677315 {
71687316 // throw from chainscope
71697317 if(!stack[base + 0])
71707318 {
71717319 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
71737321 break;
71747322 }
71757323 fprintf(stderr, "in function chainscope: unrolling stack, variable scope \n");
@@ -7179,28 +7327,28 @@
71797327 newstack[0] = (uint64_t)stack; // backup stack location
71807328 newstack[1] = 1234567890;
71817329 newstack[2] = base;
7182- newstack[3] = 534LLU;
7330+ newstack[3] = 554LLU;
71837331 stack = newstack;
71847332 // set stack-base & callee-address
71857333 base = 4/*deloffset*/;
7186- label = 508LLU; // ~scope
7334+ label = 528LLU; // ~scope
71877335 break;
71887336 }
7189- case 534LLU: // return from ~scope to chainscope
7337+ case 554LLU: // return from ~scope to chainscope
71907338 {
71917339 stack = (uint64_t *)stack[0];
71927340 // releasing toplevel container
71937341 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
71947342
7195- label = 527LLU; // continue unrolling stack, delete next variable
7343+ label = 547LLU; // continue unrolling stack, delete next variable
71967344 break;
71977345 }
7198- case 533LLU: // skipped deleter
7346+ case 553LLU: // skipped deleter
71997347 {
72007348 // construct scope.scope
72017349 if(!(stack[base + 0] = construct(2)))
72027350 {
7203- label = 527LLU; // throw: begin to unroll stack
7351+ label = 547LLU; // throw: begin to unroll stack
72047352 break;
72057353 }
72067354
@@ -7213,7 +7361,7 @@
72137361 base = stack[base - 2];
72147362 break;
72157363 }
7216- case 536LLU: // function linkscope failed
7364+ case 556LLU: // function linkscope failed
72177365 {
72187366 fprintf(stderr, "function linkscope failed\n");
72197367 label = stack[base - 3];
@@ -7220,13 +7368,13 @@
72207368 base = stack[base - 2];
72217369 break;
72227370 }
7223- case 535LLU: // linkscope
7371+ case 555LLU: // linkscope
72247372 {
72257373 //#define res0 0
72267374 //#define arg0 1
72277375 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
72287376 {
7229- label = 538LLU; // jump to alternative
7377+ label = 558LLU; // jump to alternative
72307378 break;
72317379 }
72327380
@@ -7235,24 +7383,24 @@
72357383
72367384 // case
72377385 // call chainscope from linkscope
7238- stack[base + 4LLU] = 539LLU/*throw to this address*/;
7386+ stack[base + 4LLU] = 560LLU/*throw to this address*/;
72397387 stack[base + 5LLU] = base;
7240- stack[base + 6LLU] = 540LLU;
7388+ stack[base + 6LLU] = 561LLU;
72417389 // arguments for call to chainscope
72427390 stack[base + 8LLU] = stack[base + 2]/*labelthrow*/;
72437391 // set stack-base & callee-address
72447392 base += 7LLU;
7245- label = 525LLU; // chainscope
7393+ label = 545LLU; // chainscope
72467394 break;
72477395 }
7248- case 539LLU: // copy-back deleter (chainscope to linkscope)
7396+ case 560LLU: // copy-back deleter (chainscope to linkscope)
72497397 {
72507398 fprintf(stderr, "in function linkscope: unrolling stack, copy-back (chainscope to linkscope)\n");
72517399 // copy mutable arguments back from call to chainscope
7252- label = 536LLU; // continue to roll stack
7400+ label = 559LLU; // continue to roll stack
72537401 break;
72547402 }
7255- case 540LLU: // return from chainscope to linkscope
7403+ case 561LLU: // return from chainscope to linkscope
72567404 {
72577405 // copy mutable arguments back from call to chainscope
72587406 // copy back results provided by call to chainscope
@@ -7259,15 +7407,22 @@
72597407 stack[base + 0] = stack[base + 7LLU];
72607408 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
72617409 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7262- label = 537LLU; // case complete
7410+ label = 557LLU; // case complete
72637411 break;
72647412 }
7265- case 538LLU: // try next case
7413+ case 559LLU: // copy-back deleter (switch)
72667414 {
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+ {
72677422 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
72687423 exit(-1);
72697424 }
7270- case 537LLU: // completed switch
7425+ case 557LLU: // completed switch
72717426 {
72727427 // return from linkscope
72737428 label = stack[base - 1];
@@ -7274,7 +7429,7 @@
72747429 base = stack[base - 2];
72757430 break;
72767431 }
7277- case 542LLU: // function getdeladdr failed
7432+ case 563LLU: // function getdeladdr failed
72787433 {
72797434 fprintf(stderr, "function getdeladdr failed\n");
72807435 label = stack[base - 3];
@@ -7281,13 +7436,13 @@
72817436 base = stack[base - 2];
72827437 break;
72837438 }
7284- case 541LLU: // getdeladdr
7439+ case 562LLU: // getdeladdr
72857440 {
72867441 //#define res0 0
72877442 //#define arg0 1
72887443 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
72897444 {
7290- label = 544LLU; // jump to alternative
7445+ label = 565LLU; // jump to alternative
72917446 break;
72927447 }
72937448
@@ -7295,36 +7450,43 @@
72957450 /*letdefs*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*scope*/))[1][1]/*letdefs*/;
72967451
72977452 // case
7298- label = 546LLU; // skip deleter
7453+ label = 568LLU; // skip deleter
72997454 break;
73007455 }
7301- case 545LLU: // deleter
7456+ case 567LLU: // deleter
73027457 {
73037458 // throw from getdeladdr
73047459 if(!stack[base + 0])
73057460 {
73067461 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
73087463 break;
73097464 }
73107465 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
73127467 break;
73137468 }
7314- case 546LLU: // skipped deleter
7469+ case 568LLU: // skipped deleter
73157470 {
73167471 stack[base + 0] = stack[base + 2]/*labelthrow*/;
73177472 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
73187473 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
7319- label = 543LLU; // case complete
7474+ label = 564LLU; // case complete
73207475 break;
73217476 }
7322- case 544LLU: // try next case
7477+ case 566LLU: // copy-back deleter (switch)
73237478 {
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+ {
73247486 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
73257487 exit(-1);
73267488 }
7327- case 543LLU: // completed switch
7489+ case 564LLU: // completed switch
73287490 {
73297491 // return from getdeladdr
73307492 label = stack[base - 1];
@@ -7331,7 +7493,7 @@
73317493 base = stack[base - 2];
73327494 break;
73337495 }
7334- case 548LLU: // function existslet failed
7496+ case 570LLU: // function existslet failed
73357497 {
73367498 fprintf(stderr, "function existslet failed\n");
73377499 label = stack[base - 3];
@@ -7338,39 +7500,39 @@
73387500 base = stack[base - 2];
73397501 break;
73407502 }
7341- case 547LLU: // existslet
7503+ case 569LLU: // existslet
73427504 {
73437505 //#define res0 0
73447506 //#define arg0 1
73457507 //#define arg1 2
7346- label = 550LLU; // skip deleter
7508+ label = 572LLU; // skip deleter
73477509 break;
73487510 }
7349- case 549LLU: // deleter
7511+ case 571LLU: // deleter
73507512 {
73517513 // throw from existslet
73527514 if(!stack[base + 3])
73537515 {
73547516 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
73567518 break;
73577519 }
73587520 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
73607522 break;
73617523 }
7362- case 550LLU: // skipped deleter
7524+ case 572LLU: // skipped deleter
73637525 {
73647526 stack[base + 3] = 0;
73657527 flippedassign(stack[base + 1]/*letdefs*/, &stack[base + 4]);
7366- label = 551LLU; // start to repeat
7528+ label = 573LLU; // start to repeat
73677529 break;
73687530 }
7369- case 551LLU: // repeat from here
7531+ case 573LLU: // repeat from here
73707532 {
73717533 if(!stack[base + 4])
73727534 {
7373- label = 552LLU; // break loop
7535+ label = 574LLU; // break loop
73747536 break;
73757537 }
73767538
@@ -7380,19 +7542,19 @@
73807542 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
73817543 if(!stack[base + 3]/*found*/)
73827544 {
7383- label = 553LLU; // jump to alternative
7545+ label = 575LLU; // jump to alternative
73847546 break;
73857547 }
73867548
73877549 // consequent
7388- label = 554LLU; // consequent complete
7550+ label = 576LLU; // consequent complete
73897551 break;
73907552 }
7391- case 553LLU: // alternative
7553+ case 575LLU: // alternative
73927554 {
73937555 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
73947556 {
7395- label = 556LLU; // jump to alternative
7557+ label = 578LLU; // jump to alternative
73967558 break;
73977559 }
73987560
@@ -7404,9 +7566,9 @@
74047566
74057567 // case
74067568 // call equ from existslet
7407- stack[base + 12LLU] = 557LLU/*throw to this address*/;
7569+ stack[base + 12LLU] = 580LLU/*throw to this address*/;
74087570 stack[base + 13LLU] = base;
7409- stack[base + 14LLU] = 558LLU;
7571+ stack[base + 14LLU] = 581LLU;
74107572 // arguments for call to equ
74117573 stack[base + 16LLU] = stack[base + 8]/*curid*/;
74127574 stack[base + 17LLU] = stack[base + 2]/*id*/;
@@ -7415,14 +7577,14 @@
74157577 label = 18446744073709551600LLU; // equ
74167578 break;
74177579 }
7418- case 557LLU: // copy-back deleter (equ to existslet)
7580+ case 580LLU: // copy-back deleter (equ to existslet)
74197581 {
74207582 fprintf(stderr, "in function existslet: unrolling stack, copy-back (equ to existslet)\n");
74217583 // copy mutable arguments back from call to equ
7422- label = 549LLU; // continue to roll stack
7584+ label = 579LLU; // continue to roll stack
74237585 break;
74247586 }
7425- case 558LLU: // return from equ to existslet
7587+ case 581LLU: // return from equ to existslet
74267588 {
74277589 // copy mutable arguments back from call to equ
74287590 // copy back results provided by call to equ
@@ -7432,44 +7594,54 @@
74327594 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 9];
74337595 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
74347596 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
7435- label = 555LLU; // case complete
7597+ label = 577LLU; // case complete
74367598 break;
74377599 }
7438- case 556LLU: // try next case
7600+ case 579LLU: // copy-back deleter (switch)
74397601 {
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+ {
74407612 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
74417613 exit(-1);
74427614 }
7443- case 555LLU: // completed switch
7615+ case 577LLU: // completed switch
74447616 {
7445- label = 554LLU; // alternative complete
7617+ label = 576LLU; // alternative complete
74467618 break;
74477619 }
7448- case 554LLU: // completed if-then-else
7620+ case 576LLU: // completed if-then-else
74497621 {
74507622 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
7451- label = 551LLU; // repeat
7623+ label = 573LLU; // repeat
74527624 break;
74537625 }
7454- case 552LLU: // loop finished
7626+ case 574LLU: // loop finished
74557627 {
7456- label = 560LLU; // skip deleter
7628+ label = 583LLU; // skip deleter
74577629 break;
74587630 }
7459- case 559LLU: // deleter
7631+ case 582LLU: // deleter
74607632 {
74617633 // throw from existslet
74627634 if(!stack[base + 0])
74637635 {
74647636 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
74667638 break;
74677639 }
74687640 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
74707642 break;
74717643 }
7472- case 560LLU: // skipped deleter
7644+ case 583LLU: // skipped deleter
74737645 {
74747646 stack[base + 0] = stack[base + 3]/*found*/;
74757647 // return from existslet
@@ -7477,7 +7649,7 @@
74777649 base = stack[base - 2];
74787650 break;
74797651 }
7480- case 562LLU: // function FindLetNew failed
7652+ case 585LLU: // function FindLetNew failed
74817653 {
74827654 fprintf(stderr, "function FindLetNew failed\n");
74837655 label = stack[base - 3];
@@ -7484,7 +7656,7 @@
74847656 base = stack[base - 2];
74857657 break;
74867658 }
7487- case 561LLU: // FindLetNew
7659+ case 584LLU: // FindLetNew
74887660 {
74897661 //#define res0 0
74907662 //#define arg0 1
@@ -7492,87 +7664,87 @@
74927664 //#define arg2 3
74937665 //#define arg3 4
74947666 // call mkletdummy from FindLetNew
7495- stack[base + 6LLU] = 563LLU/*throw to this address*/;
7667+ stack[base + 6LLU] = 586LLU/*throw to this address*/;
74967668 stack[base + 7LLU] = base;
7497- stack[base + 8LLU] = 564LLU;
7669+ stack[base + 8LLU] = 587LLU;
74987670 // arguments for call to mkletdummy
74997671 // set stack-base & callee-address
75007672 base += 9LLU;
7501- label = 441LLU; // mkletdummy
7673+ label = 458LLU; // mkletdummy
75027674 break;
75037675 }
7504- case 563LLU: // copy-back deleter (mkletdummy to FindLetNew)
7676+ case 586LLU: // copy-back deleter (mkletdummy to FindLetNew)
75057677 {
75067678 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (mkletdummy to FindLetNew)\n");
75077679 // copy mutable arguments back from call to mkletdummy
7508- label = 562LLU; // continue to roll stack
7680+ label = 585LLU; // continue to roll stack
75097681 break;
75107682 }
7511- case 564LLU: // return from mkletdummy to FindLetNew
7683+ case 587LLU: // return from mkletdummy to FindLetNew
75127684 {
75137685 // copy mutable arguments back from call to mkletdummy
75147686 // copy back results provided by call to mkletdummy
75157687 stack[base + 5] = stack[base + 9LLU];
7516- label = 566LLU; // skip deleter
7688+ label = 589LLU; // skip deleter
75177689 break;
75187690 }
7519- case 565LLU: // deleter
7691+ case 588LLU: // deleter
75207692 {
75217693 // throw from FindLetNew
75227694 if(!stack[base + 6])
75237695 {
75247696 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
75267698 break;
75277699 }
75287700 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
75307702 break;
75317703 }
7532- case 566LLU: // skipped deleter
7704+ case 589LLU: // skipped deleter
75337705 {
75347706 stack[base + 6] = 0;
7535- label = 568LLU; // skip deleter
7707+ label = 591LLU; // skip deleter
75367708 break;
75377709 }
7538- case 567LLU: // deleter
7710+ case 590LLU: // deleter
75397711 {
75407712 // throw from FindLetNew
75417713 if(!stack[base + 7])
75427714 {
75437715 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
75457717 break;
75467718 }
75477719 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
75497721 break;
75507722 }
7551- case 568LLU: // skipped deleter
7723+ case 591LLU: // skipped deleter
75527724 {
75537725 stack[base + 7] = 0;
7554- label = 570LLU; // skip deleter
7726+ label = 593LLU; // skip deleter
75557727 break;
75567728 }
7557- case 569LLU: // deleter
7729+ case 592LLU: // deleter
75587730 {
75597731 // throw from FindLetNew
75607732 if(!stack[base + 8])
75617733 {
75627734 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
75647736 break;
75657737 }
75667738 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
75687740 break;
75697741 }
7570- case 570LLU: // skipped deleter
7742+ case 593LLU: // skipped deleter
75717743 {
75727744 stack[base + 8] = 0;
75737745 if(/*scope*/0 != ((uint64_t *)(stack[base + 4]/*SCOPE*/))[0])
75747746 {
7575- label = 572LLU; // jump to alternative
7747+ label = 595LLU; // jump to alternative
75767748 break;
75777749 }
75787750
@@ -7581,14 +7753,14 @@
75817753
75827754 // case
75837755 flippedassign(stack[base + 10]/*scope*/, &stack[base + 11]);
7584- label = 573LLU; // start to repeat
7756+ label = 597LLU; // start to repeat
75857757 break;
75867758 }
7587- case 573LLU: // repeat from here
7759+ case 597LLU: // repeat from here
75887760 {
75897761 if(!stack[base + 11])
75907762 {
7591- label = 574LLU; // break loop
7763+ label = 598LLU; // break loop
75927764 break;
75937765 }
75947766
@@ -7598,19 +7770,19 @@
75987770 stack[base + 11] = (uint64_t)(((const struct listnode *)(stack[base + 11]))->next);
75997771 if(!stack[base + 8]/*found*/)
76007772 {
7601- label = 575LLU; // jump to alternative
7773+ label = 599LLU; // jump to alternative
76027774 break;
76037775 }
76047776
76057777 // consequent
7606- label = 576LLU; // consequent complete
7778+ label = 600LLU; // consequent complete
76077779 break;
76087780 }
7609- case 575LLU: // alternative
7781+ case 599LLU: // alternative
76107782 {
76117783 if(/*letdef*/0 != ((uint64_t *)(stack[base + 12]/*letdef*/))[0])
76127784 {
7613- label = 578LLU; // jump to alternative
7785+ label = 602LLU; // jump to alternative
76147786 break;
76157787 }
76167788
@@ -7622,9 +7794,9 @@
76227794
76237795 // case
76247796 // call equ from FindLetNew
7625- stack[base + 19LLU] = 579LLU/*throw to this address*/;
7797+ stack[base + 19LLU] = 604LLU/*throw to this address*/;
76267798 stack[base + 20LLU] = base;
7627- stack[base + 21LLU] = 580LLU;
7799+ stack[base + 21LLU] = 605LLU;
76287800 // arguments for call to equ
76297801 stack[base + 23LLU] = stack[base + 15]/*curid*/;
76307802 stack[base + 24LLU] = stack[base + 2]/*id*/;
@@ -7633,14 +7805,14 @@
76337805 label = 18446744073709551600LLU; // equ
76347806 break;
76357807 }
7636- case 579LLU: // copy-back deleter (equ to FindLetNew)
7808+ case 604LLU: // copy-back deleter (equ to FindLetNew)
76377809 {
76387810 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
76397811 // copy mutable arguments back from call to equ
7640- label = 569LLU; // continue to roll stack
7812+ label = 603LLU; // continue to roll stack
76417813 break;
76427814 }
7643- case 580LLU: // return from equ to FindLetNew
7815+ case 605LLU: // return from equ to FindLetNew
76447816 {
76457817 // copy mutable arguments back from call to equ
76467818 // copy back results provided by call to equ
@@ -7647,30 +7819,30 @@
76477819 stack[base + 8] = stack[base + 22LLU];
76487820 if(!stack[base + 8]/*found*/)
76497821 {
7650- label = 581LLU; // jump to alternative
7822+ label = 606LLU; // jump to alternative
76517823 break;
76527824 }
76537825
76547826 // consequent
76557827 // call copyletdef from FindLetNew
7656- stack[base + 20LLU] = 583LLU/*throw to this address*/;
7828+ stack[base + 20LLU] = 608LLU/*throw to this address*/;
76577829 stack[base + 21LLU] = base;
7658- stack[base + 22LLU] = 584LLU;
7830+ stack[base + 22LLU] = 609LLU;
76597831 // arguments for call to copyletdef
76607832 stack[base + 24LLU] = stack[base + 12]/*letdef*/;
76617833 // set stack-base & callee-address
76627834 base += 23LLU;
7663- label = 499LLU; // copyletdef
7835+ label = 518LLU; // copyletdef
76647836 break;
76657837 }
7666- case 583LLU: // copy-back deleter (copyletdef to FindLetNew)
7838+ case 608LLU: // copy-back deleter (copyletdef to FindLetNew)
76677839 {
76687840 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
76697841 // copy mutable arguments back from call to copyletdef
7670- label = 569LLU; // continue to roll stack
7842+ label = 603LLU; // continue to roll stack
76717843 break;
76727844 }
7673- case 584LLU: // return from copyletdef to FindLetNew
7845+ case 609LLU: // return from copyletdef to FindLetNew
76747846 {
76757847 // copy mutable arguments back from call to copyletdef
76767848 // copy back results provided by call to copyletdef
@@ -7682,28 +7854,28 @@
76827854 newstack[0] = (uint64_t)stack; // backup stack location
76837855 newstack[1] = 1234567890;
76847856 newstack[2] = base;
7685- newstack[3] = 585LLU;
7857+ newstack[3] = 610LLU;
76867858 stack = newstack;
76877859 // set stack-base & callee-address
76887860 base = 4/*deloffset*/;
7689- label = 438LLU; // ~letdef
7861+ label = 455LLU; // ~letdef
76907862 break;
76917863 }
7692- case 585LLU: // return from ~letdef to FindLetNew
7864+ case 610LLU: // return from ~letdef to FindLetNew
76937865 {
76947866 stack = (uint64_t *)stack[0];
76957867 // releasing toplevel container
76967868 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 19] - sizeof(uint64_t) * 4));
76977869
7698- label = 582LLU; // consequent complete
7870+ label = 607LLU; // consequent complete
76997871 break;
77007872 }
7701- case 581LLU: // alternative
7873+ case 606LLU: // alternative
77027874 {
7703- label = 582LLU; // alternative complete
7875+ label = 607LLU; // alternative complete
77047876 break;
77057877 }
7706- case 582LLU: // completed if-then-else
7878+ case 607LLU: // completed if-then-else
77077879 {
77087880 ((uint64_t **)(stack[base + 12]))[1][4] = stack[base + 18];
77097881 ((uint64_t **)(stack[base + 12]))[1][3] = stack[base + 17];
@@ -7710,60 +7882,77 @@
77107882 ((uint64_t **)(stack[base + 12]))[1][2] = stack[base + 16];
77117883 ((uint64_t **)(stack[base + 12]))[1][1] = stack[base + 15];
77127884 ((uint64_t **)(stack[base + 12]))[1][0] = stack[base + 14];
7713- label = 577LLU; // case complete
7885+ label = 601LLU; // case complete
77147886 break;
77157887 }
7716- case 578LLU: // try next case
7888+ case 603LLU: // copy-back deleter (switch)
77177889 {
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+ {
77187900 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
77197901 exit(-1);
77207902 }
7721- case 577LLU: // completed switch
7903+ case 601LLU: // completed switch
77227904 {
7723- label = 576LLU; // alternative complete
7905+ label = 600LLU; // alternative complete
77247906 break;
77257907 }
7726- case 576LLU: // completed if-then-else
7908+ case 600LLU: // completed if-then-else
77277909 {
77287910 ((struct listnode *)(stack[base + 13]/*previous*/))->data = stack[base + 12];
7729- label = 573LLU; // repeat
7911+ label = 597LLU; // repeat
77307912 break;
77317913 }
7732- case 574LLU: // loop finished
7914+ case 598LLU: // loop finished
77337915 {
77347916 ((uint64_t **)(stack[base + 4]))[1][1] = stack[base + 10];
77357917 ((uint64_t **)(stack[base + 4]))[1][0] = stack[base + 9];
7736- label = 571LLU; // case complete
7918+ label = 594LLU; // case complete
77377919 break;
77387920 }
7739- case 572LLU: // try next case
7921+ case 596LLU: // copy-back deleter (switch)
77407922 {
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+ {
77417930 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
77427931 exit(-1);
77437932 }
7744- case 571LLU: // completed switch
7933+ case 594LLU: // completed switch
77457934 {
77467935 if(!stack[base + 8]/*found*/)
77477936 {
7748- label = 586LLU; // jump to alternative
7937+ label = 611LLU; // jump to alternative
77497938 break;
77507939 }
77517940
77527941 // consequent
7753- label = 587LLU; // consequent complete
7942+ label = 612LLU; // consequent complete
77547943 break;
77557944 }
7756- case 586LLU: // alternative
7945+ case 611LLU: // alternative
77577946 {
77587947 flippedassign(stack[base + 3]/*scopes*/, &stack[base + 9]);
7759- label = 588LLU; // start to repeat
7948+ label = 613LLU; // start to repeat
77607949 break;
77617950 }
7762- case 588LLU: // repeat from here
7951+ case 613LLU: // repeat from here
77637952 {
77647953 if(!stack[base + 9])
77657954 {
7766- label = 589LLU; // break loop
7955+ label = 614LLU; // break loop
77677956 break;
77687957 }
77697958
@@ -7773,19 +7962,19 @@
77737962 stack[base + 9] = (uint64_t)(((const struct listnode *)(stack[base + 9]))->next);
77747963 if(!stack[base + 8]/*found*/)
77757964 {
7776- label = 590LLU; // jump to alternative
7965+ label = 615LLU; // jump to alternative
77777966 break;
77787967 }
77797968
77807969 // consequent
7781- label = 591LLU; // consequent complete
7970+ label = 616LLU; // consequent complete
77827971 break;
77837972 }
7784- case 590LLU: // alternative
7973+ case 615LLU: // alternative
77857974 {
77867975 if(/*scope*/0 != ((uint64_t *)(stack[base + 10]/*SCOPE*/))[0])
77877976 {
7788- label = 593LLU; // jump to alternative
7977+ label = 618LLU; // jump to alternative
77897978 break;
77907979 }
77917980
@@ -7794,14 +7983,14 @@
77947983
77957984 // case
77967985 flippedassign(stack[base + 13]/*scope*/, &stack[base + 14]);
7797- label = 594LLU; // start to repeat
7986+ label = 620LLU; // start to repeat
77987987 break;
77997988 }
7800- case 594LLU: // repeat from here
7989+ case 620LLU: // repeat from here
78017990 {
78027991 if(!stack[base + 14])
78037992 {
7804- label = 595LLU; // break loop
7993+ label = 621LLU; // break loop
78057994 break;
78067995 }
78077996
@@ -7811,19 +8000,19 @@
78118000 stack[base + 14] = (uint64_t)(((const struct listnode *)(stack[base + 14]))->next);
78128001 if(!stack[base + 8]/*found*/)
78138002 {
7814- label = 596LLU; // jump to alternative
8003+ label = 622LLU; // jump to alternative
78158004 break;
78168005 }
78178006
78188007 // consequent
7819- label = 597LLU; // consequent complete
8008+ label = 623LLU; // consequent complete
78208009 break;
78218010 }
7822- case 596LLU: // alternative
8011+ case 622LLU: // alternative
78238012 {
78248013 if(!stack[base + 15]/*letdef*/)
78258014 {
7826- label = 598LLU; // jump to alternative
8015+ label = 624LLU; // jump to alternative
78278016 break;
78288017 }
78298018
@@ -7830,7 +8019,7 @@
78308019 // consequent
78318020 if(/*letdef*/0 != ((uint64_t *)(stack[base + 15]/*letdef*/))[0])
78328021 {
7833- label = 601LLU; // jump to alternative
8022+ label = 627LLU; // jump to alternative
78348023 break;
78358024 }
78368025
@@ -7842,9 +8031,9 @@
78428031
78438032 // case
78448033 // call equ from FindLetNew
7845- stack[base + 22LLU] = 602LLU/*throw to this address*/;
8034+ stack[base + 22LLU] = 629LLU/*throw to this address*/;
78468035 stack[base + 23LLU] = base;
7847- stack[base + 24LLU] = 603LLU;
8036+ stack[base + 24LLU] = 630LLU;
78488037 // arguments for call to equ
78498038 stack[base + 26LLU] = stack[base + 18]/*curid*/;
78508039 stack[base + 27LLU] = stack[base + 2]/*id*/;
@@ -7853,14 +8042,14 @@
78538042 label = 18446744073709551600LLU; // equ
78548043 break;
78558044 }
7856- case 602LLU: // copy-back deleter (equ to FindLetNew)
8045+ case 629LLU: // copy-back deleter (equ to FindLetNew)
78578046 {
78588047 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (equ to FindLetNew)\n");
78598048 // copy mutable arguments back from call to equ
7860- label = 569LLU; // continue to roll stack
8049+ label = 628LLU; // continue to roll stack
78618050 break;
78628051 }
7863- case 603LLU: // return from equ to FindLetNew
8052+ case 630LLU: // return from equ to FindLetNew
78648053 {
78658054 // copy mutable arguments back from call to equ
78668055 // copy back results provided by call to equ
@@ -7867,30 +8056,30 @@
78678056 stack[base + 8] = stack[base + 25LLU];
78688057 if(!stack[base + 8]/*found*/)
78698058 {
7870- label = 604LLU; // jump to alternative
8059+ label = 631LLU; // jump to alternative
78718060 break;
78728061 }
78738062
78748063 // consequent
78758064 // call copyletdef from FindLetNew
7876- stack[base + 23LLU] = 606LLU/*throw to this address*/;
8065+ stack[base + 23LLU] = 633LLU/*throw to this address*/;
78778066 stack[base + 24LLU] = base;
7878- stack[base + 25LLU] = 607LLU;
8067+ stack[base + 25LLU] = 634LLU;
78798068 // arguments for call to copyletdef
78808069 stack[base + 27LLU] = stack[base + 15]/*letdef*/;
78818070 // set stack-base & callee-address
78828071 base += 26LLU;
7883- label = 499LLU; // copyletdef
8072+ label = 518LLU; // copyletdef
78848073 break;
78858074 }
7886- case 606LLU: // copy-back deleter (copyletdef to FindLetNew)
8075+ case 633LLU: // copy-back deleter (copyletdef to FindLetNew)
78878076 {
78888077 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (copyletdef to FindLetNew)\n");
78898078 // copy mutable arguments back from call to copyletdef
7890- label = 569LLU; // continue to roll stack
8079+ label = 628LLU; // continue to roll stack
78918080 break;
78928081 }
7893- case 607LLU: // return from copyletdef to FindLetNew
8082+ case 634LLU: // return from copyletdef to FindLetNew
78948083 {
78958084 // copy mutable arguments back from call to copyletdef
78968085 // copy back results provided by call to copyletdef
@@ -7902,28 +8091,28 @@
79028091 newstack[0] = (uint64_t)stack; // backup stack location
79038092 newstack[1] = 1234567890;
79048093 newstack[2] = base;
7905- newstack[3] = 608LLU;
8094+ newstack[3] = 635LLU;
79068095 stack = newstack;
79078096 // set stack-base & callee-address
79088097 base = 4/*deloffset*/;
7909- label = 438LLU; // ~letdef
8098+ label = 455LLU; // ~letdef
79108099 break;
79118100 }
7912- case 608LLU: // return from ~letdef to FindLetNew
8101+ case 635LLU: // return from ~letdef to FindLetNew
79138102 {
79148103 stack = (uint64_t *)stack[0];
79158104 // releasing toplevel container
79168105 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 22] - sizeof(uint64_t) * 4));
79178106
7918- label = 605LLU; // consequent complete
8107+ label = 632LLU; // consequent complete
79198108 break;
79208109 }
7921- case 604LLU: // alternative
8110+ case 631LLU: // alternative
79228111 {
7923- label = 605LLU; // alternative complete
8112+ label = 632LLU; // alternative complete
79248113 break;
79258114 }
7926- case 605LLU: // completed if-then-else
8115+ case 632LLU: // completed if-then-else
79278116 {
79288117 ((uint64_t **)(stack[base + 15]))[1][4] = stack[base + 21];
79298118 ((uint64_t **)(stack[base + 15]))[1][3] = stack[base + 20];
@@ -7930,78 +8119,95 @@
79308119 ((uint64_t **)(stack[base + 15]))[1][2] = stack[base + 19];
79318120 ((uint64_t **)(stack[base + 15]))[1][1] = stack[base + 18];
79328121 ((uint64_t **)(stack[base + 15]))[1][0] = stack[base + 17];
7933- label = 600LLU; // case complete
8122+ label = 626LLU; // case complete
79348123 break;
79358124 }
7936- case 601LLU: // try next case
8125+ case 628LLU: // copy-back deleter (switch)
79378126 {
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+ {
79388137 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
79398138 exit(-1);
79408139 }
7941- case 600LLU: // completed switch
8140+ case 626LLU: // completed switch
79428141 {
7943- label = 599LLU; // consequent complete
8142+ label = 625LLU; // consequent complete
79448143 break;
79458144 }
7946- case 598LLU: // alternative
8145+ case 624LLU: // alternative
79478146 {
79488147 fprintf(stderr, "%s", "INTERNAL ERROR empty scope\n");
7949- label = 599LLU; // alternative complete
8148+ label = 625LLU; // alternative complete
79508149 break;
79518150 }
7952- case 599LLU: // completed if-then-else
8151+ case 625LLU: // completed if-then-else
79538152 {
7954- label = 597LLU; // alternative complete
8153+ label = 623LLU; // alternative complete
79558154 break;
79568155 }
7957- case 597LLU: // completed if-then-else
8156+ case 623LLU: // completed if-then-else
79588157 {
79598158 ((struct listnode *)(stack[base + 16]/*previous*/))->data = stack[base + 15];
7960- label = 594LLU; // repeat
8159+ label = 620LLU; // repeat
79618160 break;
79628161 }
7963- case 595LLU: // loop finished
8162+ case 621LLU: // loop finished
79648163 {
79658164 ((uint64_t **)(stack[base + 10]))[1][1] = stack[base + 13];
79668165 ((uint64_t **)(stack[base + 10]))[1][0] = stack[base + 12];
7967- label = 592LLU; // case complete
8166+ label = 617LLU; // case complete
79688167 break;
79698168 }
7970- case 593LLU: // try next case
8169+ case 619LLU: // copy-back deleter (switch)
79718170 {
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+ {
79728178 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
79738179 exit(-1);
79748180 }
7975- case 592LLU: // completed switch
8181+ case 617LLU: // completed switch
79768182 {
7977- label = 591LLU; // alternative complete
8183+ label = 616LLU; // alternative complete
79788184 break;
79798185 }
7980- case 591LLU: // completed if-then-else
8186+ case 616LLU: // completed if-then-else
79818187 {
79828188 ((struct listnode *)(stack[base + 11]/*previous*/))->data = stack[base + 10];
7983- label = 588LLU; // repeat
8189+ label = 613LLU; // repeat
79848190 break;
79858191 }
7986- case 589LLU: // loop finished
8192+ case 614LLU: // loop finished
79878193 {
79888194 if(!stack[base + 8]/*found*/)
79898195 {
7990- label = 609LLU; // jump to alternative
8196+ label = 636LLU; // jump to alternative
79918197 break;
79928198 }
79938199
79948200 // consequent
7995- label = 610LLU; // consequent complete
8201+ label = 637LLU; // consequent complete
79968202 break;
79978203 }
7998- case 609LLU: // alternative
8204+ case 636LLU: // alternative
79998205 {
80008206 fprintf(stderr, "%s", "in function ");
80018207 // call reportid from FindLetNew
8002- stack[base + 12LLU] = 611LLU/*throw to this address*/;
8208+ stack[base + 12LLU] = 638LLU/*throw to this address*/;
80038209 stack[base + 13LLU] = base;
8004- stack[base + 14LLU] = 612LLU;
8210+ stack[base + 14LLU] = 639LLU;
80058211 // arguments for call to reportid
80068212 stack[base + 15LLU] = stack[base + 1]/*fnid*/;
80078213 // set stack-base & callee-address
@@ -8009,22 +8215,22 @@
80098215 label = 18446744073709551586LLU; // reportid
80108216 break;
80118217 }
8012- case 611LLU: // copy-back deleter (reportid to FindLetNew)
8218+ case 638LLU: // copy-back deleter (reportid to FindLetNew)
80138219 {
80148220 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
80158221 // copy mutable arguments back from call to reportid
8016- label = 569LLU; // continue to roll stack
8222+ label = 592LLU; // continue to roll stack
80178223 break;
80188224 }
8019- case 612LLU: // return from reportid to FindLetNew
8225+ case 639LLU: // return from reportid to FindLetNew
80208226 {
80218227 // copy mutable arguments back from call to reportid
80228228 fprintf(stderr, "%s", ": ");
80238229 fprintf(stderr, "%s", "variable ");
80248230 // call reportid from FindLetNew
8025- stack[base + 12LLU] = 613LLU/*throw to this address*/;
8231+ stack[base + 12LLU] = 640LLU/*throw to this address*/;
80268232 stack[base + 13LLU] = base;
8027- stack[base + 14LLU] = 614LLU;
8233+ stack[base + 14LLU] = 641LLU;
80288234 // arguments for call to reportid
80298235 stack[base + 15LLU] = stack[base + 2]/*id*/;
80308236 // set stack-base & callee-address
@@ -8032,38 +8238,38 @@
80328238 label = 18446744073709551586LLU; // reportid
80338239 break;
80348240 }
8035- case 613LLU: // copy-back deleter (reportid to FindLetNew)
8241+ case 640LLU: // copy-back deleter (reportid to FindLetNew)
80368242 {
80378243 fprintf(stderr, "in function FindLetNew: unrolling stack, copy-back (reportid to FindLetNew)\n");
80388244 // copy mutable arguments back from call to reportid
8039- label = 569LLU; // continue to roll stack
8245+ label = 592LLU; // continue to roll stack
80408246 break;
80418247 }
8042- case 614LLU: // return from reportid to FindLetNew
8248+ case 641LLU: // return from reportid to FindLetNew
80438249 {
80448250 // copy mutable arguments back from call to reportid
80458251 fprintf(stderr, "%s", " not in scope\n");
80468252 exit(-1);
8047- label = 610LLU; // alternative complete
8253+ label = 637LLU; // alternative complete
80488254 break;
80498255 }
8050- case 610LLU: // completed if-then-else
8256+ case 637LLU: // completed if-then-else
80518257 {
8052- label = 587LLU; // alternative complete
8258+ label = 612LLU; // alternative complete
80538259 break;
80548260 }
8055- case 587LLU: // completed if-then-else
8261+ case 612LLU: // completed if-then-else
80568262 {
8057- label = 616LLU; // skip deleter
8263+ label = 643LLU; // skip deleter
80588264 break;
80598265 }
8060- case 615LLU: // deleter
8266+ case 642LLU: // deleter
80618267 {
80628268 // throw from FindLetNew
80638269 if(!stack[base + 0])
80648270 {
80658271 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
80678273 break;
80688274 }
80698275 fprintf(stderr, "in function FindLetNew: unrolling stack, variable letdef \n");
@@ -8073,23 +8279,23 @@
80738279 newstack[0] = (uint64_t)stack; // backup stack location
80748280 newstack[1] = 1234567890;
80758281 newstack[2] = base;
8076- newstack[3] = 617LLU;
8282+ newstack[3] = 644LLU;
80778283 stack = newstack;
80788284 // set stack-base & callee-address
80798285 base = 4/*deloffset*/;
8080- label = 438LLU; // ~letdef
8286+ label = 455LLU; // ~letdef
80818287 break;
80828288 }
8083- case 617LLU: // return from ~letdef to FindLetNew
8289+ case 644LLU: // return from ~letdef to FindLetNew
80848290 {
80858291 stack = (uint64_t *)stack[0];
80868292 // releasing toplevel container
80878293 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
80888294
8089- label = 569LLU; // continue unrolling stack, delete next variable
8295+ label = 592LLU; // continue unrolling stack, delete next variable
80908296 break;
80918297 }
8092- case 616LLU: // skipped deleter
8298+ case 643LLU: // skipped deleter
80938299 {
80948300 INIT(&stack[base + 0], &stack[base + 5]/*result*/);
80958301 // return from FindLetNew
@@ -8097,7 +8303,7 @@
80978303 base = stack[base - 2];
80988304 break;
80998305 }
8100- case 619LLU: // function getlettype failed
8306+ case 646LLU: // function getlettype failed
81018307 {
81028308 fprintf(stderr, "function getlettype failed\n");
81038309 label = stack[base - 3];
@@ -8104,7 +8310,7 @@
81048310 base = stack[base - 2];
81058311 break;
81068312 }
8107- case 618LLU: // getlettype
8313+ case 645LLU: // getlettype
81088314 {
81098315 //#define res0 0
81108316 //#define arg0 1
@@ -8112,9 +8318,9 @@
81128318 //#define arg2 3
81138319 //#define arg3 4
81148320 // call FindLetNew from getlettype
8115- stack[base + 6LLU] = 620LLU/*throw to this address*/;
8321+ stack[base + 6LLU] = 647LLU/*throw to this address*/;
81168322 stack[base + 7LLU] = base;
8117- stack[base + 8LLU] = 621LLU;
8323+ stack[base + 8LLU] = 648LLU;
81188324 // arguments for call to FindLetNew
81198325 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
81208326 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8122,17 +8328,17 @@
81228328 stack[base + 13LLU] = stack[base + 4]/*scope*/;
81238329 // set stack-base & callee-address
81248330 base += 9LLU;
8125- label = 561LLU; // FindLetNew
8331+ label = 584LLU; // FindLetNew
81268332 break;
81278333 }
8128- case 620LLU: // copy-back deleter (FindLetNew to getlettype)
8334+ case 647LLU: // copy-back deleter (FindLetNew to getlettype)
81298335 {
81308336 fprintf(stderr, "in function getlettype: unrolling stack, copy-back (FindLetNew to getlettype)\n");
81318337 // copy mutable arguments back from call to FindLetNew
8132- label = 619LLU; // continue to roll stack
8338+ label = 646LLU; // continue to roll stack
81338339 break;
81348340 }
8135- case 621LLU: // return from FindLetNew to getlettype
8341+ case 648LLU: // return from FindLetNew to getlettype
81368342 {
81378343 // copy mutable arguments back from call to FindLetNew
81388344 // copy back results provided by call to FindLetNew
@@ -8139,7 +8345,7 @@
81398345 stack[base + 5] = stack[base + 9LLU];
81408346 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
81418347 {
8142- label = 623LLU; // jump to alternative
8348+ label = 650LLU; // jump to alternative
81438349 break;
81448350 }
81458351
@@ -8153,7 +8359,7 @@
81538359 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
81548360 if(!newstack)
81558361 {
8156- label = 619LLU; // throw: begin to unroll stack
8362+ label = 651LLU; // throw: begin to unroll stack
81578363 break;
81588364 }
81598365
@@ -8160,18 +8366,18 @@
81608366 newstack[15LLU] = 9876543210LLU; // overflow-marker
81618367 // call copytype from getlettype
81628368 newstack[0] = (uint64_t)stack; // backup stack location
8163- newstack[1] = 624LLU;
8369+ newstack[1] = 652LLU;
81648370 newstack[2] = base;
8165- newstack[3] = 625LLU;
8371+ newstack[3] = 653LLU;
81668372 // arguments for call to copytype
81678373 newstack[5LLU] = stack[base + 6]/*type*/;
81688374 stack = newstack;
81698375 // set stack-base & callee-address
81708376 base = 4/*deloffset*/;
8171- label = 322LLU; // copytype
8377+ label = 326LLU; // copytype
81728378 break;
81738379 }
8174- case 624LLU: // copy-back deleter (copytype to getlettype)
8380+ case 652LLU: // copy-back deleter (copytype to getlettype)
81758381 {
81768382 fprintf(stderr, "in function getlettype: unrolling stack, copy-back (copytype to getlettype)\n");
81778383 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -8183,10 +8389,10 @@
81838389 }
81848390 Free(15LLU + 1, sizeof(uint64_t), stack);
81858391 stack = oldstack;
8186- label = 619LLU; // continue to unroll stack
8392+ label = 651LLU; // continue to unroll stack
81878393 break;
81888394 }
8189- case 625LLU: // return from copytype to getlettype
8395+ case 653LLU: // return from copytype to getlettype
81908396 {
81918397 uint64_t *oldstack = (uint64_t *)stack[0];
81928398 // copy mutable arguments back from call to copytype
@@ -8204,15 +8410,25 @@
82048410 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
82058411 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
82068412 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8207- label = 622LLU; // case complete
8413+ label = 649LLU; // case complete
82088414 break;
82098415 }
8210- case 623LLU: // try next case
8416+ case 651LLU: // copy-back deleter (switch)
82118417 {
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+ {
82128428 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
82138429 exit(-1);
82148430 }
8215- case 622LLU: // completed switch
8431+ case 649LLU: // completed switch
82168432 {
82178433
82188434 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8220,14 +8436,14 @@
82208436 newstack[0] = (uint64_t)stack; // backup stack location
82218437 newstack[1] = 1234567890;
82228438 newstack[2] = base;
8223- newstack[3] = 626LLU;
8439+ newstack[3] = 654LLU;
82248440 stack = newstack;
82258441 // set stack-base & callee-address
82268442 base = 4/*deloffset*/;
8227- label = 438LLU; // ~letdef
8443+ label = 455LLU; // ~letdef
82288444 break;
82298445 }
8230- case 626LLU: // return from ~letdef to getlettype
8446+ case 654LLU: // return from ~letdef to getlettype
82318447 {
82328448 stack = (uint64_t *)stack[0];
82338449 // releasing toplevel container
@@ -8238,7 +8454,7 @@
82388454 base = stack[base - 2];
82398455 break;
82408456 }
8241- case 628LLU: // function findletidx failed
8457+ case 656LLU: // function findletidx failed
82428458 {
82438459 fprintf(stderr, "function findletidx failed\n");
82448460 label = stack[base - 3];
@@ -8245,7 +8461,7 @@
82458461 base = stack[base - 2];
82468462 break;
82478463 }
8248- case 627LLU: // findletidx
8464+ case 655LLU: // findletidx
82498465 {
82508466 //#define res0 0
82518467 //#define arg0 1
@@ -8253,9 +8469,9 @@
82538469 //#define arg2 3
82548470 //#define arg3 4
82558471 // call FindLetNew from findletidx
8256- stack[base + 6LLU] = 629LLU/*throw to this address*/;
8472+ stack[base + 6LLU] = 657LLU/*throw to this address*/;
82578473 stack[base + 7LLU] = base;
8258- stack[base + 8LLU] = 630LLU;
8474+ stack[base + 8LLU] = 658LLU;
82598475 // arguments for call to FindLetNew
82608476 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
82618477 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8263,17 +8479,17 @@
82638479 stack[base + 13LLU] = stack[base + 4]/*scope*/;
82648480 // set stack-base & callee-address
82658481 base += 9LLU;
8266- label = 561LLU; // FindLetNew
8482+ label = 584LLU; // FindLetNew
82678483 break;
82688484 }
8269- case 629LLU: // copy-back deleter (FindLetNew to findletidx)
8485+ case 657LLU: // copy-back deleter (FindLetNew to findletidx)
82708486 {
82718487 fprintf(stderr, "in function findletidx: unrolling stack, copy-back (FindLetNew to findletidx)\n");
82728488 // copy mutable arguments back from call to FindLetNew
8273- label = 628LLU; // continue to roll stack
8489+ label = 656LLU; // continue to roll stack
82748490 break;
82758491 }
8276- case 630LLU: // return from FindLetNew to findletidx
8492+ case 658LLU: // return from FindLetNew to findletidx
82778493 {
82788494 // copy mutable arguments back from call to FindLetNew
82798495 // copy back results provided by call to FindLetNew
@@ -8280,7 +8496,7 @@
82808496 stack[base + 5] = stack[base + 9LLU];
82818497 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
82828498 {
8283- label = 632LLU; // jump to alternative
8499+ label = 660LLU; // jump to alternative
82848500 break;
82858501 }
82868502
@@ -8291,23 +8507,23 @@
82918507 /*substruct*/stack[base + 10] = ((uint64_t **)(stack[base + 5]/*letdef*/))[1][4]/*substruct*/;
82928508
82938509 // case
8294- label = 634LLU; // skip deleter
8510+ label = 663LLU; // skip deleter
82958511 break;
82968512 }
8297- case 633LLU: // deleter
8513+ case 662LLU: // deleter
82988514 {
82998515 // throw from findletidx
83008516 if(!stack[base + 0])
83018517 {
83028518 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
83048520 break;
83058521 }
83068522 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
83088524 break;
83098525 }
8310- case 634LLU: // skipped deleter
8526+ case 663LLU: // skipped deleter
83118527 {
83128528 stack[base + 0] = stack[base + 8]/*index*/;
83138529 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
@@ -8315,15 +8531,25 @@
83158531 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
83168532 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
83178533 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8318- label = 631LLU; // case complete
8534+ label = 659LLU; // case complete
83198535 break;
83208536 }
8321- case 632LLU: // try next case
8537+ case 661LLU: // copy-back deleter (switch)
83228538 {
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+ {
83238549 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
83248550 exit(-1);
83258551 }
8326- case 631LLU: // completed switch
8552+ case 659LLU: // completed switch
83278553 {
83288554
83298555 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8331,14 +8557,14 @@
83318557 newstack[0] = (uint64_t)stack; // backup stack location
83328558 newstack[1] = 1234567890;
83338559 newstack[2] = base;
8334- newstack[3] = 635LLU;
8560+ newstack[3] = 664LLU;
83358561 stack = newstack;
83368562 // set stack-base & callee-address
83378563 base = 4/*deloffset*/;
8338- label = 438LLU; // ~letdef
8564+ label = 455LLU; // ~letdef
83398565 break;
83408566 }
8341- case 635LLU: // return from ~letdef to findletidx
8567+ case 664LLU: // return from ~letdef to findletidx
83428568 {
83438569 stack = (uint64_t *)stack[0];
83448570 // releasing toplevel container
@@ -8349,7 +8575,7 @@
83498575 base = stack[base - 2];
83508576 break;
83518577 }
8352- case 637LLU: // function findletmut failed
8578+ case 666LLU: // function findletmut failed
83538579 {
83548580 fprintf(stderr, "function findletmut failed\n");
83558581 label = stack[base - 3];
@@ -8356,7 +8582,7 @@
83568582 base = stack[base - 2];
83578583 break;
83588584 }
8359- case 636LLU: // findletmut
8585+ case 665LLU: // findletmut
83608586 {
83618587 //#define res0 0
83628588 //#define arg0 1
@@ -8364,9 +8590,9 @@
83648590 //#define arg2 3
83658591 //#define arg3 4
83668592 // call FindLetNew from findletmut
8367- stack[base + 6LLU] = 638LLU/*throw to this address*/;
8593+ stack[base + 6LLU] = 667LLU/*throw to this address*/;
83688594 stack[base + 7LLU] = base;
8369- stack[base + 8LLU] = 639LLU;
8595+ stack[base + 8LLU] = 668LLU;
83708596 // arguments for call to FindLetNew
83718597 stack[base + 10LLU] = stack[base + 1]/*fnid*/;
83728598 stack[base + 11LLU] = stack[base + 2]/*id*/;
@@ -8374,17 +8600,17 @@
83748600 stack[base + 13LLU] = stack[base + 4]/*scope*/;
83758601 // set stack-base & callee-address
83768602 base += 9LLU;
8377- label = 561LLU; // FindLetNew
8603+ label = 584LLU; // FindLetNew
83788604 break;
83798605 }
8380- case 638LLU: // copy-back deleter (FindLetNew to findletmut)
8606+ case 667LLU: // copy-back deleter (FindLetNew to findletmut)
83818607 {
83828608 fprintf(stderr, "in function findletmut: unrolling stack, copy-back (FindLetNew to findletmut)\n");
83838609 // copy mutable arguments back from call to FindLetNew
8384- label = 637LLU; // continue to roll stack
8610+ label = 666LLU; // continue to roll stack
83858611 break;
83868612 }
8387- case 639LLU: // return from FindLetNew to findletmut
8613+ case 668LLU: // return from FindLetNew to findletmut
83888614 {
83898615 // copy mutable arguments back from call to FindLetNew
83908616 // copy back results provided by call to FindLetNew
@@ -8391,7 +8617,7 @@
83918617 stack[base + 5] = stack[base + 9LLU];
83928618 if(/*letdef*/0 != ((uint64_t *)(stack[base + 5]/*letdef*/))[0])
83938619 {
8394- label = 641LLU; // jump to alternative
8620+ label = 670LLU; // jump to alternative
83958621 break;
83968622 }
83978623
@@ -8402,23 +8628,23 @@
84028628 /*substruct*/stack[base + 10] = ((uint64_t **)(stack[base + 5]/*letdef*/))[1][4]/*substruct*/;
84038629
84048630 // case
8405- label = 643LLU; // skip deleter
8631+ label = 673LLU; // skip deleter
84068632 break;
84078633 }
8408- case 642LLU: // deleter
8634+ case 672LLU: // deleter
84098635 {
84108636 // throw from findletmut
84118637 if(!stack[base + 0])
84128638 {
84138639 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
84158641 break;
84168642 }
84178643 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
84198645 break;
84208646 }
8421- case 643LLU: // skipped deleter
8647+ case 673LLU: // skipped deleter
84228648 {
84238649 stack[base + 0] = stack[base + 9]/*mutable*/;
84248650 ((uint64_t **)(stack[base + 5]))[1][4] = stack[base + 10];
@@ -8426,15 +8652,25 @@
84268652 ((uint64_t **)(stack[base + 5]))[1][2] = stack[base + 8];
84278653 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 7];
84288654 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 6];
8429- label = 640LLU; // case complete
8655+ label = 669LLU; // case complete
84308656 break;
84318657 }
8432- case 641LLU: // try next case
8658+ case 671LLU: // copy-back deleter (switch)
84338659 {
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+ {
84348670 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
84358671 exit(-1);
84368672 }
8437- case 640LLU: // completed switch
8673+ case 669LLU: // completed switch
84388674 {
84398675
84408676 uint64_t *newstack = (uint64_t *)(stack[base + 5] - sizeof(uint64_t) * 4);
@@ -8442,14 +8678,14 @@
84428678 newstack[0] = (uint64_t)stack; // backup stack location
84438679 newstack[1] = 1234567890;
84448680 newstack[2] = base;
8445- newstack[3] = 644LLU;
8681+ newstack[3] = 674LLU;
84468682 stack = newstack;
84478683 // set stack-base & callee-address
84488684 base = 4/*deloffset*/;
8449- label = 438LLU; // ~letdef
8685+ label = 455LLU; // ~letdef
84508686 break;
84518687 }
8452- case 644LLU: // return from ~letdef to findletmut
8688+ case 674LLU: // return from ~letdef to findletmut
84538689 {
84548690 stack = (uint64_t *)stack[0];
84558691 // releasing toplevel container
@@ -8460,7 +8696,7 @@
84608696 base = stack[base - 2];
84618697 break;
84628698 }
8463- case 646LLU: // function assertvar failed
8699+ case 676LLU: // function assertvar failed
84648700 {
84658701 fprintf(stderr, "function assertvar failed\n");
84668702 label = stack[base - 3];
@@ -8467,7 +8703,7 @@
84678703 base = stack[base - 2];
84688704 break;
84698705 }
8470- case 645LLU: // assertvar
8706+ case 675LLU: // assertvar
84718707 {
84728708 //#define arg0 0
84738709 //#define arg1 1
@@ -8474,9 +8710,9 @@
84748710 //#define arg2 2
84758711 //#define arg3 3
84768712 // call findletidx from assertvar
8477- stack[base + 5LLU] = 647LLU/*throw to this address*/;
8713+ stack[base + 5LLU] = 677LLU/*throw to this address*/;
84788714 stack[base + 6LLU] = base;
8479- stack[base + 7LLU] = 648LLU;
8715+ stack[base + 7LLU] = 678LLU;
84808716 // arguments for call to findletidx
84818717 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
84828718 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8484,17 +8720,17 @@
84848720 stack[base + 12LLU] = stack[base + 3]/*scope*/;
84858721 // set stack-base & callee-address
84868722 base += 8LLU;
8487- label = 627LLU; // findletidx
8723+ label = 655LLU; // findletidx
84888724 break;
84898725 }
8490- case 647LLU: // copy-back deleter (findletidx to assertvar)
8726+ case 677LLU: // copy-back deleter (findletidx to assertvar)
84918727 {
84928728 fprintf(stderr, "in function assertvar: unrolling stack, copy-back (findletidx to assertvar)\n");
84938729 // copy mutable arguments back from call to findletidx
8494- label = 646LLU; // continue to roll stack
8730+ label = 676LLU; // continue to roll stack
84958731 break;
84968732 }
8497- case 648LLU: // return from findletidx to assertvar
8733+ case 678LLU: // return from findletidx to assertvar
84988734 {
84998735 // copy mutable arguments back from call to findletidx
85008736 // copy back results provided by call to findletidx
@@ -8504,7 +8740,7 @@
85048740 base = stack[base - 2];
85058741 break;
85068742 }
8507- case 650LLU: // function emitindex failed
8743+ case 680LLU: // function emitindex failed
85088744 {
85098745 fprintf(stderr, "function emitindex failed\n");
85108746 label = stack[base - 3];
@@ -8511,7 +8747,7 @@
85118747 base = stack[base - 2];
85128748 break;
85138749 }
8514- case 649LLU: // emitindex
8750+ case 679LLU: // emitindex
85158751 {
85168752 //#define arg0 0
85178753 //#define arg1 1
@@ -8518,9 +8754,9 @@
85188754 //#define arg2 2
85198755 //#define arg3 3
85208756 // call findletidx from emitindex
8521- stack[base + 5LLU] = 651LLU/*throw to this address*/;
8757+ stack[base + 5LLU] = 681LLU/*throw to this address*/;
85228758 stack[base + 6LLU] = base;
8523- stack[base + 7LLU] = 652LLU;
8759+ stack[base + 7LLU] = 682LLU;
85248760 // arguments for call to findletidx
85258761 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
85268762 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8528,25 +8764,25 @@
85288764 stack[base + 12LLU] = stack[base + 3]/*scope*/;
85298765 // set stack-base & callee-address
85308766 base += 8LLU;
8531- label = 627LLU; // findletidx
8767+ label = 655LLU; // findletidx
85328768 break;
85338769 }
8534- case 651LLU: // copy-back deleter (findletidx to emitindex)
8770+ case 681LLU: // copy-back deleter (findletidx to emitindex)
85358771 {
85368772 fprintf(stderr, "in function emitindex: unrolling stack, copy-back (findletidx to emitindex)\n");
85378773 // copy mutable arguments back from call to findletidx
8538- label = 650LLU; // continue to roll stack
8774+ label = 680LLU; // continue to roll stack
85398775 break;
85408776 }
8541- case 652LLU: // return from findletidx to emitindex
8777+ case 682LLU: // return from findletidx to emitindex
85428778 {
85438779 // copy mutable arguments back from call to findletidx
85448780 // copy back results provided by call to findletidx
85458781 stack[base + 4] = stack[base + 8LLU];
85468782 // call printnr from emitindex
8547- stack[base + 5LLU] = 653LLU/*throw to this address*/;
8783+ stack[base + 5LLU] = 683LLU/*throw to this address*/;
85488784 stack[base + 6LLU] = base;
8549- stack[base + 7LLU] = 654LLU;
8785+ stack[base + 7LLU] = 684LLU;
85508786 // arguments for call to printnr
85518787 stack[base + 8LLU] = stack[base + 4]/*index*/;
85528788 // set stack-base & callee-address
@@ -8554,14 +8790,14 @@
85548790 label = 18446744073709551590LLU; // printnr
85558791 break;
85568792 }
8557- case 653LLU: // copy-back deleter (printnr to emitindex)
8793+ case 683LLU: // copy-back deleter (printnr to emitindex)
85588794 {
85598795 fprintf(stderr, "in function emitindex: unrolling stack, copy-back (printnr to emitindex)\n");
85608796 // copy mutable arguments back from call to printnr
8561- label = 650LLU; // continue to roll stack
8797+ label = 680LLU; // continue to roll stack
85628798 break;
85638799 }
8564- case 654LLU: // return from printnr to emitindex
8800+ case 684LLU: // return from printnr to emitindex
85658801 {
85668802 // copy mutable arguments back from call to printnr
85678803 // return from emitindex
@@ -8569,7 +8805,7 @@
85698805 base = stack[base - 2];
85708806 break;
85718807 }
8572- case 656LLU: // function emitvaridx failed
8808+ case 686LLU: // function emitvaridx failed
85738809 {
85748810 fprintf(stderr, "function emitvaridx failed\n");
85758811 label = stack[base - 3];
@@ -8576,14 +8812,14 @@
85768812 base = stack[base - 2];
85778813 break;
85788814 }
8579- case 655LLU: // emitvaridx
8815+ case 685LLU: // emitvaridx
85808816 {
85818817 //#define arg0 0
85828818 printf("%s", "stack[base + ");
85838819 // call printnr from emitvaridx
8584- stack[base + 1LLU] = 657LLU/*throw to this address*/;
8820+ stack[base + 1LLU] = 687LLU/*throw to this address*/;
85858821 stack[base + 2LLU] = base;
8586- stack[base + 3LLU] = 658LLU;
8822+ stack[base + 3LLU] = 688LLU;
85878823 // arguments for call to printnr
85888824 stack[base + 4LLU] = stack[base + 0]/*index*/;
85898825 // set stack-base & callee-address
@@ -8591,14 +8827,14 @@
85918827 label = 18446744073709551590LLU; // printnr
85928828 break;
85938829 }
8594- case 657LLU: // copy-back deleter (printnr to emitvaridx)
8830+ case 687LLU: // copy-back deleter (printnr to emitvaridx)
85958831 {
85968832 fprintf(stderr, "in function emitvaridx: unrolling stack, copy-back (printnr to emitvaridx)\n");
85978833 // copy mutable arguments back from call to printnr
8598- label = 656LLU; // continue to roll stack
8834+ label = 686LLU; // continue to roll stack
85998835 break;
86008836 }
8601- case 658LLU: // return from printnr to emitvaridx
8837+ case 688LLU: // return from printnr to emitvaridx
86028838 {
86038839 // copy mutable arguments back from call to printnr
86048840 printf("%s", "]");
@@ -8607,7 +8843,7 @@
86078843 base = stack[base - 2];
86088844 break;
86098845 }
8610- case 660LLU: // function emitvar failed
8846+ case 690LLU: // function emitvar failed
86118847 {
86128848 fprintf(stderr, "function emitvar failed\n");
86138849 label = stack[base - 3];
@@ -8614,7 +8850,7 @@
86148850 base = stack[base - 2];
86158851 break;
86168852 }
8617- case 659LLU: // emitvar
8853+ case 689LLU: // emitvar
86188854 {
86198855 //#define arg0 0
86208856 //#define arg1 1
@@ -8621,9 +8857,9 @@
86218857 //#define arg2 2
86228858 //#define arg3 3
86238859 // call findletidx from emitvar
8624- stack[base + 5LLU] = 661LLU/*throw to this address*/;
8860+ stack[base + 5LLU] = 691LLU/*throw to this address*/;
86258861 stack[base + 6LLU] = base;
8626- stack[base + 7LLU] = 662LLU;
8862+ stack[base + 7LLU] = 692LLU;
86278863 // arguments for call to findletidx
86288864 stack[base + 9LLU] = stack[base + 0]/*fnid*/;
86298865 stack[base + 10LLU] = stack[base + 1]/*id*/;
@@ -8631,47 +8867,47 @@
86318867 stack[base + 12LLU] = stack[base + 3]/*scope*/;
86328868 // set stack-base & callee-address
86338869 base += 8LLU;
8634- label = 627LLU; // findletidx
8870+ label = 655LLU; // findletidx
86358871 break;
86368872 }
8637- case 661LLU: // copy-back deleter (findletidx to emitvar)
8873+ case 691LLU: // copy-back deleter (findletidx to emitvar)
86388874 {
86398875 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (findletidx to emitvar)\n");
86408876 // copy mutable arguments back from call to findletidx
8641- label = 660LLU; // continue to roll stack
8877+ label = 690LLU; // continue to roll stack
86428878 break;
86438879 }
8644- case 662LLU: // return from findletidx to emitvar
8880+ case 692LLU: // return from findletidx to emitvar
86458881 {
86468882 // copy mutable arguments back from call to findletidx
86478883 // copy back results provided by call to findletidx
86488884 stack[base + 4] = stack[base + 8LLU];
86498885 // call emitvaridx from emitvar
8650- stack[base + 5LLU] = 663LLU/*throw to this address*/;
8886+ stack[base + 5LLU] = 693LLU/*throw to this address*/;
86518887 stack[base + 6LLU] = base;
8652- stack[base + 7LLU] = 664LLU;
8888+ stack[base + 7LLU] = 694LLU;
86538889 // arguments for call to emitvaridx
86548890 stack[base + 8LLU] = stack[base + 4]/*index*/;
86558891 // set stack-base & callee-address
86568892 base += 8LLU;
8657- label = 655LLU; // emitvaridx
8893+ label = 685LLU; // emitvaridx
86588894 break;
86598895 }
8660- case 663LLU: // copy-back deleter (emitvaridx to emitvar)
8896+ case 693LLU: // copy-back deleter (emitvaridx to emitvar)
86618897 {
86628898 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (emitvaridx to emitvar)\n");
86638899 // copy mutable arguments back from call to emitvaridx
8664- label = 660LLU; // continue to roll stack
8900+ label = 690LLU; // continue to roll stack
86658901 break;
86668902 }
8667- case 664LLU: // return from emitvaridx to emitvar
8903+ case 694LLU: // return from emitvaridx to emitvar
86688904 {
86698905 // copy mutable arguments back from call to emitvaridx
86708906 printf("%s", "/*");
86718907 // call printid from emitvar
8672- stack[base + 5LLU] = 665LLU/*throw to this address*/;
8908+ stack[base + 5LLU] = 695LLU/*throw to this address*/;
86738909 stack[base + 6LLU] = base;
8674- stack[base + 7LLU] = 666LLU;
8910+ stack[base + 7LLU] = 696LLU;
86758911 // arguments for call to printid
86768912 stack[base + 8LLU] = stack[base + 1]/*id*/;
86778913 // set stack-base & callee-address
@@ -8679,14 +8915,14 @@
86798915 label = 18446744073709551587LLU; // printid
86808916 break;
86818917 }
8682- case 665LLU: // copy-back deleter (printid to emitvar)
8918+ case 695LLU: // copy-back deleter (printid to emitvar)
86838919 {
86848920 fprintf(stderr, "in function emitvar: unrolling stack, copy-back (printid to emitvar)\n");
86858921 // copy mutable arguments back from call to printid
8686- label = 660LLU; // continue to roll stack
8922+ label = 690LLU; // continue to roll stack
86878923 break;
86888924 }
8689- case 666LLU: // return from printid to emitvar
8925+ case 696LLU: // return from printid to emitvar
86908926 {
86918927 // copy mutable arguments back from call to printid
86928928 printf("%s", "*/");
@@ -8695,7 +8931,7 @@
86958931 base = stack[base - 2];
86968932 break;
86978933 }
8698- case 668LLU: // function newvarraw failed
8934+ case 698LLU: // function newvarraw failed
86998935 {
87008936 fprintf(stderr, "function newvarraw failed\n");
87018937 label = stack[base - 3];
@@ -8702,7 +8938,7 @@
87028938 base = stack[base - 2];
87038939 break;
87048940 }
8705- case 667LLU: // newvarraw
8941+ case 697LLU: // newvarraw
87068942 {
87078943 //#define res0 0
87088944 //#define arg0 1
@@ -8714,28 +8950,28 @@
87148950 //#define arg6 7
87158951 //#define arg7 8
87168952 //#define arg8 9
8717- label = 670LLU; // skip deleter
8953+ label = 700LLU; // skip deleter
87188954 break;
87198955 }
8720- case 669LLU: // deleter
8956+ case 699LLU: // deleter
87218957 {
87228958 // throw from newvarraw
87238959 if(!stack[base + 10])
87248960 {
87258961 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
87278963 break;
87288964 }
87298965 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
87318967 break;
87328968 }
8733- case 670LLU: // skipped deleter
8969+ case 700LLU: // skipped deleter
87348970 {
87358971 stack[base + 10] = 0;
87368972 if(/*scope*/0 != ((uint64_t *)(stack[base + 8]/*scope*/))[0])
87378973 {
8738- label = 672LLU; // jump to alternative
8974+ label = 702LLU; // jump to alternative
87398975 break;
87408976 }
87418977
@@ -8743,29 +8979,29 @@
87438979 /*letdefs*/stack[base + 12] = ((uint64_t **)(stack[base + 8]/*scope*/))[1][1]/*letdefs*/;
87448980
87458981 // case
8746- label = 674LLU; // skip deleter
8982+ label = 705LLU; // skip deleter
87478983 break;
87488984 }
8749- case 673LLU: // deleter
8985+ case 704LLU: // deleter
87508986 {
87518987 // throw from newvarraw
87528988 if(!stack[base + 13])
87538989 {
87548990 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
87568992 break;
87578993 }
87588994 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
87608996 break;
87618997 }
8762- case 674LLU: // skipped deleter
8998+ case 705LLU: // skipped deleter
87638999 {
87649000 stack[base + 13] = 0;
87659001 // call add from newvarraw
8766- stack[base + 14LLU] = 675LLU/*throw to this address*/;
9002+ stack[base + 14LLU] = 706LLU/*throw to this address*/;
87679003 stack[base + 15LLU] = base;
8768- stack[base + 16LLU] = 676LLU;
9004+ stack[base + 16LLU] = 707LLU;
87699005 // arguments for call to add
87709006 stack[base + 18LLU] = stack[base + 4]/*fnrescount*/;
87719007 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -8774,22 +9010,22 @@
87749010 label = 18446744073709551605LLU; // add
87759011 break;
87769012 }
8777- case 675LLU: // copy-back deleter (add to newvarraw)
9013+ case 706LLU: // copy-back deleter (add to newvarraw)
87789014 {
87799015 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
87809016 // copy mutable arguments back from call to add
8781- label = 673LLU; // continue to roll stack
9017+ label = 704LLU; // continue to roll stack
87829018 break;
87839019 }
8784- case 676LLU: // return from add to newvarraw
9020+ case 707LLU: // return from add to newvarraw
87859021 {
87869022 // copy mutable arguments back from call to add
87879023 // copy back results provided by call to add
87889024 stack[base + 13] = stack[base + 17LLU];
87899025 // call add from newvarraw
8790- stack[base + 14LLU] = 677LLU/*throw to this address*/;
9026+ stack[base + 14LLU] = 708LLU/*throw to this address*/;
87919027 stack[base + 15LLU] = base;
8792- stack[base + 16LLU] = 678LLU;
9028+ stack[base + 16LLU] = 709LLU;
87939029 // arguments for call to add
87949030 stack[base + 18LLU] = stack[base + 5]/*fnargcount*/;
87959031 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -8798,22 +9034,22 @@
87989034 label = 18446744073709551605LLU; // add
87999035 break;
88009036 }
8801- case 677LLU: // copy-back deleter (add to newvarraw)
9037+ case 708LLU: // copy-back deleter (add to newvarraw)
88029038 {
88039039 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
88049040 // copy mutable arguments back from call to add
8805- label = 673LLU; // continue to roll stack
9041+ label = 704LLU; // continue to roll stack
88069042 break;
88079043 }
8808- case 678LLU: // return from add to newvarraw
9044+ case 709LLU: // return from add to newvarraw
88099045 {
88109046 // copy mutable arguments back from call to add
88119047 // copy back results provided by call to add
88129048 stack[base + 13] = stack[base + 17LLU];
88139049 // call add from newvarraw
8814- stack[base + 14LLU] = 679LLU/*throw to this address*/;
9050+ stack[base + 14LLU] = 710LLU/*throw to this address*/;
88159051 stack[base + 15LLU] = base;
8816- stack[base + 16LLU] = 680LLU;
9052+ stack[base + 16LLU] = 711LLU;
88179053 // arguments for call to add
88189054 stack[base + 18LLU] = stack[base + 7]/*varcount*/;
88199055 stack[base + 19LLU] = stack[base + 13]/*sum*/;
@@ -8822,14 +9058,14 @@
88229058 label = 18446744073709551605LLU; // add
88239059 break;
88249060 }
8825- case 679LLU: // copy-back deleter (add to newvarraw)
9061+ case 710LLU: // copy-back deleter (add to newvarraw)
88269062 {
88279063 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
88289064 // copy mutable arguments back from call to add
8829- label = 673LLU; // continue to roll stack
9065+ label = 704LLU; // continue to roll stack
88309066 break;
88319067 }
8832- case 680LLU: // return from add to newvarraw
9068+ case 711LLU: // return from add to newvarraw
88339069 {
88349070 // copy mutable arguments back from call to add
88359071 // copy back results provided by call to add
@@ -8838,7 +9074,7 @@
88389074 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
88399075 if(!newstack)
88409076 {
8841- label = 673LLU; // throw: begin to unroll stack
9077+ label = 704LLU; // throw: begin to unroll stack
88429078 break;
88439079 }
88449080
@@ -8845,18 +9081,18 @@
88459081 newstack[15LLU] = 9876543210LLU; // overflow-marker
88469082 // call copytype from newvarraw
88479083 newstack[0] = (uint64_t)stack; // backup stack location
8848- newstack[1] = 681LLU;
9084+ newstack[1] = 712LLU;
88499085 newstack[2] = base;
8850- newstack[3] = 682LLU;
9086+ newstack[3] = 713LLU;
88519087 // arguments for call to copytype
88529088 newstack[5LLU] = stack[base + 1]/*type*/;
88539089 stack = newstack;
88549090 // set stack-base & callee-address
88559091 base = 4/*deloffset*/;
8856- label = 322LLU; // copytype
9092+ label = 326LLU; // copytype
88579093 break;
88589094 }
8859- case 681LLU: // copy-back deleter (copytype to newvarraw)
9095+ case 712LLU: // copy-back deleter (copytype to newvarraw)
88609096 {
88619097 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (copytype to newvarraw)\n");
88629098 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -8868,10 +9104,10 @@
88689104 }
88699105 Free(15LLU + 1, sizeof(uint64_t), stack);
88709106 stack = oldstack;
8871- label = 673LLU; // continue to unroll stack
9107+ label = 704LLU; // continue to unroll stack
88729108 break;
88739109 }
8874- case 682LLU: // return from copytype to newvarraw
9110+ case 713LLU: // return from copytype to newvarraw
88759111 {
88769112 uint64_t *oldstack = (uint64_t *)stack[0];
88779113 // copy mutable arguments back from call to copytype
@@ -8884,16 +9120,16 @@
88849120 }
88859121 Free(15LLU + 1, sizeof(uint64_t), stack);
88869122 stack = oldstack;
8887- label = 684LLU; // skip deleter
9123+ label = 715LLU; // skip deleter
88889124 break;
88899125 }
8890- case 683LLU: // deleter
9126+ case 714LLU: // deleter
88919127 {
88929128 // throw from newvarraw
88939129 if(!stack[base + 15])
88949130 {
88959131 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
88979133 break;
88989134 }
88999135 fprintf(stderr, "in function newvarraw: unrolling stack, variable letdef \n");
@@ -8903,28 +9139,28 @@
89039139 newstack[0] = (uint64_t)stack; // backup stack location
89049140 newstack[1] = 1234567890;
89059141 newstack[2] = base;
8906- newstack[3] = 685LLU;
9142+ newstack[3] = 716LLU;
89079143 stack = newstack;
89089144 // set stack-base & callee-address
89099145 base = 4/*deloffset*/;
8910- label = 438LLU; // ~letdef
9146+ label = 455LLU; // ~letdef
89119147 break;
89129148 }
8913- case 685LLU: // return from ~letdef to newvarraw
9149+ case 716LLU: // return from ~letdef to newvarraw
89149150 {
89159151 stack = (uint64_t *)stack[0];
89169152 // releasing toplevel container
89179153 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 15] - sizeof(uint64_t) * 4));
89189154
8919- label = 673LLU; // continue unrolling stack, delete next variable
9155+ label = 704LLU; // continue unrolling stack, delete next variable
89209156 break;
89219157 }
8922- case 684LLU: // skipped deleter
9158+ case 715LLU: // skipped deleter
89239159 {
89249160 // construct letdef.letdef
89259161 if(!(stack[base + 15] = construct(5)))
89269162 {
8927- label = 673LLU; // throw: begin to unroll stack
9163+ label = 704LLU; // throw: begin to unroll stack
89289164 break;
89299165 }
89309166
@@ -8948,20 +9184,27 @@
89489184 }
89499185 ((uint64_t **)(stack[base + 8]))[1][1] = stack[base + 12];
89509186 ((uint64_t **)(stack[base + 8]))[1][0] = stack[base + 11];
8951- label = 671LLU; // case complete
9187+ label = 701LLU; // case complete
89529188 break;
89539189 }
8954- case 672LLU: // try next case
9190+ case 703LLU: // copy-back deleter (switch)
89559191 {
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+ {
89569199 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
89579200 exit(-1);
89589201 }
8959- case 671LLU: // completed switch
9202+ case 701LLU: // completed switch
89609203 {
89619204 // call add from newvarraw
8962- stack[base + 11LLU] = 686LLU/*throw to this address*/;
9205+ stack[base + 11LLU] = 717LLU/*throw to this address*/;
89639206 stack[base + 12LLU] = base;
8964- stack[base + 13LLU] = 687LLU;
9207+ stack[base + 13LLU] = 718LLU;
89659208 // arguments for call to add
89669209 stack[base + 15LLU] = 1LLU;
89679210 stack[base + 16LLU] = stack[base + 7]/*varcount*/;
@@ -8970,22 +9213,22 @@
89709213 label = 18446744073709551605LLU; // add
89719214 break;
89729215 }
8973- case 686LLU: // copy-back deleter (add to newvarraw)
9216+ case 717LLU: // copy-back deleter (add to newvarraw)
89749217 {
89759218 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (add to newvarraw)\n");
89769219 // copy mutable arguments back from call to add
8977- label = 669LLU; // continue to roll stack
9220+ label = 699LLU; // continue to roll stack
89789221 break;
89799222 }
8980- case 687LLU: // return from add to newvarraw
9223+ case 718LLU: // return from add to newvarraw
89819224 {
89829225 // copy mutable arguments back from call to add
89839226 // copy back results provided by call to add
89849227 stack[base + 7] = stack[base + 14LLU];
89859228 // call max from newvarraw
8986- stack[base + 11LLU] = 688LLU/*throw to this address*/;
9229+ stack[base + 11LLU] = 719LLU/*throw to this address*/;
89879230 stack[base + 12LLU] = base;
8988- stack[base + 13LLU] = 689LLU;
9231+ stack[base + 13LLU] = 720LLU;
89899232 // arguments for call to max
89909233 stack[base + 15LLU] = stack[base + 7]/*varcount*/;
89919234 stack[base + 16LLU] = stack[base + 6]/*fnmaxcount*/;
@@ -8994,35 +9237,35 @@
89949237 label = 18446744073709551606LLU; // max
89959238 break;
89969239 }
8997- case 688LLU: // copy-back deleter (max to newvarraw)
9240+ case 719LLU: // copy-back deleter (max to newvarraw)
89989241 {
89999242 fprintf(stderr, "in function newvarraw: unrolling stack, copy-back (max to newvarraw)\n");
90009243 // copy mutable arguments back from call to max
9001- label = 669LLU; // continue to roll stack
9244+ label = 699LLU; // continue to roll stack
90029245 break;
90039246 }
9004- case 689LLU: // return from max to newvarraw
9247+ case 720LLU: // return from max to newvarraw
90059248 {
90069249 // copy mutable arguments back from call to max
90079250 // copy back results provided by call to max
90089251 stack[base + 6] = stack[base + 14LLU];
9009- label = 691LLU; // skip deleter
9252+ label = 722LLU; // skip deleter
90109253 break;
90119254 }
9012- case 690LLU: // deleter
9255+ case 721LLU: // deleter
90139256 {
90149257 // throw from newvarraw
90159258 if(!stack[base + 0])
90169259 {
90179260 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
90199262 break;
90209263 }
90219264 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
90239266 break;
90249267 }
9025- case 691LLU: // skipped deleter
9268+ case 722LLU: // skipped deleter
90269269 {
90279270 stack[base + 0] = stack[base + 10]/*index*/;
90289271 // return from newvarraw
@@ -9030,7 +9273,7 @@
90309273 base = stack[base - 2];
90319274 break;
90329275 }
9033- case 693LLU: // function newvar failed
9276+ case 724LLU: // function newvar failed
90349277 {
90359278 fprintf(stderr, "function newvar failed\n");
90369279 label = stack[base - 3];
@@ -9037,7 +9280,7 @@
90379280 base = stack[base - 2];
90389281 break;
90399282 }
9040- case 692LLU: // newvar
9283+ case 723LLU: // newvar
90419284 {
90429285 //#define arg0 0
90439286 //#define arg1 1
@@ -9049,9 +9292,9 @@
90499292 //#define arg7 7
90509293 printf("%s", "\n//#define ");
90519294 // call printid from newvar
9052- stack[base + 8LLU] = 694LLU/*throw to this address*/;
9295+ stack[base + 8LLU] = 725LLU/*throw to this address*/;
90539296 stack[base + 9LLU] = base;
9054- stack[base + 10LLU] = 695LLU;
9297+ stack[base + 10LLU] = 726LLU;
90559298 // arguments for call to printid
90569299 stack[base + 11LLU] = stack[base + 1]/*id*/;
90579300 // set stack-base & callee-address
@@ -9059,19 +9302,19 @@
90599302 label = 18446744073709551587LLU; // printid
90609303 break;
90619304 }
9062- case 694LLU: // copy-back deleter (printid to newvar)
9305+ case 725LLU: // copy-back deleter (printid to newvar)
90639306 {
90649307 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
90659308 // copy mutable arguments back from call to printid
9066- label = 693LLU; // continue to roll stack
9309+ label = 724LLU; // continue to roll stack
90679310 break;
90689311 }
9069- case 695LLU: // return from printid to newvar
9312+ case 726LLU: // return from printid to newvar
90709313 {
90719314 // copy mutable arguments back from call to printid
90729315 if(/*scope*/0 != ((uint64_t *)(stack[base + 7]/*scope*/))[0])
90739316 {
9074- label = 697LLU; // jump to alternative
9317+ label = 728LLU; // jump to alternative
90759318 break;
90769319 }
90779320
@@ -9079,29 +9322,29 @@
90799322 /*letdefs*/stack[base + 9] = ((uint64_t **)(stack[base + 7]/*scope*/))[1][1]/*letdefs*/;
90809323
90819324 // case
9082- label = 699LLU; // skip deleter
9325+ label = 731LLU; // skip deleter
90839326 break;
90849327 }
9085- case 698LLU: // deleter
9328+ case 730LLU: // deleter
90869329 {
90879330 // throw from newvar
90889331 if(!stack[base + 10])
90899332 {
90909333 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
90929335 break;
90939336 }
90949337 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
90969339 break;
90979340 }
9098- case 699LLU: // skipped deleter
9341+ case 731LLU: // skipped deleter
90999342 {
91009343 stack[base + 10] = 0;
91019344 // call add from newvar
9102- stack[base + 11LLU] = 700LLU/*throw to this address*/;
9345+ stack[base + 11LLU] = 732LLU/*throw to this address*/;
91039346 stack[base + 12LLU] = base;
9104- stack[base + 13LLU] = 701LLU;
9347+ stack[base + 13LLU] = 733LLU;
91059348 // arguments for call to add
91069349 stack[base + 15LLU] = stack[base + 3]/*fnrescount*/;
91079350 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9110,22 +9353,22 @@
91109353 label = 18446744073709551605LLU; // add
91119354 break;
91129355 }
9113- case 700LLU: // copy-back deleter (add to newvar)
9356+ case 732LLU: // copy-back deleter (add to newvar)
91149357 {
91159358 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
91169359 // copy mutable arguments back from call to add
9117- label = 698LLU; // continue to roll stack
9360+ label = 730LLU; // continue to roll stack
91189361 break;
91199362 }
9120- case 701LLU: // return from add to newvar
9363+ case 733LLU: // return from add to newvar
91219364 {
91229365 // copy mutable arguments back from call to add
91239366 // copy back results provided by call to add
91249367 stack[base + 10] = stack[base + 14LLU];
91259368 // call add from newvar
9126- stack[base + 11LLU] = 702LLU/*throw to this address*/;
9369+ stack[base + 11LLU] = 734LLU/*throw to this address*/;
91279370 stack[base + 12LLU] = base;
9128- stack[base + 13LLU] = 703LLU;
9371+ stack[base + 13LLU] = 735LLU;
91299372 // arguments for call to add
91309373 stack[base + 15LLU] = stack[base + 4]/*fnargcount*/;
91319374 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9134,22 +9377,22 @@
91349377 label = 18446744073709551605LLU; // add
91359378 break;
91369379 }
9137- case 702LLU: // copy-back deleter (add to newvar)
9380+ case 734LLU: // copy-back deleter (add to newvar)
91389381 {
91399382 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
91409383 // copy mutable arguments back from call to add
9141- label = 698LLU; // continue to roll stack
9384+ label = 730LLU; // continue to roll stack
91429385 break;
91439386 }
9144- case 703LLU: // return from add to newvar
9387+ case 735LLU: // return from add to newvar
91459388 {
91469389 // copy mutable arguments back from call to add
91479390 // copy back results provided by call to add
91489391 stack[base + 10] = stack[base + 14LLU];
91499392 // call add from newvar
9150- stack[base + 11LLU] = 704LLU/*throw to this address*/;
9393+ stack[base + 11LLU] = 736LLU/*throw to this address*/;
91519394 stack[base + 12LLU] = base;
9152- stack[base + 13LLU] = 705LLU;
9395+ stack[base + 13LLU] = 737LLU;
91539396 // arguments for call to add
91549397 stack[base + 15LLU] = stack[base + 6]/*varcount*/;
91559398 stack[base + 16LLU] = stack[base + 10]/*sum*/;
@@ -9158,14 +9401,14 @@
91589401 label = 18446744073709551605LLU; // add
91599402 break;
91609403 }
9161- case 704LLU: // copy-back deleter (add to newvar)
9404+ case 736LLU: // copy-back deleter (add to newvar)
91629405 {
91639406 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
91649407 // copy mutable arguments back from call to add
9165- label = 698LLU; // continue to roll stack
9408+ label = 730LLU; // continue to roll stack
91669409 break;
91679410 }
9168- case 705LLU: // return from add to newvar
9411+ case 737LLU: // return from add to newvar
91699412 {
91709413 // copy mutable arguments back from call to add
91719414 // copy back results provided by call to add
@@ -9172,9 +9415,9 @@
91729415 stack[base + 10] = stack[base + 14LLU];
91739416 printf("%s", " ");
91749417 // call printnr from newvar
9175- stack[base + 11LLU] = 706LLU/*throw to this address*/;
9418+ stack[base + 11LLU] = 738LLU/*throw to this address*/;
91769419 stack[base + 12LLU] = base;
9177- stack[base + 13LLU] = 707LLU;
9420+ stack[base + 13LLU] = 739LLU;
91789421 // arguments for call to printnr
91799422 stack[base + 14LLU] = stack[base + 10]/*sum*/;
91809423 // set stack-base & callee-address
@@ -9182,20 +9425,20 @@
91829425 label = 18446744073709551590LLU; // printnr
91839426 break;
91849427 }
9185- case 706LLU: // copy-back deleter (printnr to newvar)
9428+ case 738LLU: // copy-back deleter (printnr to newvar)
91869429 {
91879430 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
91889431 // copy mutable arguments back from call to printnr
9189- label = 698LLU; // continue to roll stack
9432+ label = 730LLU; // continue to roll stack
91909433 break;
91919434 }
9192- case 707LLU: // return from printnr to newvar
9435+ case 739LLU: // return from printnr to newvar
91939436 {
91949437 // copy mutable arguments back from call to printnr
91959438 uint64_t *newstack = (uint64_t *)Calloc(15LLU + 1, sizeof(uint64_t));
91969439 if(!newstack)
91979440 {
9198- label = 698LLU; // throw: begin to unroll stack
9441+ label = 730LLU; // throw: begin to unroll stack
91999442 break;
92009443 }
92019444
@@ -9202,18 +9445,18 @@
92029445 newstack[15LLU] = 9876543210LLU; // overflow-marker
92039446 // call copytype from newvar
92049447 newstack[0] = (uint64_t)stack; // backup stack location
9205- newstack[1] = 708LLU;
9448+ newstack[1] = 740LLU;
92069449 newstack[2] = base;
9207- newstack[3] = 709LLU;
9450+ newstack[3] = 741LLU;
92089451 // arguments for call to copytype
92099452 newstack[5LLU] = stack[base + 0]/*type*/;
92109453 stack = newstack;
92119454 // set stack-base & callee-address
92129455 base = 4/*deloffset*/;
9213- label = 322LLU; // copytype
9456+ label = 326LLU; // copytype
92149457 break;
92159458 }
9216- case 708LLU: // copy-back deleter (copytype to newvar)
9459+ case 740LLU: // copy-back deleter (copytype to newvar)
92179460 {
92189461 fprintf(stderr, "in function newvar: unrolling stack, copy-back (copytype to newvar)\n");
92199462 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -9225,10 +9468,10 @@
92259468 }
92269469 Free(15LLU + 1, sizeof(uint64_t), stack);
92279470 stack = oldstack;
9228- label = 698LLU; // continue to unroll stack
9471+ label = 730LLU; // continue to unroll stack
92299472 break;
92309473 }
9231- case 709LLU: // return from copytype to newvar
9474+ case 741LLU: // return from copytype to newvar
92329475 {
92339476 uint64_t *oldstack = (uint64_t *)stack[0];
92349477 // copy mutable arguments back from call to copytype
@@ -9241,35 +9484,35 @@
92419484 }
92429485 Free(15LLU + 1, sizeof(uint64_t), stack);
92439486 stack = oldstack;
9244- label = 711LLU; // skip deleter
9487+ label = 743LLU; // skip deleter
92459488 break;
92469489 }
9247- case 710LLU: // deleter
9490+ case 742LLU: // deleter
92489491 {
92499492 // throw from newvar
92509493 if(!stack[base + 12])
92519494 {
92529495 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
92549497 break;
92559498 }
92569499 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
92589501 break;
92599502 }
9260- case 711LLU: // skipped deleter
9503+ case 743LLU: // skipped deleter
92619504 {
92629505 stack[base + 12] = 0;
9263- label = 713LLU; // skip deleter
9506+ label = 745LLU; // skip deleter
92649507 break;
92659508 }
9266- case 712LLU: // deleter
9509+ case 744LLU: // deleter
92679510 {
92689511 // throw from newvar
92699512 if(!stack[base + 13])
92709513 {
92719514 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
92739516 break;
92749517 }
92759518 fprintf(stderr, "in function newvar: unrolling stack, variable letdef \n");
@@ -9279,28 +9522,28 @@
92799522 newstack[0] = (uint64_t)stack; // backup stack location
92809523 newstack[1] = 1234567890;
92819524 newstack[2] = base;
9282- newstack[3] = 714LLU;
9525+ newstack[3] = 746LLU;
92839526 stack = newstack;
92849527 // set stack-base & callee-address
92859528 base = 4/*deloffset*/;
9286- label = 438LLU; // ~letdef
9529+ label = 455LLU; // ~letdef
92879530 break;
92889531 }
9289- case 714LLU: // return from ~letdef to newvar
9532+ case 746LLU: // return from ~letdef to newvar
92909533 {
92919534 stack = (uint64_t *)stack[0];
92929535 // releasing toplevel container
92939536 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 13] - sizeof(uint64_t) * 4));
92949537
9295- label = 710LLU; // continue unrolling stack, delete next variable
9538+ label = 742LLU; // continue unrolling stack, delete next variable
92969539 break;
92979540 }
9298- case 713LLU: // skipped deleter
9541+ case 745LLU: // skipped deleter
92999542 {
93009543 // construct letdef.letdef
93019544 if(!(stack[base + 13] = construct(5)))
93029545 {
9303- label = 710LLU; // throw: begin to unroll stack
9546+ label = 742LLU; // throw: begin to unroll stack
93049547 break;
93059548 }
93069549
@@ -9324,9 +9567,9 @@
93249567 }
93259568 printf("%s", "\n stack[base + ");
93269569 // call printnr from newvar
9327- stack[base + 14LLU] = 715LLU/*throw to this address*/;
9570+ stack[base + 14LLU] = 747LLU/*throw to this address*/;
93289571 stack[base + 15LLU] = base;
9329- stack[base + 16LLU] = 716LLU;
9572+ stack[base + 16LLU] = 748LLU;
93309573 // arguments for call to printnr
93319574 stack[base + 17LLU] = stack[base + 10]/*sum*/;
93329575 // set stack-base & callee-address
@@ -9334,21 +9577,21 @@
93349577 label = 18446744073709551590LLU; // printnr
93359578 break;
93369579 }
9337- case 715LLU: // copy-back deleter (printnr to newvar)
9580+ case 747LLU: // copy-back deleter (printnr to newvar)
93389581 {
93399582 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printnr to newvar)\n");
93409583 // copy mutable arguments back from call to printnr
9341- label = 712LLU; // continue to roll stack
9584+ label = 744LLU; // continue to roll stack
93429585 break;
93439586 }
9344- case 716LLU: // return from printnr to newvar
9587+ case 748LLU: // return from printnr to newvar
93459588 {
93469589 // copy mutable arguments back from call to printnr
93479590 printf("%s", "/*");
93489591 // call printid from newvar
9349- stack[base + 14LLU] = 717LLU/*throw to this address*/;
9592+ stack[base + 14LLU] = 749LLU/*throw to this address*/;
93509593 stack[base + 15LLU] = base;
9351- stack[base + 16LLU] = 718LLU;
9594+ stack[base + 16LLU] = 750LLU;
93529595 // arguments for call to printid
93539596 stack[base + 17LLU] = stack[base + 1]/*id*/;
93549597 // set stack-base & callee-address
@@ -9356,33 +9599,40 @@
93569599 label = 18446744073709551587LLU; // printid
93579600 break;
93589601 }
9359- case 717LLU: // copy-back deleter (printid to newvar)
9602+ case 749LLU: // copy-back deleter (printid to newvar)
93609603 {
93619604 fprintf(stderr, "in function newvar: unrolling stack, copy-back (printid to newvar)\n");
93629605 // copy mutable arguments back from call to printid
9363- label = 712LLU; // continue to roll stack
9606+ label = 744LLU; // continue to roll stack
93649607 break;
93659608 }
9366- case 718LLU: // return from printid to newvar
9609+ case 750LLU: // return from printid to newvar
93679610 {
93689611 // copy mutable arguments back from call to printid
93699612 printf("%s", "*/] = 0; // init");
93709613 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
93719614 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
9372- label = 696LLU; // case complete
9615+ label = 727LLU; // case complete
93739616 break;
93749617 }
9375- case 697LLU: // try next case
9618+ case 729LLU: // copy-back deleter (switch)
93769619 {
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+ {
93779627 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
93789628 exit(-1);
93799629 }
9380- case 696LLU: // completed switch
9630+ case 727LLU: // completed switch
93819631 {
93829632 // call add from newvar
9383- stack[base + 8LLU] = 719LLU/*throw to this address*/;
9633+ stack[base + 8LLU] = 751LLU/*throw to this address*/;
93849634 stack[base + 9LLU] = base;
9385- stack[base + 10LLU] = 720LLU;
9635+ stack[base + 10LLU] = 752LLU;
93869636 // arguments for call to add
93879637 stack[base + 12LLU] = 1LLU;
93889638 stack[base + 13LLU] = stack[base + 6]/*varcount*/;
@@ -9391,22 +9641,22 @@
93919641 label = 18446744073709551605LLU; // add
93929642 break;
93939643 }
9394- case 719LLU: // copy-back deleter (add to newvar)
9644+ case 751LLU: // copy-back deleter (add to newvar)
93959645 {
93969646 fprintf(stderr, "in function newvar: unrolling stack, copy-back (add to newvar)\n");
93979647 // copy mutable arguments back from call to add
9398- label = 693LLU; // continue to roll stack
9648+ label = 724LLU; // continue to roll stack
93999649 break;
94009650 }
9401- case 720LLU: // return from add to newvar
9651+ case 752LLU: // return from add to newvar
94029652 {
94039653 // copy mutable arguments back from call to add
94049654 // copy back results provided by call to add
94059655 stack[base + 6] = stack[base + 11LLU];
94069656 // call max from newvar
9407- stack[base + 8LLU] = 721LLU/*throw to this address*/;
9657+ stack[base + 8LLU] = 753LLU/*throw to this address*/;
94089658 stack[base + 9LLU] = base;
9409- stack[base + 10LLU] = 722LLU;
9659+ stack[base + 10LLU] = 754LLU;
94109660 // arguments for call to max
94119661 stack[base + 12LLU] = stack[base + 6]/*varcount*/;
94129662 stack[base + 13LLU] = stack[base + 5]/*fnmaxcount*/;
@@ -9415,14 +9665,14 @@
94159665 label = 18446744073709551606LLU; // max
94169666 break;
94179667 }
9418- case 721LLU: // copy-back deleter (max to newvar)
9668+ case 753LLU: // copy-back deleter (max to newvar)
94199669 {
94209670 fprintf(stderr, "in function newvar: unrolling stack, copy-back (max to newvar)\n");
94219671 // copy mutable arguments back from call to max
9422- label = 693LLU; // continue to roll stack
9672+ label = 724LLU; // continue to roll stack
94239673 break;
94249674 }
9425- case 722LLU: // return from max to newvar
9675+ case 754LLU: // return from max to newvar
94269676 {
94279677 // copy mutable arguments back from call to max
94289678 // copy back results provided by call to max
@@ -9432,7 +9682,7 @@
94329682 base = stack[base - 2];
94339683 break;
94349684 }
9435- case 724LLU: // function unscopelet failed
9685+ case 756LLU: // function unscopelet failed
94369686 {
94379687 fprintf(stderr, "function unscopelet failed\n");
94389688 label = stack[base - 3];
@@ -9439,7 +9689,7 @@
94399689 base = stack[base - 2];
94409690 break;
94419691 }
9442- case 723LLU: // unscopelet
9692+ case 755LLU: // unscopelet
94439693 {
94449694 //#define arg0 0
94459695 //#define arg1 1
@@ -9446,7 +9696,7 @@
94469696 //#define arg2 2
94479697 if(/*scope*/0 != ((uint64_t *)(stack[base + 1]/*scope*/))[0])
94489698 {
9449- label = 726LLU; // jump to alternative
9699+ label = 758LLU; // jump to alternative
94509700 break;
94519701 }
94529702
@@ -9454,28 +9704,28 @@
94549704 /*LETDEFS*/stack[base + 4] = ((uint64_t **)(stack[base + 1]/*scope*/))[1][1]/*letdefs*/;
94559705
94569706 // case
9457- label = 728LLU; // skip deleter
9707+ label = 761LLU; // skip deleter
94589708 break;
94599709 }
9460- case 727LLU: // deleter
9710+ case 760LLU: // deleter
94619711 {
94629712 // throw from unscopelet
94639713 if(!stack[base + 5])
94649714 {
94659715 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
94679717 break;
94689718 }
94699719 fprintf(stderr, "in function unscopelet: unrolling stack, variable [letdef] \n");
94709720 // delete list
9471- label = 729LLU; // start to repeat
9721+ label = 762LLU; // start to repeat
94729722 break;
94739723 }
9474- case 729LLU: // repeat from here
9724+ case 762LLU: // repeat from here
94759725 {
94769726 if(!stack[base + 5])
94779727 {
9478- label = 730LLU; // break loop
9728+ label = 763LLU; // break loop
94799729 break;
94809730 }
94819731
@@ -9486,14 +9736,14 @@
94869736 newstack[0] = (uint64_t)stack; // backup stack location
94879737 newstack[1] = 1234567890;
94889738 newstack[2] = base;
9489- newstack[3] = 731LLU;
9739+ newstack[3] = 764LLU;
94909740 stack = newstack;
94919741 // set stack-base & callee-address
94929742 base = 4/*deloffset*/;
9493- label = 438LLU; // ~letdef
9743+ label = 455LLU; // ~letdef
94949744 break;
94959745 }
9496- case 731LLU: // return from ~letdef to unscopelet
9746+ case 764LLU: // return from ~letdef to unscopelet
94979747 {
94989748 stack = (uint64_t *)stack[0];
94999749 // releasing toplevel container
@@ -9504,44 +9754,44 @@
95049754 stack[base + 5] = (uint64_t)list->next;
95059755 Free(1, sizeof(struct listnode), list);
95069756 }
9507- label = 729LLU; // repeat
9757+ label = 762LLU; // repeat
95089758 break;
95099759 }
9510- case 730LLU: // loop finished
9760+ case 763LLU: // loop finished
95119761 {
9512- label = 724LLU; // continue unrolling stack, delete next variable
9762+ label = 759LLU; // continue unrolling stack, delete next variable
95139763 break;
95149764 }
9515- case 728LLU: // skipped deleter
9765+ case 761LLU: // skipped deleter
95169766 {
95179767 stack[base + 5] = 0;
9518- label = 733LLU; // skip deleter
9768+ label = 766LLU; // skip deleter
95199769 break;
95209770 }
9521- case 732LLU: // deleter
9771+ case 765LLU: // deleter
95229772 {
95239773 // throw from unscopelet
95249774 if(!stack[base + 6])
95259775 {
95269776 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
95289778 break;
95299779 }
95309780 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
95329782 break;
95339783 }
9534- case 733LLU: // skipped deleter
9784+ case 766LLU: // skipped deleter
95359785 {
95369786 stack[base + 6] = 0;
9537- label = 734LLU; // start to repeat
9787+ label = 767LLU; // start to repeat
95389788 break;
95399789 }
9540- case 734LLU: // repeat from here
9790+ case 767LLU: // repeat from here
95419791 {
95429792 if(!stack[base + 4])
95439793 {
9544- label = 735LLU; // break loop
9794+ label = 768LLU; // break loop
95459795 break;
95469796 }
95479797
@@ -9554,29 +9804,29 @@
95549804 }
95559805 if(!stack[base + 6]/*found*/)
95569806 {
9557- label = 736LLU; // jump to alternative
9807+ label = 769LLU; // jump to alternative
95589808 break;
95599809 }
95609810
95619811 // consequent
95629812 // call mkletdummy from unscopelet
9563- stack[base + 9LLU] = 738LLU/*throw to this address*/;
9813+ stack[base + 9LLU] = 771LLU/*throw to this address*/;
95649814 stack[base + 10LLU] = base;
9565- stack[base + 11LLU] = 739LLU;
9815+ stack[base + 11LLU] = 772LLU;
95669816 // arguments for call to mkletdummy
95679817 // set stack-base & callee-address
95689818 base += 12LLU;
9569- label = 441LLU; // mkletdummy
9819+ label = 458LLU; // mkletdummy
95709820 break;
95719821 }
9572- case 738LLU: // copy-back deleter (mkletdummy to unscopelet)
9822+ case 771LLU: // copy-back deleter (mkletdummy to unscopelet)
95739823 {
95749824 fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (mkletdummy to unscopelet)\n");
95759825 // copy mutable arguments back from call to mkletdummy
9576- label = 732LLU; // continue to roll stack
9826+ label = 765LLU; // continue to roll stack
95779827 break;
95789828 }
9579- case 739LLU: // return from mkletdummy to unscopelet
9829+ case 772LLU: // return from mkletdummy to unscopelet
95809830 {
95819831 // copy mutable arguments back from call to mkletdummy
95829832 // copy back results provided by call to mkletdummy
@@ -9593,14 +9843,14 @@
95939843 stack[base + 5]/*letdefs*/ = (uint64_t)list;
95949844 MOVE(&list->data, &stack[base + 8]/*tmp*/);
95959845 }
9596- label = 737LLU; // consequent complete
9846+ label = 770LLU; // consequent complete
95979847 break;
95989848 }
9599- case 736LLU: // alternative
9849+ case 769LLU: // alternative
96009850 {
96019851 if(/*letdef*/0 != ((uint64_t *)(stack[base + 7]/*letdef*/))[0])
96029852 {
9603- label = 741LLU; // jump to alternative
9853+ label = 774LLU; // jump to alternative
96049854 break;
96059855 }
96069856
@@ -9612,9 +9862,9 @@
96129862
96139863 // case
96149864 // call equ from unscopelet
9615- stack[base + 13LLU] = 742LLU/*throw to this address*/;
9865+ stack[base + 13LLU] = 776LLU/*throw to this address*/;
96169866 stack[base + 14LLU] = base;
9617- stack[base + 15LLU] = 743LLU;
9867+ stack[base + 15LLU] = 777LLU;
96189868 // arguments for call to equ
96199869 stack[base + 17LLU] = stack[base + 9]/*curid*/;
96209870 stack[base + 18LLU] = stack[base + 2]/*id*/;
@@ -9623,14 +9873,14 @@
96239873 label = 18446744073709551600LLU; // equ
96249874 break;
96259875 }
9626- case 742LLU: // copy-back deleter (equ to unscopelet)
9876+ case 776LLU: // copy-back deleter (equ to unscopelet)
96279877 {
96289878 fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (equ to unscopelet)\n");
96299879 // copy mutable arguments back from call to equ
9630- label = 732LLU; // continue to roll stack
9880+ label = 775LLU; // continue to roll stack
96319881 break;
96329882 }
9633- case 743LLU: // return from equ to unscopelet
9883+ case 777LLU: // return from equ to unscopelet
96349884 {
96359885 // copy mutable arguments back from call to equ
96369886 // copy back results provided by call to equ
@@ -9640,46 +9890,56 @@
96409890 ((uint64_t **)(stack[base + 7]))[1][2] = stack[base + 10];
96419891 ((uint64_t **)(stack[base + 7]))[1][1] = stack[base + 9];
96429892 ((uint64_t **)(stack[base + 7]))[1][0] = stack[base + 8];
9643- label = 740LLU; // case complete
9893+ label = 773LLU; // case complete
96449894 break;
96459895 }
9646- case 741LLU: // try next case
9896+ case 775LLU: // copy-back deleter (switch)
96479897 {
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+ {
96489908 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
96499909 exit(-1);
96509910 }
9651- case 740LLU: // completed switch
9911+ case 773LLU: // completed switch
96529912 {
96539913 if(!stack[base + 6]/*found*/)
96549914 {
9655- label = 744LLU; // jump to alternative
9915+ label = 778LLU; // jump to alternative
96569916 break;
96579917 }
96589918
96599919 // consequent
9660- label = 745LLU; // consequent complete
9920+ label = 779LLU; // consequent complete
96619921 break;
96629922 }
9663- case 744LLU: // alternative
9923+ case 778LLU: // alternative
96649924 {
96659925 // call mkletdummy from unscopelet
9666- stack[base + 9LLU] = 746LLU/*throw to this address*/;
9926+ stack[base + 9LLU] = 780LLU/*throw to this address*/;
96679927 stack[base + 10LLU] = base;
9668- stack[base + 11LLU] = 747LLU;
9928+ stack[base + 11LLU] = 781LLU;
96699929 // arguments for call to mkletdummy
96709930 // set stack-base & callee-address
96719931 base += 12LLU;
9672- label = 441LLU; // mkletdummy
9932+ label = 458LLU; // mkletdummy
96739933 break;
96749934 }
9675- case 746LLU: // copy-back deleter (mkletdummy to unscopelet)
9935+ case 780LLU: // copy-back deleter (mkletdummy to unscopelet)
96769936 {
96779937 fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (mkletdummy to unscopelet)\n");
96789938 // copy mutable arguments back from call to mkletdummy
9679- label = 732LLU; // continue to roll stack
9939+ label = 765LLU; // continue to roll stack
96809940 break;
96819941 }
9682- case 747LLU: // return from mkletdummy to unscopelet
9942+ case 781LLU: // return from mkletdummy to unscopelet
96839943 {
96849944 // copy mutable arguments back from call to mkletdummy
96859945 // copy back results provided by call to mkletdummy
@@ -9696,15 +9956,15 @@
96969956 stack[base + 5]/*letdefs*/ = (uint64_t)list;
96979957 MOVE(&list->data, &stack[base + 8]/*tmp*/);
96989958 }
9699- label = 745LLU; // alternative complete
9959+ label = 779LLU; // alternative complete
97009960 break;
97019961 }
9702- case 745LLU: // completed if-then-else
9962+ case 779LLU: // completed if-then-else
97039963 {
9704- label = 737LLU; // alternative complete
9964+ label = 770LLU; // alternative complete
97059965 break;
97069966 }
9707- case 737LLU: // completed if-then-else
9967+ case 770LLU: // completed if-then-else
97089968 {
97099969
97109970 uint64_t *newstack = (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4);
@@ -9712,43 +9972,43 @@
97129972 newstack[0] = (uint64_t)stack; // backup stack location
97139973 newstack[1] = 1234567890;
97149974 newstack[2] = base;
9715- newstack[3] = 748LLU;
9975+ newstack[3] = 782LLU;
97169976 stack = newstack;
97179977 // set stack-base & callee-address
97189978 base = 4/*deloffset*/;
9719- label = 438LLU; // ~letdef
9979+ label = 455LLU; // ~letdef
97209980 break;
97219981 }
9722- case 748LLU: // return from ~letdef to unscopelet
9982+ case 782LLU: // return from ~letdef to unscopelet
97239983 {
97249984 stack = (uint64_t *)stack[0];
97259985 // releasing toplevel container
97269986 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 7] - sizeof(uint64_t) * 4));
97279987
9728- label = 734LLU; // repeat
9988+ label = 767LLU; // repeat
97299989 break;
97309990 }
9731- case 735LLU: // loop finished
9991+ case 768LLU: // loop finished
97329992 {
97339993 list_reverse(((struct listnode **)(&stack[base + 5]/*letdefs*/)));
97349994 swap(&stack[base + 5], &stack[base + 4]);
97359995 if(!stack[base + 6]/*found*/)
97369996 {
9737- label = 749LLU; // jump to alternative
9997+ label = 783LLU; // jump to alternative
97389998 break;
97399999 }
974010000
974110001 // consequent
9742- label = 750LLU; // consequent complete
10002+ label = 784LLU; // consequent complete
974310003 break;
974410004 }
9745- case 749LLU: // alternative
10005+ case 783LLU: // alternative
974610006 {
974710007 fprintf(stderr, "%s", "in function ");
974810008 // call reportid from unscopelet
9749- stack[base + 8LLU] = 751LLU/*throw to this address*/;
10009+ stack[base + 8LLU] = 785LLU/*throw to this address*/;
975010010 stack[base + 9LLU] = base;
9751- stack[base + 10LLU] = 752LLU;
10011+ stack[base + 10LLU] = 786LLU;
975210012 // arguments for call to reportid
975310013 stack[base + 11LLU] = stack[base + 0]/*fnid*/;
975410014 // set stack-base & callee-address
@@ -9756,22 +10016,22 @@
975610016 label = 18446744073709551586LLU; // reportid
975710017 break;
975810018 }
9759- case 751LLU: // copy-back deleter (reportid to unscopelet)
10019+ case 785LLU: // copy-back deleter (reportid to unscopelet)
976010020 {
976110021 fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (reportid to unscopelet)\n");
976210022 // copy mutable arguments back from call to reportid
9763- label = 732LLU; // continue to roll stack
10023+ label = 765LLU; // continue to roll stack
976410024 break;
976510025 }
9766- case 752LLU: // return from reportid to unscopelet
10026+ case 786LLU: // return from reportid to unscopelet
976710027 {
976810028 // copy mutable arguments back from call to reportid
976910029 fprintf(stderr, "%s", ": ");
977010030 fprintf(stderr, "%s", "failed to uninitialize variable ");
977110031 // call reportid from unscopelet
9772- stack[base + 8LLU] = 753LLU/*throw to this address*/;
10032+ stack[base + 8LLU] = 787LLU/*throw to this address*/;
977310033 stack[base + 9LLU] = base;
9774- stack[base + 10LLU] = 754LLU;
10034+ stack[base + 10LLU] = 788LLU;
977510035 // arguments for call to reportid
977610036 stack[base + 11LLU] = stack[base + 2]/*id*/;
977710037 // set stack-base & callee-address
@@ -9779,32 +10039,32 @@
977910039 label = 18446744073709551586LLU; // reportid
978010040 break;
978110041 }
9782- case 753LLU: // copy-back deleter (reportid to unscopelet)
10042+ case 787LLU: // copy-back deleter (reportid to unscopelet)
978310043 {
978410044 fprintf(stderr, "in function unscopelet: unrolling stack, copy-back (reportid to unscopelet)\n");
978510045 // copy mutable arguments back from call to reportid
9786- label = 732LLU; // continue to roll stack
10046+ label = 765LLU; // continue to roll stack
978710047 break;
978810048 }
9789- case 754LLU: // return from reportid to unscopelet
10049+ case 788LLU: // return from reportid to unscopelet
979010050 {
979110051 // copy mutable arguments back from call to reportid
979210052 fprintf(stderr, "%s", " because it is not in scope.\n");
979310053 exit(-1);
9794- label = 750LLU; // alternative complete
10054+ label = 784LLU; // alternative complete
979510055 break;
979610056 }
9797- case 750LLU: // completed if-then-else
10057+ case 784LLU: // completed if-then-else
979810058 {
979910059 // delete list
9800- label = 755LLU; // start to repeat
10060+ label = 789LLU; // start to repeat
980110061 break;
980210062 }
9803- case 755LLU: // repeat from here
10063+ case 789LLU: // repeat from here
980410064 {
980510065 if(!stack[base + 5])
980610066 {
9807- label = 756LLU; // break loop
10067+ label = 790LLU; // break loop
980810068 break;
980910069 }
981010070
@@ -9815,14 +10075,14 @@
981510075 newstack[0] = (uint64_t)stack; // backup stack location
981610076 newstack[1] = 1234567890;
981710077 newstack[2] = base;
9818- newstack[3] = 757LLU;
10078+ newstack[3] = 791LLU;
981910079 stack = newstack;
982010080 // set stack-base & callee-address
982110081 base = 4/*deloffset*/;
9822- label = 438LLU; // ~letdef
10082+ label = 455LLU; // ~letdef
982310083 break;
982410084 }
9825- case 757LLU: // return from ~letdef to unscopelet
10085+ case 791LLU: // return from ~letdef to unscopelet
982610086 {
982710087 stack = (uint64_t *)stack[0];
982810088 // releasing toplevel container
@@ -9833,22 +10093,29 @@
983310093 stack[base + 5] = (uint64_t)list->next;
983410094 Free(1, sizeof(struct listnode), list);
983510095 }
9836- label = 755LLU; // repeat
10096+ label = 789LLU; // repeat
983710097 break;
983810098 }
9839- case 756LLU: // loop finished
10099+ case 790LLU: // loop finished
984010100 {
984110101 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 4];
984210102 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 3];
9843- label = 725LLU; // case complete
10103+ label = 757LLU; // case complete
984410104 break;
984510105 }
9846- case 726LLU: // try next case
10106+ case 759LLU: // copy-back deleter (switch)
984710107 {
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+ {
984810115 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
984910116 exit(-1);
985010117 }
9851- case 725LLU: // completed switch
10118+ case 757LLU: // completed switch
985210119 {
985310120 // return from unscopelet
985410121 label = stack[base - 1];
@@ -9855,7 +10122,7 @@
985510122 base = stack[base - 2];
985610123 break;
985710124 }
9858- case 758LLU: // ~idnr
10125+ case 792LLU: // ~idnr
985910126 {
986010127 if(stack[base + 0]/*variant-nr*/ >= 1)
986110128 {
@@ -9862,10 +10129,10 @@
986210129 fprintf(stderr, "in ~idnr: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
986310130 exit(-1);
986410131 }
9865- label = 758LLU + 1LLU + stack[base + 0]/*variant-nr*/;
10132+ label = 792LLU + 1LLU + stack[base + 0]/*variant-nr*/;
986610133 break;
986710134 }
9868- case 758LLU + 1LLU + 0LLU: // ~idnr.idnr
10135+ case 792LLU + 1LLU + 0LLU: // ~idnr.idnr
986910136 {
987010137 // release element id
987110138 // release element nr
@@ -9875,7 +10142,7 @@
987510142 base = stack[base - 2];
987610143 break;
987710144 }
9878- case 761LLU: // function lookidnr failed
10145+ case 795LLU: // function lookidnr failed
987910146 {
988010147 fprintf(stderr, "function lookidnr failed\n");
988110148 label = stack[base - 3];
@@ -9882,39 +10149,39 @@
988210149 base = stack[base - 2];
988310150 break;
988410151 }
9885- case 760LLU: // lookidnr
10152+ case 794LLU: // lookidnr
988610153 {
988710154 //#define res0 0
988810155 //#define arg0 1
988910156 //#define arg1 2
9890- label = 763LLU; // skip deleter
10157+ label = 797LLU; // skip deleter
989110158 break;
989210159 }
9893- case 762LLU: // deleter
10160+ case 796LLU: // deleter
989410161 {
989510162 // throw from lookidnr
989610163 if(!stack[base + 3])
989710164 {
989810165 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
990010167 break;
990110168 }
990210169 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
990410171 break;
990510172 }
9906- case 763LLU: // skipped deleter
10173+ case 797LLU: // skipped deleter
990710174 {
990810175 stack[base + 3] = 0;
990910176 flippedassign(stack[base + 1]/*idnrs*/, &stack[base + 4]);
9910- label = 764LLU; // start to repeat
10177+ label = 798LLU; // start to repeat
991110178 break;
991210179 }
9913- case 764LLU: // repeat from here
10180+ case 798LLU: // repeat from here
991410181 {
991510182 if(!stack[base + 4])
991610183 {
9917- label = 765LLU; // break loop
10184+ label = 799LLU; // break loop
991810185 break;
991910186 }
992010187
@@ -9924,19 +10191,19 @@
992410191 stack[base + 4] = (uint64_t)(((const struct listnode *)(stack[base + 4]))->next);
992510192 if(!stack[base + 3]/*found*/)
992610193 {
9927- label = 766LLU; // jump to alternative
10194+ label = 800LLU; // jump to alternative
992810195 break;
992910196 }
993010197
993110198 // consequent
9932- label = 767LLU; // consequent complete
10199+ label = 801LLU; // consequent complete
993310200 break;
993410201 }
9935- case 766LLU: // alternative
10202+ case 800LLU: // alternative
993610203 {
993710204 if(/*idnr*/0 != ((uint64_t *)(stack[base + 5]/*idnr*/))[0])
993810205 {
9939- label = 769LLU; // jump to alternative
10206+ label = 803LLU; // jump to alternative
994010207 break;
994110208 }
994210209
@@ -9945,9 +10212,9 @@
994510212
994610213 // case
994710214 // call equ from lookidnr
9948- stack[base + 9LLU] = 770LLU/*throw to this address*/;
10215+ stack[base + 9LLU] = 805LLU/*throw to this address*/;
994910216 stack[base + 10LLU] = base;
9950- stack[base + 11LLU] = 771LLU;
10217+ stack[base + 11LLU] = 806LLU;
995110218 // arguments for call to equ
995210219 stack[base + 13LLU] = stack[base + 7]/*id*/;
995310220 stack[base + 14LLU] = stack[base + 2]/*wanted*/;
@@ -9956,14 +10223,14 @@
995610223 label = 18446744073709551600LLU; // equ
995710224 break;
995810225 }
9959- case 770LLU: // copy-back deleter (equ to lookidnr)
10226+ case 805LLU: // copy-back deleter (equ to lookidnr)
996010227 {
996110228 fprintf(stderr, "in function lookidnr: unrolling stack, copy-back (equ to lookidnr)\n");
996210229 // copy mutable arguments back from call to equ
9963- label = 762LLU; // continue to roll stack
10230+ label = 804LLU; // continue to roll stack
996410231 break;
996510232 }
9966- case 771LLU: // return from equ to lookidnr
10233+ case 806LLU: // return from equ to lookidnr
996710234 {
996810235 // copy mutable arguments back from call to equ
996910236 // copy back results provided by call to equ
@@ -9970,44 +10237,51 @@
997010237 stack[base + 3] = stack[base + 12LLU];
997110238 ((uint64_t **)(stack[base + 5]))[1][1] = stack[base + 8];
997210239 ((uint64_t **)(stack[base + 5]))[1][0] = stack[base + 7];
9973- label = 768LLU; // case complete
10240+ label = 802LLU; // case complete
997410241 break;
997510242 }
9976- case 769LLU: // try next case
10243+ case 804LLU: // copy-back deleter (switch)
997710244 {
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+ {
997810252 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
997910253 exit(-1);
998010254 }
9981- case 768LLU: // completed switch
10255+ case 802LLU: // completed switch
998210256 {
9983- label = 767LLU; // alternative complete
10257+ label = 801LLU; // alternative complete
998410258 break;
998510259 }
9986- case 767LLU: // completed if-then-else
10260+ case 801LLU: // completed if-then-else
998710261 {
998810262 ((struct listnode *)(stack[base + 6]/*previous*/))->data = stack[base + 5];
9989- label = 764LLU; // repeat
10263+ label = 798LLU; // repeat
999010264 break;
999110265 }
9992- case 765LLU: // loop finished
10266+ case 799LLU: // loop finished
999310267 {
9994- label = 773LLU; // skip deleter
10268+ label = 808LLU; // skip deleter
999510269 break;
999610270 }
9997- case 772LLU: // deleter
10271+ case 807LLU: // deleter
999810272 {
999910273 // throw from lookidnr
1000010274 if(!stack[base + 0])
1000110275 {
1000210276 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
1000410278 break;
1000510279 }
1000610280 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
1000810282 break;
1000910283 }
10010- case 773LLU: // skipped deleter
10284+ case 808LLU: // skipped deleter
1001110285 {
1001210286 stack[base + 0] = stack[base + 3]/*found*/;
1001310287 // return from lookidnr
@@ -10015,7 +10289,7 @@
1001510289 base = stack[base - 2];
1001610290 break;
1001710291 }
10018- case 775LLU: // function reportidnr failed
10292+ case 810LLU: // function reportidnr failed
1001910293 {
1002010294 fprintf(stderr, "function reportidnr failed\n");
1002110295 label = stack[base - 3];
@@ -10022,12 +10296,12 @@
1002210296 base = stack[base - 2];
1002310297 break;
1002410298 }
10025- case 774LLU: // reportidnr
10299+ case 809LLU: // reportidnr
1002610300 {
1002710301 //#define arg0 0
1002810302 if(/*idnr*/0 != ((uint64_t *)(stack[base + 0]/*idnr*/))[0])
1002910303 {
10030- label = 777LLU; // jump to alternative
10304+ label = 812LLU; // jump to alternative
1003110305 break;
1003210306 }
1003310307
@@ -10036,9 +10310,9 @@
1003610310
1003710311 // case
1003810312 // call reportid from reportidnr
10039- stack[base + 3LLU] = 778LLU/*throw to this address*/;
10313+ stack[base + 3LLU] = 814LLU/*throw to this address*/;
1004010314 stack[base + 4LLU] = base;
10041- stack[base + 5LLU] = 779LLU;
10315+ stack[base + 5LLU] = 815LLU;
1004210316 // arguments for call to reportid
1004310317 stack[base + 6LLU] = stack[base + 1]/*id*/;
1004410318 // set stack-base & callee-address
@@ -10046,21 +10320,21 @@
1004610320 label = 18446744073709551586LLU; // reportid
1004710321 break;
1004810322 }
10049- case 778LLU: // copy-back deleter (reportid to reportidnr)
10323+ case 814LLU: // copy-back deleter (reportid to reportidnr)
1005010324 {
1005110325 fprintf(stderr, "in function reportidnr: unrolling stack, copy-back (reportid to reportidnr)\n");
1005210326 // copy mutable arguments back from call to reportid
10053- label = 775LLU; // continue to roll stack
10327+ label = 813LLU; // continue to roll stack
1005410328 break;
1005510329 }
10056- case 779LLU: // return from reportid to reportidnr
10330+ case 815LLU: // return from reportid to reportidnr
1005710331 {
1005810332 // copy mutable arguments back from call to reportid
1005910333 fprintf(stderr, "%s", " ");
1006010334 // call reportnr from reportidnr
10061- stack[base + 3LLU] = 780LLU/*throw to this address*/;
10335+ stack[base + 3LLU] = 816LLU/*throw to this address*/;
1006210336 stack[base + 4LLU] = base;
10063- stack[base + 5LLU] = 781LLU;
10337+ stack[base + 5LLU] = 817LLU;
1006410338 // arguments for call to reportnr
1006510339 stack[base + 6LLU] = stack[base + 2]/*nr*/;
1006610340 // set stack-base & callee-address
@@ -10068,27 +10342,34 @@
1006810342 label = 18446744073709551589LLU; // reportnr
1006910343 break;
1007010344 }
10071- case 780LLU: // copy-back deleter (reportnr to reportidnr)
10345+ case 816LLU: // copy-back deleter (reportnr to reportidnr)
1007210346 {
1007310347 fprintf(stderr, "in function reportidnr: unrolling stack, copy-back (reportnr to reportidnr)\n");
1007410348 // copy mutable arguments back from call to reportnr
10075- label = 775LLU; // continue to roll stack
10349+ label = 813LLU; // continue to roll stack
1007610350 break;
1007710351 }
10078- case 781LLU: // return from reportnr to reportidnr
10352+ case 817LLU: // return from reportnr to reportidnr
1007910353 {
1008010354 // copy mutable arguments back from call to reportnr
1008110355 ((uint64_t **)(stack[base + 0]))[1][1] = stack[base + 2];
1008210356 ((uint64_t **)(stack[base + 0]))[1][0] = stack[base + 1];
10083- label = 776LLU; // case complete
10357+ label = 811LLU; // case complete
1008410358 break;
1008510359 }
10086- case 777LLU: // try next case
10360+ case 813LLU: // copy-back deleter (switch)
1008710361 {
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+ {
1008810369 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1008910370 exit(-1);
1009010371 }
10091- case 776LLU: // completed switch
10372+ case 811LLU: // completed switch
1009210373 {
1009310374 // return from reportidnr
1009410375 label = stack[base - 1];
@@ -10095,7 +10376,7 @@
1009510376 base = stack[base - 2];
1009610377 break;
1009710378 }
10098- case 782LLU: // ~elcopyback
10379+ case 818LLU: // ~elcopyback
1009910380 {
1010010381 if(stack[base + 0]/*variant-nr*/ >= 1)
1010110382 {
@@ -10102,10 +10383,10 @@
1010210383 fprintf(stderr, "in ~elcopyback: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1010310384 exit(-1);
1010410385 }
10105- label = 782LLU + 1LLU + stack[base + 0]/*variant-nr*/;
10386+ label = 818LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1010610387 break;
1010710388 }
10108- case 782LLU + 1LLU + 0LLU: // ~elcopyback.elcopyback
10389+ case 818LLU + 1LLU + 0LLU: // ~elcopyback.elcopyback
1010910390 {
1011010391 // release element aliasindex
1011110392 // release element dataidx
@@ -10116,7 +10397,7 @@
1011610397 base = stack[base - 2];
1011710398 break;
1011810399 }
10119- case 785LLU: // function parsetype failed
10400+ case 821LLU: // function parsetype failed
1012010401 {
1012110402 fprintf(stderr, "function parsetype failed\n");
1012210403 label = stack[base - 3];
@@ -10123,7 +10404,7 @@
1012310404 base = stack[base - 2];
1012410405 break;
1012510406 }
10126- case 784LLU: // parsetype
10407+ case 820LLU: // parsetype
1012710408 {
1012810409 //#define res0 0
1012910410 //#define res1 1
@@ -10131,29 +10412,29 @@
1013110412 //#define arg1 3
1013210413 //#define arg2 4
1013310414 //#define arg3 5
10134- label = 787LLU; // skip deleter
10415+ label = 823LLU; // skip deleter
1013510416 break;
1013610417 }
10137- case 786LLU: // deleter
10418+ case 822LLU: // deleter
1013810419 {
1013910420 // throw from parsetype
1014010421 if(!stack[base + 6])
1014110422 {
1014210423 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
1014410425 break;
1014510426 }
1014610427 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
1014810429 break;
1014910430 }
10150- case 787LLU: // skipped deleter
10431+ case 823LLU: // skipped deleter
1015110432 {
1015210433 stack[base + 6] = 0;
1015310434 // call equ from parsetype
10154- stack[base + 7LLU] = 788LLU/*throw to this address*/;
10435+ stack[base + 7LLU] = 824LLU/*throw to this address*/;
1015510436 stack[base + 8LLU] = base;
10156- stack[base + 9LLU] = 789LLU;
10437+ stack[base + 9LLU] = 825LLU;
1015710438 // arguments for call to equ
1015810439 stack[base + 11LLU] = stack[base + 3]/*variant*/;
1015910440 stack[base + 12LLU] = 4LLU;
@@ -10162,14 +10443,14 @@
1016210443 label = 18446744073709551600LLU; // equ
1016310444 break;
1016410445 }
10165- case 788LLU: // copy-back deleter (equ to parsetype)
10446+ case 824LLU: // copy-back deleter (equ to parsetype)
1016610447 {
1016710448 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
1016810449 // copy mutable arguments back from call to equ
10169- label = 786LLU; // continue to roll stack
10450+ label = 822LLU; // continue to roll stack
1017010451 break;
1017110452 }
10172- case 789LLU: // return from equ to parsetype
10453+ case 825LLU: // return from equ to parsetype
1017310454 {
1017410455 // copy mutable arguments back from call to equ
1017510456 // copy back results provided by call to equ
@@ -10176,21 +10457,21 @@
1017610457 stack[base + 6] = stack[base + 10LLU];
1017710458 if(!stack[base + 6]/*isequal*/)
1017810459 {
10179- label = 790LLU; // jump to alternative
10460+ label = 826LLU; // jump to alternative
1018010461 break;
1018110462 }
1018210463
1018310464 // consequent
10184- label = 793LLU; // skip deleter
10465+ label = 829LLU; // skip deleter
1018510466 break;
1018610467 }
10187- case 792LLU: // deleter
10468+ case 828LLU: // deleter
1018810469 {
1018910470 // throw from parsetype
1019010471 if(!stack[base + 0])
1019110472 {
1019210473 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
1019410475 break;
1019510476 }
1019610477 fprintf(stderr, "in function parsetype: unrolling stack, variable type \n");
@@ -10200,7 +10481,7 @@
1020010481 newstack[0] = (uint64_t)stack; // backup stack location
1020110482 newstack[1] = 1234567890;
1020210483 newstack[2] = base;
10203- newstack[3] = 794LLU;
10484+ newstack[3] = 830LLU;
1020410485 stack = newstack;
1020510486 // set stack-base & callee-address
1020610487 base = 4/*deloffset*/;
@@ -10207,21 +10488,21 @@
1020710488 label = 295LLU; // ~type
1020810489 break;
1020910490 }
10210- case 794LLU: // return from ~type to parsetype
10491+ case 830LLU: // return from ~type to parsetype
1021110492 {
1021210493 stack = (uint64_t *)stack[0];
1021310494 // releasing toplevel container
1021410495 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1021510496
10216- label = 786LLU; // continue unrolling stack, delete next variable
10497+ label = 822LLU; // continue unrolling stack, delete next variable
1021710498 break;
1021810499 }
10219- case 793LLU: // skipped deleter
10500+ case 829LLU: // skipped deleter
1022010501 {
1022110502 // construct type.typename
1022210503 if(!(stack[base + 0] = construct(1)))
1022310504 {
10224- label = 786LLU; // throw: begin to unroll stack
10505+ label = 822LLU; // throw: begin to unroll stack
1022510506 break;
1022610507 }
1022710508
@@ -10228,34 +10509,34 @@
1022810509 // consequent
1022910510 ((uint64_t *)stack[base + 0])[0] = 0;
1023010511 (((uint64_t **)(stack[base + 0]))[1][0]) = stack[base + 4]/*content*/;
10231- label = 796LLU; // skip deleter
10512+ label = 832LLU; // skip deleter
1023210513 break;
1023310514 }
10234- case 795LLU: // deleter
10515+ case 831LLU: // deleter
1023510516 {
1023610517 // throw from parsetype
1023710518 if(!stack[base + 1])
1023810519 {
1023910520 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
1024110522 break;
1024210523 }
1024310524 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
1024510526 break;
1024610527 }
10247- case 796LLU: // skipped deleter
10528+ case 832LLU: // skipped deleter
1024810529 {
1024910530 stack[base + 1] = stack[base + 5]/*lookahead*/;
10250- label = 791LLU; // consequent complete
10531+ label = 827LLU; // consequent complete
1025110532 break;
1025210533 }
10253- case 790LLU: // alternative
10534+ case 826LLU: // alternative
1025410535 {
1025510536 // call equ from parsetype
10256- stack[base + 7LLU] = 797LLU/*throw to this address*/;
10537+ stack[base + 7LLU] = 833LLU/*throw to this address*/;
1025710538 stack[base + 8LLU] = base;
10258- stack[base + 9LLU] = 798LLU;
10539+ stack[base + 9LLU] = 834LLU;
1025910540 // arguments for call to equ
1026010541 stack[base + 11LLU] = stack[base + 3]/*variant*/;
1026110542 stack[base + 12LLU] = 0LLU;
@@ -10264,14 +10545,14 @@
1026410545 label = 18446744073709551600LLU; // equ
1026510546 break;
1026610547 }
10267- case 797LLU: // copy-back deleter (equ to parsetype)
10548+ case 833LLU: // copy-back deleter (equ to parsetype)
1026810549 {
1026910550 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
1027010551 // copy mutable arguments back from call to equ
10271- label = 786LLU; // continue to roll stack
10552+ label = 822LLU; // continue to roll stack
1027210553 break;
1027310554 }
10274- case 798LLU: // return from equ to parsetype
10555+ case 834LLU: // return from equ to parsetype
1027510556 {
1027610557 // copy mutable arguments back from call to equ
1027710558 // copy back results provided by call to equ
@@ -10278,15 +10559,15 @@
1027810559 stack[base + 6] = stack[base + 10LLU];
1027910560 if(!stack[base + 6]/*isequal*/)
1028010561 {
10281- label = 799LLU; // jump to alternative
10562+ label = 835LLU; // jump to alternative
1028210563 break;
1028310564 }
1028410565
1028510566 // consequent
1028610567 // call equ from parsetype
10287- stack[base + 7LLU] = 801LLU/*throw to this address*/;
10568+ stack[base + 7LLU] = 837LLU/*throw to this address*/;
1028810569 stack[base + 8LLU] = base;
10289- stack[base + 9LLU] = 802LLU;
10570+ stack[base + 9LLU] = 838LLU;
1029010571 // arguments for call to equ
1029110572 stack[base + 11LLU] = stack[base + 4]/*content*/;
1029210573 stack[base + 12LLU] = 91LLU;
@@ -10295,14 +10576,14 @@
1029510576 label = 18446744073709551600LLU; // equ
1029610577 break;
1029710578 }
10298- case 801LLU: // copy-back deleter (equ to parsetype)
10579+ case 837LLU: // copy-back deleter (equ to parsetype)
1029910580 {
1030010581 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (equ to parsetype)\n");
1030110582 // copy mutable arguments back from call to equ
10302- label = 786LLU; // continue to roll stack
10583+ label = 822LLU; // continue to roll stack
1030310584 break;
1030410585 }
10305- case 802LLU: // return from equ to parsetype
10586+ case 838LLU: // return from equ to parsetype
1030610587 {
1030710588 // copy mutable arguments back from call to equ
1030810589 // copy back results provided by call to equ
@@ -10309,15 +10590,15 @@
1030910590 stack[base + 6] = stack[base + 10LLU];
1031010591 if(!stack[base + 6]/*isequal*/)
1031110592 {
10312- label = 803LLU; // jump to alternative
10593+ label = 839LLU; // jump to alternative
1031310594 break;
1031410595 }
1031510596
1031610597 // consequent
1031710598 // call PARSETOKEN from parsetype
10318- stack[base + 7LLU] = 805LLU/*throw to this address*/;
10599+ stack[base + 7LLU] = 841LLU/*throw to this address*/;
1031910600 stack[base + 8LLU] = base;
10320- stack[base + 9LLU] = 806LLU;
10601+ stack[base + 9LLU] = 842LLU;
1032110602 // arguments for call to PARSETOKEN
1032210603 stack[base + 12LLU] = stack[base + 5]/*lookahead*/;
1032310604 // set stack-base & callee-address
@@ -10325,14 +10606,14 @@
1032510606 label = 18446744073709551584LLU; // PARSETOKEN
1032610607 break;
1032710608 }
10328- case 805LLU: // copy-back deleter (PARSETOKEN to parsetype)
10609+ case 841LLU: // copy-back deleter (PARSETOKEN to parsetype)
1032910610 {
1033010611 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (PARSETOKEN to parsetype)\n");
1033110612 // copy mutable arguments back from call to PARSETOKEN
10332- label = 786LLU; // continue to roll stack
10613+ label = 822LLU; // continue to roll stack
1033310614 break;
1033410615 }
10335- case 806LLU: // return from PARSETOKEN to parsetype
10616+ case 842LLU: // return from PARSETOKEN to parsetype
1033610617 {
1033710618 // copy mutable arguments back from call to PARSETOKEN
1033810619 // copy back results provided by call to PARSETOKEN
@@ -10341,7 +10622,7 @@
1034110622 uint64_t *newstack = (uint64_t *)Calloc(35LLU + 1, sizeof(uint64_t));
1034210623 if(!newstack)
1034310624 {
10344- label = 786LLU; // throw: begin to unroll stack
10625+ label = 822LLU; // throw: begin to unroll stack
1034510626 break;
1034610627 }
1034710628
@@ -10348,9 +10629,9 @@
1034810629 newstack[35LLU] = 9876543210LLU; // overflow-marker
1034910630 // call parsetype from parsetype
1035010631 newstack[0] = (uint64_t)stack; // backup stack location
10351- newstack[1] = 807LLU;
10632+ newstack[1] = 843LLU;
1035210633 newstack[2] = base;
10353- newstack[3] = 808LLU;
10634+ newstack[3] = 844LLU;
1035410635 // arguments for call to parsetype
1035510636 newstack[6LLU] = stack[base + 2]/*fnid*/;
1035610637 newstack[7LLU] = stack[base + 3]/*variant*/;
@@ -10359,10 +10640,10 @@
1035910640 stack = newstack;
1036010641 // set stack-base & callee-address
1036110642 base = 4/*deloffset*/;
10362- label = 784LLU; // parsetype
10643+ label = 820LLU; // parsetype
1036310644 break;
1036410645 }
10365- case 807LLU: // copy-back deleter (parsetype to parsetype)
10646+ case 843LLU: // copy-back deleter (parsetype to parsetype)
1036610647 {
1036710648 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (parsetype to parsetype)\n");
1036810649 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -10376,10 +10657,10 @@
1037610657 }
1037710658 Free(35LLU + 1, sizeof(uint64_t), stack);
1037810659 stack = oldstack;
10379- label = 786LLU; // continue to unroll stack
10660+ label = 822LLU; // continue to unroll stack
1038010661 break;
1038110662 }
10382- case 808LLU: // return from parsetype to parsetype
10663+ case 844LLU: // return from parsetype to parsetype
1038310664 {
1038410665 uint64_t *oldstack = (uint64_t *)stack[0];
1038510666 // copy mutable arguments back from call to parsetype
@@ -10396,9 +10677,9 @@
1039610677 Free(35LLU + 1, sizeof(uint64_t), stack);
1039710678 stack = oldstack;
1039810679 // call matchsym from parsetype
10399- stack[base + 9LLU] = 809LLU/*throw to this address*/;
10680+ stack[base + 9LLU] = 845LLU/*throw to this address*/;
1040010681 stack[base + 10LLU] = base;
10401- stack[base + 11LLU] = 810LLU;
10682+ stack[base + 11LLU] = 846LLU;
1040210683 // arguments for call to matchsym
1040310684 stack[base + 12LLU] = stack[base + 2]/*fnid*/;
1040410685 stack[base + 13LLU] = 93LLU;
@@ -10408,28 +10689,28 @@
1040810689 label = 211LLU; // matchsym
1040910690 break;
1041010691 }
10411- case 809LLU: // copy-back deleter (matchsym to parsetype)
10692+ case 845LLU: // copy-back deleter (matchsym to parsetype)
1041210693 {
1041310694 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (matchsym to parsetype)\n");
1041410695 // copy mutable arguments back from call to matchsym
1041510696 stack[base + 8]/*lookahead*/ = stack[base + 14LLU];
10416- label = 786LLU; // continue to roll stack
10697+ label = 822LLU; // continue to roll stack
1041710698 break;
1041810699 }
10419- case 810LLU: // return from matchsym to parsetype
10700+ case 846LLU: // return from matchsym to parsetype
1042010701 {
1042110702 // copy mutable arguments back from call to matchsym
1042210703 stack[base + 8]/*lookahead*/ = stack[base + 14LLU];
10423- label = 812LLU; // skip deleter
10704+ label = 848LLU; // skip deleter
1042410705 break;
1042510706 }
10426- case 811LLU: // deleter
10707+ case 847LLU: // deleter
1042710708 {
1042810709 // throw from parsetype
1042910710 if(!stack[base + 0])
1043010711 {
1043110712 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
1043310714 break;
1043410715 }
1043510716 fprintf(stderr, "in function parsetype: unrolling stack, variable type \n");
@@ -10439,7 +10720,7 @@
1043910720 newstack[0] = (uint64_t)stack; // backup stack location
1044010721 newstack[1] = 1234567890;
1044110722 newstack[2] = base;
10442- newstack[3] = 813LLU;
10723+ newstack[3] = 849LLU;
1044310724 stack = newstack;
1044410725 // set stack-base & callee-address
1044510726 base = 4/*deloffset*/;
@@ -10446,21 +10727,21 @@
1044610727 label = 295LLU; // ~type
1044710728 break;
1044810729 }
10449- case 813LLU: // return from ~type to parsetype
10730+ case 849LLU: // return from ~type to parsetype
1045010731 {
1045110732 stack = (uint64_t *)stack[0];
1045210733 // releasing toplevel container
1045310734 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1045410735
10455- label = 786LLU; // continue unrolling stack, delete next variable
10736+ label = 822LLU; // continue unrolling stack, delete next variable
1045610737 break;
1045710738 }
10458- case 812LLU: // skipped deleter
10739+ case 848LLU: // skipped deleter
1045910740 {
1046010741 // construct type.typelist
1046110742 if(!(stack[base + 0] = construct(1)))
1046210743 {
10463- label = 786LLU; // throw: begin to unroll stack
10744+ label = 822LLU; // throw: begin to unroll stack
1046410745 break;
1046510746 }
1046610747
@@ -10467,35 +10748,35 @@
1046710748 // consequent
1046810749 ((uint64_t *)stack[base + 0])[0] = 1;
1046910750 INIT(&(((uint64_t **)(stack[base + 0]))[1][0]), &stack[base + 7]/*subtype*/);
10470- label = 815LLU; // skip deleter
10751+ label = 851LLU; // skip deleter
1047110752 break;
1047210753 }
10473- case 814LLU: // deleter
10754+ case 850LLU: // deleter
1047410755 {
1047510756 // throw from parsetype
1047610757 if(!stack[base + 1])
1047710758 {
1047810759 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
1048010761 break;
1048110762 }
1048210763 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
1048410765 break;
1048510766 }
10486- case 815LLU: // skipped deleter
10767+ case 851LLU: // skipped deleter
1048710768 {
1048810769 stack[base + 1] = stack[base + 8]/*lookahead*/;
10489- label = 804LLU; // consequent complete
10770+ label = 840LLU; // consequent complete
1049010771 break;
1049110772 }
10492- case 803LLU: // alternative
10773+ case 839LLU: // alternative
1049310774 {
1049410775 fprintf(stderr, "%s", "parsing type: expected '[' but found ");
1049510776 // call reporttok from parsetype
10496- stack[base + 7LLU] = 816LLU/*throw to this address*/;
10777+ stack[base + 7LLU] = 852LLU/*throw to this address*/;
1049710778 stack[base + 8LLU] = base;
10498- stack[base + 9LLU] = 817LLU;
10779+ stack[base + 9LLU] = 853LLU;
1049910780 // arguments for call to reporttok
1050010781 stack[base + 10LLU] = stack[base + 3]/*variant*/;
1050110782 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -10504,33 +10785,33 @@
1050410785 label = 18446744073709551582LLU; // reporttok
1050510786 break;
1050610787 }
10507- case 816LLU: // copy-back deleter (reporttok to parsetype)
10788+ case 852LLU: // copy-back deleter (reporttok to parsetype)
1050810789 {
1050910790 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (reporttok to parsetype)\n");
1051010791 // copy mutable arguments back from call to reporttok
10511- label = 786LLU; // continue to roll stack
10792+ label = 822LLU; // continue to roll stack
1051210793 break;
1051310794 }
10514- case 817LLU: // return from reporttok to parsetype
10795+ case 853LLU: // return from reporttok to parsetype
1051510796 {
1051610797 // copy mutable arguments back from call to reporttok
1051710798 fprintf(stderr, "%s", "\n");
1051810799 exit(-1);
10519- label = 804LLU; // alternative complete
10800+ label = 840LLU; // alternative complete
1052010801 break;
1052110802 }
10522- case 804LLU: // completed if-then-else
10803+ case 840LLU: // completed if-then-else
1052310804 {
10524- label = 800LLU; // consequent complete
10805+ label = 836LLU; // consequent complete
1052510806 break;
1052610807 }
10527- case 799LLU: // alternative
10808+ case 835LLU: // alternative
1052810809 {
1052910810 fprintf(stderr, "%s", "parsing type: expected identifier but found ");
1053010811 // call reporttok from parsetype
10531- stack[base + 7LLU] = 818LLU/*throw to this address*/;
10812+ stack[base + 7LLU] = 854LLU/*throw to this address*/;
1053210813 stack[base + 8LLU] = base;
10533- stack[base + 9LLU] = 819LLU;
10814+ stack[base + 9LLU] = 855LLU;
1053410815 // arguments for call to reporttok
1053510816 stack[base + 10LLU] = stack[base + 3]/*variant*/;
1053610817 stack[base + 11LLU] = stack[base + 4]/*content*/;
@@ -10539,27 +10820,27 @@
1053910820 label = 18446744073709551582LLU; // reporttok
1054010821 break;
1054110822 }
10542- case 818LLU: // copy-back deleter (reporttok to parsetype)
10823+ case 854LLU: // copy-back deleter (reporttok to parsetype)
1054310824 {
1054410825 fprintf(stderr, "in function parsetype: unrolling stack, copy-back (reporttok to parsetype)\n");
1054510826 // copy mutable arguments back from call to reporttok
10546- label = 786LLU; // continue to roll stack
10827+ label = 822LLU; // continue to roll stack
1054710828 break;
1054810829 }
10549- case 819LLU: // return from reporttok to parsetype
10830+ case 855LLU: // return from reporttok to parsetype
1055010831 {
1055110832 // copy mutable arguments back from call to reporttok
1055210833 fprintf(stderr, "%s", "\n");
1055310834 exit(-1);
10554- label = 800LLU; // alternative complete
10835+ label = 836LLU; // alternative complete
1055510836 break;
1055610837 }
10557- case 800LLU: // completed if-then-else
10838+ case 836LLU: // completed if-then-else
1055810839 {
10559- label = 791LLU; // alternative complete
10840+ label = 827LLU; // alternative complete
1056010841 break;
1056110842 }
10562- case 791LLU: // completed if-then-else
10843+ case 827LLU: // completed if-then-else
1056310844 {
1056410845 // return from parsetype
1056510846 label = stack[base - 1];
@@ -10566,7 +10847,7 @@
1056610847 base = stack[base - 2];
1056710848 break;
1056810849 }
10569- case 821LLU: // function PARSETYPE failed
10850+ case 857LLU: // function PARSETYPE failed
1057010851 {
1057110852 fprintf(stderr, "function PARSETYPE failed\n");
1057210853 label = stack[base - 3];
@@ -10573,7 +10854,7 @@
1057310854 base = stack[base - 2];
1057410855 break;
1057510856 }
10576- case 820LLU: // PARSETYPE
10857+ case 856LLU: // PARSETYPE
1057710858 {
1057810859 //#define res0 0
1057910860 //#define arg0 1
@@ -10583,7 +10864,7 @@
1058310864 uint64_t *newstack = (uint64_t *)Calloc(35LLU + 1, sizeof(uint64_t));
1058410865 if(!newstack)
1058510866 {
10586- label = 821LLU; // throw: begin to unroll stack
10867+ label = 857LLU; // throw: begin to unroll stack
1058710868 break;
1058810869 }
1058910870
@@ -10590,9 +10871,9 @@
1059010871 newstack[35LLU] = 9876543210LLU; // overflow-marker
1059110872 // call parsetype from PARSETYPE
1059210873 newstack[0] = (uint64_t)stack; // backup stack location
10593- newstack[1] = 822LLU;
10874+ newstack[1] = 858LLU;
1059410875 newstack[2] = base;
10595- newstack[3] = 823LLU;
10876+ newstack[3] = 859LLU;
1059610877 // arguments for call to parsetype
1059710878 newstack[6LLU] = stack[base + 1]/*fnid*/;
1059810879 newstack[7LLU] = stack[base + 2]/*variant*/;
@@ -10601,10 +10882,10 @@
1060110882 stack = newstack;
1060210883 // set stack-base & callee-address
1060310884 base = 4/*deloffset*/;
10604- label = 784LLU; // parsetype
10885+ label = 820LLU; // parsetype
1060510886 break;
1060610887 }
10607- case 822LLU: // copy-back deleter (parsetype to PARSETYPE)
10888+ case 858LLU: // copy-back deleter (parsetype to PARSETYPE)
1060810889 {
1060910890 fprintf(stderr, "in function PARSETYPE: unrolling stack, copy-back (parsetype to PARSETYPE)\n");
1061010891 uint64_t *oldstack = (uint64_t *)stack[0];
@@ -10618,10 +10899,10 @@
1061810899 }
1061910900 Free(35LLU + 1, sizeof(uint64_t), stack);
1062010901 stack = oldstack;
10621- label = 821LLU; // continue to unroll stack
10902+ label = 857LLU; // continue to unroll stack
1062210903 break;
1062310904 }
10624- case 823LLU: // return from parsetype to PARSETYPE
10905+ case 859LLU: // return from parsetype to PARSETYPE
1062510906 {
1062610907 uint64_t *oldstack = (uint64_t *)stack[0];
1062710908 // copy mutable arguments back from call to parsetype
@@ -10638,16 +10919,16 @@
1063810919 Free(35LLU + 1, sizeof(uint64_t), stack);
1063910920 stack = oldstack;
1064010921 stack[base + 4]/*lookahead*/ = stack[base + 6]/*LOOKAHEAD*/;
10641- label = 825LLU; // skip deleter
10922+ label = 861LLU; // skip deleter
1064210923 break;
1064310924 }
10644- case 824LLU: // deleter
10925+ case 860LLU: // deleter
1064510926 {
1064610927 // throw from PARSETYPE
1064710928 if(!stack[base + 0])
1064810929 {
1064910930 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
1065110932 break;
1065210933 }
1065310934 fprintf(stderr, "in function PARSETYPE: unrolling stack, variable type \n");
@@ -10657,7 +10938,7 @@
1065710938 newstack[0] = (uint64_t)stack; // backup stack location
1065810939 newstack[1] = 1234567890;
1065910940 newstack[2] = base;
10660- newstack[3] = 826LLU;
10941+ newstack[3] = 862LLU;
1066110942 stack = newstack;
1066210943 // set stack-base & callee-address
1066310944 base = 4/*deloffset*/;
@@ -10664,16 +10945,16 @@
1066410945 label = 295LLU; // ~type
1066510946 break;
1066610947 }
10667- case 826LLU: // return from ~type to PARSETYPE
10948+ case 862LLU: // return from ~type to PARSETYPE
1066810949 {
1066910950 stack = (uint64_t *)stack[0];
1067010951 // releasing toplevel container
1067110952 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1067210953
10673- label = 821LLU; // continue unrolling stack, delete next variable
10954+ label = 857LLU; // continue unrolling stack, delete next variable
1067410955 break;
1067510956 }
10676- case 825LLU: // skipped deleter
10957+ case 861LLU: // skipped deleter
1067710958 {
1067810959 INIT(&stack[base + 0], &stack[base + 5]/*type*/);
1067910960 // return from PARSETYPE
@@ -10681,7 +10962,7 @@
1068110962 base = stack[base - 2];
1068210963 break;
1068310964 }
10684- case 827LLU: // ~variant
10965+ case 863LLU: // ~variant
1068510966 {
1068610967 if(stack[base + 0]/*variant-nr*/ >= 1)
1068710968 {
@@ -10688,23 +10969,23 @@
1068810969 fprintf(stderr, "in ~variant: unknown variant-nr %d\n", (int)stack[base + 0]/*variant-nr*/);
1068910970 exit(-1);
1069010971 }
10691- label = 827LLU + 1LLU + stack[base + 0]/*variant-nr*/;
10972+ label = 863LLU + 1LLU + stack[base + 0]/*variant-nr*/;
1069210973 break;
1069310974 }
10694- case 827LLU + 1LLU + 0LLU: // ~variant.variant
10975+ case 863LLU + 1LLU + 0LLU: // ~variant.variant
1069510976 {
1069610977 // release element id
1069710978 // release element elements
1069810979 stack[base + 0] = ((uint64_t *)stack[base + 1]/*variant-nr*/)[1/*element-nr*/];
1069910980 // delete list
10700- label = 829LLU; // start to repeat
10981+ label = 865LLU; // start to repeat
1070110982 break;
1070210983 }
10703- case 829LLU: // repeat from here
10984+ case 865LLU: // repeat from here
1070410985 {
1070510986 if(!stack[base + 0])
1070610987 {
10707- label = 830LLU; // break loop
10988+ label = 866LLU; // break loop
1070810989 break;
1070910990 }
1071010991
@@ -10715,14 +10996,14 @@
1071510996 newstack[0] = (uint64_t)stack; // backup stack location
1071610997 newstack[1] = 1234567890;
1071710998 newstack[2] = base;
10718- newstack[3] = 831LLU;
10999+ newstack[3] = 867LLU;
1071911000 stack = newstack;
1072011001 // set stack-base & callee-address
1072111002 base = 4/*deloffset*/;
10722- label = 346LLU; // ~typeid
11003+ label = 354LLU; // ~typeid
1072311004 break;
1072411005 }
10725- case 831LLU: // return from ~typeid to variant
11006+ case 867LLU: // return from ~typeid to variant
1072611007 {
1072711008 stack = (uint64_t *)stack[0];
1072811009 // releasing toplevel container
@@ -10733,10 +11014,10 @@
1073311014 stack[base + 0] = (uint64_t)list->next;
1073411015 Free(1, sizeof(struct listnode), list);
1073511016 }
10736- label = 829LLU; // repeat
11017+ label = 865LLU; // repeat
1073711018 break;
1073811019 }
10739- case 830LLU: // loop finished
11020+ case 866LLU: // loop finished
1074011021 {
1074111022 // release variant container
1074211023 Free(2, sizeof(uint64_t), ((uint64_t *)stack[base + 1]/*variant*/));
@@ -10744,7 +11025,7 @@
1074411025 base = stack[base - 2];
1074511026 break;
1074611027 }
10747- case 833LLU: // function mkvariantd failed
11028+ case 869LLU: // function mkvariantd failed
1074811029 {
1074911030 fprintf(stderr, "function mkvariantd failed\n");
1075011031 label = stack[base - 3];
@@ -10751,50 +11032,50 @@
1075111032 base = stack[base - 2];
1075211033 break;
1075311034 }
10754- case 832LLU: // mkvariantd
11035+ case 868LLU: // mkvariantd
1075511036 {
1075611037 //#define res0 0
10757- label = 835LLU; // skip deleter
11038+ label = 871LLU; // skip deleter
1075811039 break;
1075911040 }
10760- case 834LLU: // deleter
11041+ case 870LLU: // deleter
1076111042 {
1076211043 // throw from mkvariantd
1076311044 if(!stack[base + 1])
1076411045 {
1076511046 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
1076711048 break;
1076811049 }
1076911050 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
1077111052 break;
1077211053 }
10773- case 835LLU: // skipped deleter
11054+ case 871LLU: // skipped deleter
1077411055 {
1077511056 stack[base + 1] = 0;
10776- label = 837LLU; // skip deleter
11057+ label = 873LLU; // skip deleter
1077711058 break;
1077811059 }
10779- case 836LLU: // deleter
11060+ case 872LLU: // deleter
1078011061 {
1078111062 // throw from mkvariantd
1078211063 if(!stack[base + 2])
1078311064 {
1078411065 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
1078611067 break;
1078711068 }
1078811069 fprintf(stderr, "in function mkvariantd: unrolling stack, variable [typeid] \n");
1078911070 // delete list
10790- label = 838LLU; // start to repeat
11071+ label = 874LLU; // start to repeat
1079111072 break;
1079211073 }
10793- case 838LLU: // repeat from here
11074+ case 874LLU: // repeat from here
1079411075 {
1079511076 if(!stack[base + 2])
1079611077 {
10797- label = 839LLU; // break loop
11078+ label = 875LLU; // break loop
1079811079 break;
1079911080 }
1080011081
@@ -10805,14 +11086,14 @@
1080511086 newstack[0] = (uint64_t)stack; // backup stack location
1080611087 newstack[1] = 1234567890;
1080711088 newstack[2] = base;
10808- newstack[3] = 840LLU;
11089+ newstack[3] = 876LLU;
1080911090 stack = newstack;
1081011091 // set stack-base & callee-address
1081111092 base = 4/*deloffset*/;
10812- label = 346LLU; // ~typeid
11093+ label = 354LLU; // ~typeid
1081311094 break;
1081411095 }
10815- case 840LLU: // return from ~typeid to mkvariantd
11096+ case 876LLU: // return from ~typeid to mkvariantd
1081611097 {
1081711098 stack = (uint64_t *)stack[0];
1081811099 // releasing toplevel container
@@ -10823,27 +11104,27 @@
1082311104 stack[base + 2] = (uint64_t)list->next;
1082411105 Free(1, sizeof(struct listnode), list);
1082511106 }
10826- label = 838LLU; // repeat
11107+ label = 874LLU; // repeat
1082711108 break;
1082811109 }
10829- case 839LLU: // loop finished
11110+ case 875LLU: // loop finished
1083011111 {
10831- label = 834LLU; // continue unrolling stack, delete next variable
11112+ label = 870LLU; // continue unrolling stack, delete next variable
1083211113 break;
1083311114 }
10834- case 837LLU: // skipped deleter
11115+ case 873LLU: // skipped deleter
1083511116 {
1083611117 stack[base + 2] = 0;
10837- label = 842LLU; // skip deleter
11118+ label = 878LLU; // skip deleter
1083811119 break;
1083911120 }
10840- case 841LLU: // deleter
11121+ case 877LLU: // deleter
1084111122 {
1084211123 // throw from mkvariantd
1084311124 if(!stack[base + 0])
1084411125 {
1084511126 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
1084711128 break;
1084811129 }
1084911130 fprintf(stderr, "in function mkvariantd: unrolling stack, variable variant \n");
@@ -10853,28 +11134,28 @@
1085311134 newstack[0] = (uint64_t)stack; // backup stack location
1085411135 newstack[1] = 1234567890;
1085511136 newstack[2] = base;
10856- newstack[3] = 843LLU;
11137+ newstack[3] = 879LLU;
1085711138 stack = newstack;
1085811139 // set stack-base & callee-address
1085911140 base = 4/*deloffset*/;
10860- label = 827LLU; // ~variant
11141+ label = 863LLU; // ~variant
1086111142 break;
1086211143 }
10863- case 843LLU: // return from ~variant to mkvariantd
11144+ case 879LLU: // return from ~variant to mkvariantd
1086411145 {
1086511146 stack = (uint64_t *)stack[0];
1086611147 // releasing toplevel container
1086711148 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1086811149
10869- label = 836LLU; // continue unrolling stack, delete next variable
11150+ label = 872LLU; // continue unrolling stack, delete next variable
1087011151 break;
1087111152 }
10872- case 842LLU: // skipped deleter
11153+ case 878LLU: // skipped deleter
1087311154 {
1087411155 // construct variant.variant
1087511156 if(!(stack[base + 0] = construct(2)))
1087611157 {
10877- label = 836LLU; // throw: begin to unroll stack
11158+ label = 872LLU; // throw: begin to unroll stack
1087811159 break;
1087911160 }
1088011161
@@ -10887,7 +11168,7 @@
1088711168 base = stack[base - 2];
1088811169 break;
1088911170 }
10890- case 845LLU: // function cpvariant failed
11171+ case 881LLU: // function cpvariant failed
1089111172 {
1089211173 fprintf(stderr, "function cpvariant failed\n");
1089311174 label = stack[base - 3];
@@ -10894,13 +11175,13 @@
1089411175 base = stack[base - 2];
1089511176 break;
1089611177 }
10897- case 844LLU: // cpvariant
11178+ case 880LLU: // cpvariant
1089811179 {
1089911180 //#define res0 0
1090011181 //#define arg0 1
1090111182 if(/*variant*/0 != ((uint64_t *)(stack[base + 1]/*original*/))[0])
1090211183 {
10903- label = 847LLU; // jump to alternative
11184+ label = 883LLU; // jump to alternative
1090411185 break;
1090511186 }
1090611187
@@ -10908,47 +11189,47 @@
1090811189 /*oelements*/stack[base + 3] = ((uint64_t **)(stack[base + 1]/*original*/))[1][1]/*elements*/;
1090911190
1091011191 // case
10911- label = 849LLU; // skip deleter
11192+ label = 886LLU; // skip deleter
1091211193 break;
1091311194 }
10914- case 848LLU: // deleter
11195+ case 885LLU: // deleter
1091511196 {
1091611197 // throw from cpvariant
1091711198 if(!stack[base + 4])
1091811199 {
1091911200 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
1092111202 break;
1092211203 }
1092311204 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
1092511206 break;
1092611207 }
10927- case 849LLU: // skipped deleter
11208+ case 886LLU: // skipped deleter
1092811209 {
1092911210 stack[base + 4] = stack[base + 2]/*oid*/;
10930- label = 851LLU; // skip deleter
11211+ label = 888LLU; // skip deleter
1093111212 break;
1093211213 }
10933- case 850LLU: // deleter
11214+ case 887LLU: // deleter
1093411215 {
1093511216 // throw from cpvariant
1093611217 if(!stack[base + 5])
1093711218 {
1093811219 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
1094011221 break;
1094111222 }
1094211223 fprintf(stderr, "in function cpvariant: unrolling stack, variable [typeid] \n");
1094311224 // delete list
10944- label = 852LLU; // start to repeat
11225+ label = 889LLU; // start to repeat
1094511226 break;
1094611227 }
10947- case 852LLU: // repeat from here
11228+ case 889LLU: // repeat from here
1094811229 {
1094911230 if(!stack[base + 5])
1095011231 {
10951- label = 853LLU; // break loop
11232+ label = 890LLU; // break loop
1095211233 break;
1095311234 }
1095411235
@@ -10959,14 +11240,14 @@
1095911240 newstack[0] = (uint64_t)stack; // backup stack location
1096011241 newstack[1] = 1234567890;
1096111242 newstack[2] = base;
10962- newstack[3] = 854LLU;
11243+ newstack[3] = 891LLU;
1096311244 stack = newstack;
1096411245 // set stack-base & callee-address
1096511246 base = 4/*deloffset*/;
10966- label = 346LLU; // ~typeid
11247+ label = 354LLU; // ~typeid
1096711248 break;
1096811249 }
10969- case 854LLU: // return from ~typeid to cpvariant
11250+ case 891LLU: // return from ~typeid to cpvariant
1097011251 {
1097111252 stack = (uint64_t *)stack[0];
1097211253 // releasing toplevel container
@@ -10977,26 +11258,26 @@
1097711258 stack[base + 5] = (uint64_t)list->next;
1097811259 Free(1, sizeof(struct listnode), list);
1097911260 }
10980- label = 852LLU; // repeat
11261+ label = 889LLU; // repeat
1098111262 break;
1098211263 }
10983- case 853LLU: // loop finished
11264+ case 890LLU: // loop finished
1098411265 {
10985- label = 848LLU; // continue unrolling stack, delete next variable
11266+ label = 885LLU; // continue unrolling stack, delete next variable
1098611267 break;
1098711268 }
10988- case 851LLU: // skipped deleter
11269+ case 888LLU: // skipped deleter
1098911270 {
1099011271 stack[base + 5] = 0;
1099111272 flippedassign(stack[base + 3]/*oelements*/, &stack[base + 6]);
10992- label = 855LLU; // start to repeat
11273+ label = 892LLU; // start to repeat
1099311274 break;
1099411275 }
10995- case 855LLU: // repeat from here
11276+ case 892LLU: // repeat from here
1099611277 {
1099711278 if(!stack[base + 6])
1099811279 {
10999- label = 856LLU; // break loop
11280+ label = 893LLU; // break loop
1100011281 break;
1100111282 }
1100211283
@@ -11005,24 +11286,24 @@
1100511286 stack[base + 8]/*previous*/ = stack[base + 6];
1100611287 stack[base + 6] = (uint64_t)(((const struct listnode *)(stack[base + 6]))->next);
1100711288 // call copytypeid from cpvariant
11008- stack[base + 10LLU] = 857LLU/*throw to this address*/;
11289+ stack[base + 10LLU] = 894LLU/*throw to this address*/;
1100911290 stack[base + 11LLU] = base;
11010- stack[base + 12LLU] = 858LLU;
11291+ stack[base + 12LLU] = 895LLU;
1101111292 // arguments for call to copytypeid
1101211293 stack[base + 14LLU] = stack[base + 7]/*oelement*/;
1101311294 // set stack-base & callee-address
1101411295 base += 13LLU;
11015- label = 349LLU; // copytypeid
11296+ label = 357LLU; // copytypeid
1101611297 break;
1101711298 }
11018- case 857LLU: // copy-back deleter (copytypeid to cpvariant)
11299+ case 894LLU: // copy-back deleter (copytypeid to cpvariant)
1101911300 {
1102011301 fprintf(stderr, "in function cpvariant: unrolling stack, copy-back (copytypeid to cpvariant)\n");
1102111302 // copy mutable arguments back from call to copytypeid
11022- label = 850LLU; // continue to roll stack
11303+ label = 887LLU; // continue to roll stack
1102311304 break;
1102411305 }
11025- case 858LLU: // return from copytypeid to cpvariant
11306+ case 895LLU: // return from copytypeid to cpvariant
1102611307 {
1102711308 // copy mutable arguments back from call to copytypeid
1102811309 // copy back results provided by call to copytypeid
@@ -11039,22 +11320,22 @@
1103911320 MOVE(&list->data, &stack[base + 9]/*celement*/);
1104011321 }
1104111322 ((struct listnode *)(stack[base + 8]/*previous*/))->data = stack[base + 7];
11042- label = 855LLU; // repeat
11323+ label = 892LLU; // repeat
1104311324 break;
1104411325 }
11045- case 856LLU: // loop finished
11326+ case 893LLU: // loop finished
1104611327 {
1104711328 list_reverse(((struct listnode **)(&stack[base + 5]/*celements*/)));
11048- label = 860LLU; // skip deleter
11329+ label = 897LLU; // skip deleter
1104911330 break;
1105011331 }
11051- case 859LLU: // deleter
11332+ case 896LLU: // deleter
1105211333 {
1105311334 // throw from cpvariant
1105411335 if(!stack[base + 0])
1105511336 {
1105611337 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
1105811339 break;
1105911340 }
1106011341 fprintf(stderr, "in function cpvariant: unrolling stack, variable variant \n");
@@ -11064,28 +11345,28 @@
1106411345 newstack[0] = (uint64_t)stack; // backup stack location
1106511346 newstack[1] = 1234567890;
1106611347 newstack[2] = base;
11067- newstack[3] = 861LLU;
11348+ newstack[3] = 898LLU;
1106811349 stack = newstack;
1106911350 // set stack-base & callee-address
1107011351 base = 4/*deloffset*/;
11071- label = 827LLU; // ~variant
11352+ label = 863LLU; // ~variant
1107211353 break;
1107311354 }
11074- case 861LLU: // return from ~variant to cpvariant
11355+ case 898LLU: // return from ~variant to cpvariant
1107511356 {
1107611357 stack = (uint64_t *)stack[0];
1107711358 // releasing toplevel container
1107811359 Free(2 + 4, sizeof(uint64_t), (uint64_t *)(stack[base + 0] - sizeof(uint64_t) * 4));
1107911360
11080- label = 850LLU; // continue unrolling stack, delete next variable
11361+ label = 887LLU; // continue unrolling stack, delete next variable
1108111362 break;
1108211363 }
11083- case 860LLU: // skipped deleter
11364+ case 897LLU: // skipped deleter
1108411365 {
1108511366 // construct variant.variant
1108611367 if(!(stack[base + 0] = construct(2)))
1108711368 {
11088- label = 850LLU; // throw: begin to unroll stack
11369+ label = 887LLU; // throw: begin to unroll stack
1108911370 break;
1109011371 }
1109111372
@@ -11095,15 +11376,22 @@
1109511376 INIT(&(((uint64_t **)(stack[base + 0]))[1][1]), &stack[base + 5]/*celements*/);
1109611377 ((uint64_t **)(stack[base + 1]))[1][1] = stack[base + 3];
1109711378 ((uint64_t **)(stack[base + 1]))[1][0] = stack[base + 2];
11098- label = 846LLU; // case complete
11379+ label = 882LLU; // case complete
1109911380 break;
1110011381 }
11101- case 847LLU: // try next case
11382+ case 884LLU: // copy-back deleter (switch)
1110211383 {
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+ {
1110311391 fprintf(stderr, "INTERNAL ERROR: UNREACHABLE CASE\n");
1110411392 exit(-1);
1110511393 }
11106- case 846LLU: // completed switch
11394+ case 882LLU: // completed switch
1110711395 {
1110811396 // return from cpvariant
1110911397 label = stack[base - 1];
@@ -11110,7 +11398,7 @@
1111011398 base = stack[base - 2];
1111111399 break;
1111211400 }
11113- case 863LLU: // function GetVariant failed
11401+ case 900LLU: // function GetVariant failed
1111411402 {
1111511403 fprintf(stderr, "function GetVariant failed\n");
1111611